Engineering Knowledge Hub
Practical answers to real engineering questions.
Articles with code, common mistakes and trade-offs — from Java fundamentals to enterprise architecture. Free, no sign-up.
42 articles
- ADRs
Writing Architecture Decision Records that survive the team
What an ADR is, a minimal template, the status lifecycle, examples of a good and a weak record, and how to keep records next to the code so they get read.
8 min readBeginnerTech Lead, Architect
- AI in backend systems
How to use AI coding agents safely in a real project
Context files for an AI agent in a Java/Spring Boot project (CLAUDE.md, AGENTS.md), a task contract, prompt injection through PRs and READMEs, sandboxing and least-privilege permissions, negative authorization tests, SAST/SCA/secret scanning and human approval before merge.
11 min readIntermediateMiddle, Senior, Tech Lead
- AI in backend systems
Calling an LLM from a backend service safely
Treat a language model as an unreliable remote dependency. Validated tool calls, timeouts, retries, budgets, prompt-injection defence, privacy-aware logging and evaluation.
6 min readIntermediateMiddle, Senior
- API security
API security for backend engineers with the OWASP API Security Top 10
Fix broken object level authorization and mass assignment, add rate limiting and input validation, handle secrets and logs safely, and use a review checklist built on the OWASP API Security Top 10 categories.
7 min readIntermediateMiddle, Senior
- C4 model
The C4 model: architecture diagrams that people actually read
How to use the four C4 levels (context, container, component, code), who each diagram is for, notation tips and how to keep diagrams from rotting.
8 min readIntermediateTech Lead, Architect
- System design
Caching strategies - cache-aside, write-through, TTLs and stampedes
Cache-aside, read-through and write-through compared, how to choose TTLs, invalidate safely, prevent stampedes, what not to cache, and which Redis data structures fit which job.
6 min readIntermediateMiddle, Senior
- CI/CD
A CI/CD pipeline for a Java service
Design a pipeline from commit to deploy: build, test, static checks, image, promotion between environments, rollbacks and secrets. Includes a GitHub Actions-style example.
7 min readIntermediateMiddle
- Clean architecture
Pragmatic clean architecture in a Spring application
The dependency rule, ports and adapters in Spring Boot, how they improve testing, and an honest look at where the structure pays off and where it is just ceremony.
8 min readIntermediateSenior
- Cloud architecture
Cloud architecture basics for backend engineers
Regions and zones, managed versus self-hosted services, stateless design, database choices, cost drivers and the shared-responsibility model, explained in vendor-neutral terms.
6 min readIntermediateMiddle, Senior
- Technical leadership
Code review culture that helps teams
What reviews are for, how to keep Pull Requests small, how to separate blocking comments from nits, how to phrase feedback kindly, and how to disagree productively.
6 min readBeginnerMiddle, Tech Lead
- DDD
DDD aggregates, bounded contexts and invariants
Ubiquitous language, bounded contexts, aggregates as consistency boundaries, protecting invariants, referencing other aggregates by id and publishing domain events, with Java examples.
7 min readAdvancedSenior, Architect
- Distributed systems
Failure handling in distributed systems
Timeouts, retries with backoff and jitter, circuit breakers, bulkheads and fallbacks. How partial failure spreads between services and how Resilience4j concepts contain it.
7 min readAdvancedSenior
- Docker
Docker for Java services
Build small, safe images for Spring Boot services. Multi-stage builds, layered jars, JRE base images, non-root users, container memory, health checks and docker compose for local development.
7 min readBeginnerJunior, Middle
- Enterprise architecture
Enterprise architecture: capabilities, portfolios and governance without bureaucracy
What enterprise architecture is, how it differs from solution architecture, and how capability maps, application portfolios, standards and target architectures work together without turning into paperwork.
5 min readAdvancedArchitect
- Event-driven architecture
Event-driven architecture trade-offs
Events versus commands, choreography versus orchestration, eventual consistency in the UI, schema evolution, debugging, and the cases where a plain synchronous call is the better design.
6 min readAdvancedSenior, Architect
- Distributed systems
Idempotency patterns for safe retries
Why retries create duplicates, and how idempotency keys, stored request hashes and outcomes, natural idempotency and expiry make payment-style operations safe to repeat.
7 min readIntermediateMiddle, Senior
- Java Core
Choosing the right Java collection
Pick List, Set, Map or Deque by access pattern. ArrayList versus LinkedList, HashMap versus TreeMap versus LinkedHashMap, immutable collections and a decision table.
6 min readBeginnerJunior
- Advanced Java
Java concurrency basics
Threads versus ExecutorService, visibility and happens-before, volatile versus synchronized, atomic classes, ConcurrentHashMap, and a race condition with its fix.
8 min readIntermediateMiddle
- Java Core
The equals and hashCode contract in Java
Why equals and hashCode must agree, how a mutable key disappears from a HashMap, and when to use records, IDE generation or a compareTo-consistent ordering.
7 min readBeginnerJunior
- Java Core
Designing exceptions in Java services
Checked versus unchecked exceptions, wrapping with a cause, never swallowing errors, domain exceptions, translating them to HTTP at the edge, and try-with-resources.
7 min readBeginnerJunior, Middle
- Advanced Java
Java memory and garbage collection for service developers
Where a JVM keeps its data, how generational garbage collection works, how to size the JVM inside a container, and how to read a GC log line and recognise common leak patterns.
8 min readAdvancedSenior
- Java Core
Java streams: readable pipelines and common pitfalls
Write readable stream pipelines, avoid side effects in map and forEach, use groupingBy and toMap correctly, know when a loop is clearer and why parallel streams need caution.
7 min readIntermediateJunior, Middle
- Advanced Java
Virtual threads in Java 21 and Spring Boot
What virtual threads change for blocking I/O, how synchronized pinning works in different JDKs, thread-locals, why connection pools still limit you, and when not to use them.
8 min readAdvancedMiddle, Senior
- JPA / Hibernate
The N+1 query problem in JPA and how to fix it
How to detect N+1 selects in Spring Data JPA and choose between fetch joins, entity graphs, batch fetching and DTO projections, including the pagination caveat.
6 min readIntermediateJunior, Middle
- Event-driven architecture
Delivery semantics, idempotent consumers and the outbox pattern
What at-most-once, at-least-once and exactly-once really mean with Kafka, why dual writes lose events, and how a transactional outbox and idempotent consumers close the gap.
8 min readAdvancedSenior
- Kafka
Kafka fundamentals for backend engineers
Topics, partitions, offsets, consumer groups, ordering per key, retention, replication and producer acks, with a Spring Kafka producer and listener you can reason about.
7 min readIntermediateMiddle
- Microservices
Drawing microservice boundaries
How to find service boundaries from business capabilities and data ownership, recognise a distributed monolith, start with a modular monolith, and account for team structure.
6 min readAdvancedSenior, Architect
- Solution architecture
When and how to modernize a legacy monolith
Keep, refactor, modularize, extract one capability or rewrite — business and technical decision criteria, dependency and data ownership mapping, Strangler Fig and Branch by Abstraction, a fictional notification extraction with an outbox and an idempotent consumer, incremental routing, the limits of rollback and the metrics that define success.
9 min readAdvancedSenior, Tech Lead, Architect
- Observability
Observability: logs, metrics and traces
How structured logs with correlation ids, RED and USE metrics and distributed traces work together, how Micrometer and OpenTelemetry fit in, and how to design alerts around symptoms.
6 min readIntermediateMiddle, Senior
- AI in backend systems
RAG for backend engineers
How retrieval-augmented generation works as a pipeline: chunking, embeddings, retrieval, grounded answers with citations, freshness and evaluation, and when keyword search is enough.
6 min readAdvancedSenior
- Solution architecture
The solution architect role: from requirements to a working solution
How a solution architect turns requirements into a design: quality attributes, constraints, options, trade-off analysis, documentation and day-to-day work with delivery teams.
5 min readIntermediateArchitect
- Spring Boot
Layering a Spring Boot application: controller, service, repository
What each layer is responsible for, why DTOs and entities should stay apart, where business rules belong, and when to organise packages by feature instead of by layer, shown with a small Order example.
8 min readBeginnerJunior
- Spring Security
JWT or server sessions in Spring Security
Compare server-side sessions with stateless tokens on revocation, rotation, CSRF and storage, understand refresh tokens, and choose a pragmatic default for a first-party web app versus a mobile or API client.
6 min readIntermediateMiddle
- Transactions and consistency
Spring @Transactional pitfalls: proxies, propagation and rollback rules
How @Transactional works through proxies, why self-invocation silently skips it, what REQUIRED and REQUIRES_NEW do, which exceptions roll back by default, and why external calls do not belong inside a transaction.
7 min readIntermediateMiddle
- Spring Boot
Validation and error responses in Spring Boot with ProblemDetail
Validate DTOs with Bean Validation, write custom constraints, centralise error handling in a controller advice and return RFC 9457 problem details with stable error codes that clients can rely on.
8 min readIntermediateJunior, Middle
- SQL and performance
SQL indexes explained with PostgreSQL EXPLAIN
How a B-tree index works, how to read EXPLAIN (ANALYZE) in PostgreSQL, why column order matters in composite indexes, and when an index costs more than it gives.
7 min readIntermediateJunior, Middle
- Transactions and consistency
Transaction isolation levels and lost updates in PostgreSQL
Dirty, non-repeatable and phantom reads, how PostgreSQL implements READ COMMITTED, REPEATABLE READ and SERIALIZABLE, and how to prevent lost updates with row locks or @Version.
6 min readAdvancedMiddle, Senior
- System design
A repeatable method for system design interviews and design reviews
Eight steps from clarifying questions to failure modes, with a worked mini-example, common mistakes and a practice plan. It works equally well for real design reviews.
6 min readIntermediateMiddle, Senior
- System design
System design walkthrough: a URL shortener
A worked design of a URL shortener, from requirements and rough estimates to API, data model, ID generation, caching, redirects, analytics and abuse prevention, with trade-offs stated.
7 min readIntermediateSenior
- Technical leadership
Tech lead: the first 90 days
What changes when a strong senior engineer becomes a tech lead, and a practical plan for listening, setting direction, delegating, reviewing and communicating.
6 min readIntermediateTech Lead
- Testing strategy
Integration tests with Testcontainers and a real PostgreSQL
Run integration tests against a real PostgreSQL instead of an in-memory fake. Covers @ServiceConnection, container reuse, test isolation, speed and CI setup.
6 min readIntermediateMiddle
- Testing strategy
A practical testing strategy for Spring Boot backends
The test pyramid as a guide, when to use unit tests, slice tests (@WebMvcTest, @DataJpaTest) and integration tests, what to mock, how to name tests and how to build test data.
7 min readBeginnerJunior, Middle
02Roadmaps
Where to start? Pick your role
Each roadmap shows the expected knowledge, common mistakes, priorities and the articles that fit.
- L1Junior Java DeveloperCorrect, readable Java, SQL, Spring Boot basics and the habits of working in a team.
- L2Middle Java DeveloperIndependent delivery, performance, testing strategy and sound transaction handling.
- L3Senior Backend DeveloperSystem-level trade-offs, reliability, distributed systems and raising the level of the team.
- L4Tech LeadTechnical direction, visible decisions, a quality culture and a team that delivers.
- L5Solution ArchitectFrom requirements to architecture: quality attributes, integration, trade-off analysis and documentation.
- L6Enterprise ArchitectPortfolio, business capabilities, standards, roadmaps and governance that guides rather than blocks.
Want to know your level?
A short skills assessment shows your strengths and gaps, then recommends the articles you actually need.