Java Backend Engineer · OOP & SOLID by conviction · Homelab & Infrastructure · Learning Rust
- Java backend developer. Java 21 and Maven are my default. Spring Boot is where most of my work lives.
- OOP and SOLID are how I think, not a checklist I tick. I would rather split a feature across ten small, single-responsibility classes than hide it in one clever one.
- I like understanding systems all the way down — I rarely ship something I can't explain from first principles.
- I run my own self-hosted homelab and treat my own infrastructure as a playground for doing things properly.
- I build agentic AI workflows into my daily development to move faster without losing rigor.
- Currently learning: Rust — and shipping with it. Both of my Prometheus exporters are written in it.
The opinions I actually apply, not the ones I would put on a slide:
- Strict SOLID. Single responsibility down to the class level; dependencies inverted onto interfaces, not implementations.
- Many small files over few large classes. A 600-line service class is a design failure, not a milestone.
- Checked exceptions by default in Java. Unchecked only for genuinely fatal runtime conditions — an API should force the caller to reckon with what can go wrong.
- Javadoc on every method. Inline comments only where the code is genuinely hard for a third party to read: non-trivial lambdas, bit manipulation, regex. Everywhere else, the code should carry itself.
- JUnit is part of the deliverable, not an afterthought.
- PostgreSQL for anything that has to persist. H2 for embedded development.
- Prometheus for time-series. Always.
| Area | Technologies |
|---|---|
| Languages |  -000000?style=flat&logo=rust&logoColor=white){kind=icon}   |
| Backend |     |
| Data |   |
| Infra & DevOps |      |
| Tools |    |
Java Backend Engineering Spring Boot services, clean domain models, and APIs designed so the next person can extend them without reading my mind. I care about the boundaries between layers more than about clever code inside them.
Applied Cryptography & Security Building credential and data management with AES-256-GCM, a KEK/DEK key hierarchy, and PBKDF2 key derivation — implemented from the primitives up, because "we use encryption" means nothing without knowing which mistakes it does and doesn't protect you from.
Homelab & Self-Hosting Running my own services on my own metal — containerized with Docker, reverse-proxied through Traefik with automatic TLS, monitored with Prometheus and Grafana, and secured behind a VPN and dynamic DNS. If it can be self-hosted, I'd rather own it than rent it.
AI & Agentic Workflows Building agentic developer tooling around Claude Code, custom agents, and MCP servers — from AI-assisted reviews and debugging to a self-hosted "second brain" that keeps long-term knowledge searchable. I treat AI as an interrogated senior dev, not an autocomplete.
Learning Rust Coming from a garbage-collected, OOP-heavy world, Rust forces me to be explicit about things Java lets me ignore: ownership, borrowing, lifetimes. Both of my Prometheus exporters are written in it — I learn a language by shipping something with it, not by reading about it.
