Roadmap to senior Java backend
Work through stages 1 to 8. Topics tagged Core are what to learn first for interviews.
- 0/20/20/2Core0/4
- Object-oriented programming: classes, objects, constructors, static and access modifiersNext
- Object-oriented programming: immutable objects, equals/hashCode and finalNext
- Object-oriented programming: inheritance, encapsulation and polymorphismNext
- Object-oriented programming: abstract classes, interfaces and initialization orderNext
1. Java basics
Junior · Write correct Java and read other people's code
0/30/3 - Core0/4
2. Data structures & algorithms
Junior · Pick the right structure and estimate complexity
- Core0/3Core0/2
3. Advanced Java
Mid · Write modern Java and understand what the JVM does
0/5- SOLID through Java examples: five principles, spotting violations, and when you don't need themNext
- Design patterns through refactoring: StrategyNext
- Template Method or composition: refactoring a booking flow from v0 to v2Next
- Observer: from a listener list to Spring events and an outboxNext
- Adapter and Factory: integrating a payment gateway and picking the right implementationNext
0/20/4- Regex: syntax, the Java API and basic validation exercisesNext
- Regex by example: network configs, logs to CSV, lookbehind and duplicate linesNext
- Inside Java's regex engine: backtracking, possessive quantifiers and catastrophic backtrackingNext
- ReDoS in Java: real outages, a home-made timeout and a defence checklistNext
0/20/3 - 0/6
- Databases: tables, data types, primary keys and basic SQLNext
- Databases: ERDs, foreign keys, JOINs and GROUP BYNext
- Subqueries, CTEs, recursive CTEs, window functions and temporary tablesNext
- Stored procedures, functions and triggers: when logic belongs in the databaseNext
- SQL practice: joins, GROUP BY and normalization in 15 library-database queriesNext
- SQL exercises on the E-Learning database: ratings, lesson progress and a schema reviewNext
0/7- Databases: normalization from 1NF to 5NF, and denormalizationNext
- Databases: designing and querying a library system (exercise)Next
- The data modeling process: access patterns, table types, foreign keys and table templatesNext
- Evolving a schema: JSON columns, online DDL, data types and viewsNext
- Designing an airline booking database: relationships, seat inventory and overbookingNext
- Airline booking: away/return directions, a double-entry ledger and change historyNext
- Data modeling case studies: translations, ordering, availability calendars, recurring events, tags and countersNext
Core0/5- Databases: indexes, EXPLAIN, N+1, pagination and soft deleteNext
- Inside an index: B-trees, B+trees, clustered tables, heaps and choosing a primary keyNext
- Index types beyond the B-tree: hash, GIN, GiST, bitmap and LSM treesNext
- How SQL runs and how to read a PostgreSQL execution planNext
- A PostgreSQL index lab on an airline dataset: B-tree, hash, LIKE, composite and covering indexesNext
4. Databases
Mid · Design schemas and write queries that are fast and correct under concurrency
Core0/7- Databases: transactions, isolation levels and lockingNext
- Transactions from the inside: WAL, MVCC and the undo logNext
- Harmful transactions: too large, long-running, stalled, abandonedNext
- Connection pooling and HikariCP: internals, settings and sizingNext
- Locks in InnoDB: from the global lock to gap locks, read through data_locksNext
- Optimistic or pessimistic locking: measured on a 100-seat bookingNext
- Airline booking: holding seats correctly when many people book at onceNext
Core0/5- ORM and JPA: JDBC, Hibernate, entities and repositoriesNext
- ORM and JPA: entity relationships, owning sides and mappedByNext
- ORM and JPA: mapping the E-Learning schema, DTOs and JSON recursionNext
- ORM and JPA: the persistence context, dirty checking and N+1Next
- ORM and JPA: JPQL, native queries, @Transactional and lockingNext
- 0/10/4Core0/5
- The web and HTTP: the Internet, HTTPS, methods, status codes and HTTP versionsNext
- REST APIs: REST constraints, API design conventions and Spring Boot project structureNext
- Advanced REST API design: idempotent methods, gateway URLs, pagination and sortingNext
- Advanced REST API design: async exports, Idempotency-Key and API documentationNext
- DTOs, responses and validation for a Spring Boot REST APINext
Core0/25. Backend with Spring
Mid · Ship APIs that hold up in production
0/3Core0/8- Encoding, hashing, encryption and signatures: picking the right crypto tool as a backend engineerNext
- Storing passwords and encrypting personal data: salts, Argon2id, AES-GCM and blind indexesNext
- Authentication: Basic, API keys, session cookies and JWTNext
- Authorization, SSO and OAuth2: from RBAC to OpenID ConnectNext
- Form login with Spring Security: the filter chain, UserDetailsService and role-based accessNext
- Sessions and remember-me in Spring: Spring Session JDBC, session limits and three ways to stay logged inNext
- Spring Security for REST APIs: a stateless filter chain, login and JWT with the resource serverNext
- Rotating refresh tokens and permission-based authorization in Spring SecurityNext
Core0/20/5- MiniWallet: one e-wallet pet project that grows with the backend roadmapNext
- Requirements analysis and data design through a hotel booking exampleNext
- The hotel booking example: APIs, preventing overbooking and the Spring Boot planNext
- Backend interview review: Java Core, Spring Boot and the webNext
- Cart and checkout with Spring: the model, the transaction and never oversellingNext
- 0/4
- Operating systems for backend engineers: kernel, system calls, processes and threadsNext
- I/O models: blocking, non-blocking, epoll and file descriptorsNext
- Linux for backend engineers: inodes, links, permissions and shell scriptsNext
- Networking for backend engineers: DNS, TCP, TLS and debugging connectionsNext
0/20/6- AWS IAM: users, roles, policies and temporary credentials for Spring BootNext
- AWS VPC: public and private subnets, route tables, NAT gateways and security groupsNext
- AWS EC2, load balancers and Auto Scaling: running Spring Boot on many machines and stopping cleanlyNext
- AWS S3 and CloudFront: storing files, presigned URLs from Spring Boot and a CDN in frontNext
- AWS RDS, Aurora and DynamoDB: managed databases for a Spring Boot serviceNext
- Deploying Spring Boot on AWS: ECS Fargate, Lambda, SQS, CloudWatch and Secrets ManagerNext
6. Going to production
Mid · Build, deploy and observe the system
0/10/3 - Core0/2Core0/2Core0/4
- Cache-aside, write-around and keeping the cache consistent with the databaseNext
- Cache failures: avalanche, breakdown, penetration, hot keys and big keysNext
- Reviewing a Redis distributed lock: six common bugsNext
- Caching in system design: cache tiers, the limits of Redis, and a 1-million-QPS counter case studyNext
Core0/12- Message brokers: four problems with request-response and how to choose a brokerNext
- Why Kafka is fast and durable: the log, zero-copy, batching and replicationNext
- Tuning Kafka for your goal: throughput, latency, durability, availabilityNext
- Inside the Kafka producer: send(), batching, the partitioner and transactionsNext
- Kafka serialization and Schema Registry: choosing a format, the wire format and compatibility modesNext
- Inside Kafka consumer groups: rebalancing, assignors, static membership and livenessNext
- Case study: a synchronous fraud check over Kafka and Redis — good idea or not?Next
- Kafka in practice (1): partition count, large messages, lag and long-running tasksNext
- Kafka in practice (2): dual writes, exactly-once and message orderingNext
- Case study: fraud detection with Kafka and Redis — topics, keys, windows and failuresNext
- CCDAK review: 40 Kafka questions worth rememberingNext
- CCDAK practice part 2: 34 self-made questions on clients, Connect, Schema Registry and StreamsNext
Core0/37. System design
Senior · Design for load and failure, and explain the trade-offs
0/20/2Core0/1Core0/30/2Core0/6- Designing a URL shortener: short codes, Base62, token ranges and redirectsNext
- Designing a Threads-style news feed: push, pull, hybrid and celebritiesNext
- Designing a Discord-style chat system: WebSocket gateways, message storage and fan-out for huge serversNext
- Designing a notification system: push, SMS, email, per-channel queues, deduplication and frequency capsNext
- Case study: designing a liveness system for 1 million IoT devices sending heartbeatsNext
- A liveness system: from a Redis sorted set to a timing wheel and the LMAX DisruptorNext
- 0/30/20/2
8. Senior skills
Senior · Beyond code: lead technically and own the outcome
0/10/1
All posts
202 postsGarbage collection in the JVM: G1, ZGC, reading GC logs and diagnosing OutOfMemoryError
Inside the JVM: runtime memory areas, class loading and ClassLoaders
Reflection, annotations and annotation processors: how Java frameworks read your code
Virtual memory, page cache, swap and the JVM in containers
Dates and times in the backend: epoch, UTC, time zones, ISO 8601 and java.time
Java 17 and 21 for backend developers: records, sealed types, pattern matching and what is worth upgrading for
Lambdas and the Stream API: functional interfaces, lazy pipelines, Collectors and the traps
ReDoS in Java: real outages, a home-made timeout and a defence checklist
Regex by example: network configs, logs to CSV, lookbehind and duplicate lines
Regex: syntax, the Java API and basic validation exercises
Inside Java's regex engine: backtracking, possessive quantifiers and catastrophic backtracking
Java basics: variables, data types and casting
Java I/O: byte streams, buffering and serialization
Java basics: console I/O and text files
Java exceptions: checked vs unchecked, try-catch-finally and the call stack
Java generics: generic classes, generic methods, bounded types and invariance
Java generics: type erasure, raw types and type tokens
Java generics: wildcards and the PECS rule
Java basics: Hello World, compiling, the three kinds of errors and the first exercises
Java basics: the JVM, the JDK, LTS releases and where Java is used
Java basics: loops, methods, the call stack and pass-by-value
Java basics: arrays and strings
Backend interview review: Java Core, Spring Boot and the web
Java basics: operators, if and switch
Custom exceptions and centralized error handling in Spring Boot: @RestControllerAdvice, ProblemDetail, validation
SOLID through Java examples: five principles, spotting violations, and when you don't need them
Creating and destroying objects properly: static factories, builders, singletons and how singletons break
Adapter and Factory: integrating a payment gateway and picking the right implementation
Clean code: why it matters, naming, functions and control flow
Clean code: error handling, boundaries, tests and refactoring real code
DDD and package structure: bounded contexts, aggregates and a flight-booking codebase skeleton
Design patterns through refactoring: Strategy
Codebase architecture: layered, hexagonal, onion, clean and functional core
Observer: from a listener list to Spring events and an outbox
Template Method or composition: refactoring a booking flow from v0 to v2
Object-oriented programming: abstract classes, interfaces and initialization order
Object-oriented programming: immutable objects, equals/hashCode and final
Enums in production: EnumSet, EnumMap, singletons, databases and API evolution
Enums in Java: from constants to classes, strategies and exhaustive switches
Object-oriented programming: inheritance, encapsulation and polymorphism
Object-oriented programming: classes, objects, constructors, static and access modifiers
Object-oriented programming: UML class diagrams and the six class relationships
Nested classes in Java: static nested, inner, local and anonymous classes, and lambdas
Object-oriented programming: wrapper classes, BigInteger/BigDecimal and String
Interview practice: binary trees, BSTs and heaps in Java
Interview practice: graphs and dynamic programming in Java
Algorithm practice: recursion, sorting and turning recursion into loops
Linear data structures: arrays, linked lists, stacks and queues
Recursion, binary search and a few classic algorithms
Inside Java Collections: ArrayList, LinkedList, ArrayDeque and HashMap
Java Collections: List, Set and Map
Basic algorithms: Big-O and the three O(n²) sorts
Basic Algorithms: Merge Sort, Quicksort and How Java Really Sorts
Java Collections: TreeSet, TreeMap, Comparator and iterators
Subqueries, CTEs, recursive CTEs, window functions and temporary tables
Stored procedures, functions and triggers: when logic belongs in the database
Index types beyond the B-tree: hash, GIN, GiST, bitmap and LSM trees
Connection pooling and HikariCP: internals, settings and sizing
Airline booking: away/return directions, a double-entry ledger and change history
Airline booking: holding seats correctly when many people book at once
Data modeling case studies: translations, ordering, availability calendars, recurring events, tags and counters
Elasticsearch: analyzers, the inverted index, doc values and a mapping for homestay search
A PostgreSQL index lab on an airline dataset: B-tree, hash, LIKE, composite and covering indexes
Inside an index: B-trees, B+trees, clustered tables, heaps and choosing a primary key
Locks in InnoDB: from the global lock to gap locks, read through data_locks
How joins run (nested loop, hash join, merge join) and when to partition a table
Evolving a schema: JSON columns, online DDL, data types and views
Storing dates and times in PostgreSQL, MySQL and JSON: timestamptz, DATETIME, Jackson and the traps
Optimistic or pessimistic locking: measured on a 100-seat booking
The data modeling process: access patterns, table types, foreign keys and table templates
Redis internals: why it is fast, how it stores data and how it removes expired keys
Redis: choosing data structures for real problems
How SQL runs and how to read a PostgreSQL execution plan
Designing an airline booking database: relationships, seat inventory and overbooking
Transactions from the inside: WAL, MVCC and the undo log
Harmful transactions: too large, long-running, stalled, abandoned
SQL exercises on the E-Learning database: ratings, lesson progress and a schema review
SQL practice: joins, GROUP BY and normalization in 15 library-database queries
Databases: tables, data types, primary keys and basic SQL
Databases: designing and querying a library system (exercise)
Databases: ERDs, foreign keys, JOINs and GROUP BY
Databases: normalization from 1NF to 5NF, and denormalization
Databases: indexes, EXPLAIN, N+1, pagination and soft delete
ORM and JPA: mapping the E-Learning schema, DTOs and JSON recursion
ORM and JPA: the persistence context, dirty checking and N+1
ORM and JPA: entity relationships, owning sides and mappedBy
ORM and JPA: JDBC, Hibernate, entities and repositories
ORM and JPA: JPQL, native queries, @Transactional and locking
Databases: transactions, isolation levels and locking
DTOs, responses and validation for a Spring Boot REST API
Advanced REST API design: async exports, Idempotency-Key and API documentation
Advanced REST API design: idempotent methods, gateway URLs, pagination and sorting
REST APIs: REST constraints, API design conventions and Spring Boot project structure
The web and HTTP: the Internet, HTTPS, methods, status codes and HTTP versions
Spring AOP and BeanPostProcessor: proxies, pointcuts and advice order
Spring Boot Actuator: health, metrics and production monitoring
Spring Cloud for microservices: Config, Eureka, LoadBalancer, Gateway and circuit breakers
Form binding and validation in Spring MVC
Cart and checkout with Spring: the model, the transaction and never overselling
Common Spring Boot errors and how to debug them: from port conflicts to a 403 that became a 500
Pagination and dynamic filters in Spring: Pageable, Page, Slice and JPA Specifications
Spring Boot from the inside: auto-configuration, configuration, profiles and the startup lifecycle
Spring MVC: DispatcherServlet, controllers and views
Testing Spring Boot: slice tests, integration tests and Testcontainers
Unit testing with JUnit 5 and Mockito: test decisions, not wiring
File upload in Spring MVC: receive, check, store and serve files safely
Cron jobs: cron expressions and @Scheduled in Spring Boot
IoC and Dependency Injection: how the Spring container works
Cleanup cron jobs: batched deletes, archiving and partitions
CompletableFuture and asynchronous programming in Java
Operating systems for backend engineers: kernel, system calls, processes and threads
ExecutorService, thread pools and virtual threads in Java
Java concurrency: race conditions, volatile and deadlocks
Threads in Java: creating threads, the lifecycle and interruption
AWS EC2, load balancers and Auto Scaling: running Spring Boot on many machines and stopping cleanly
AWS IAM: users, roles, policies and temporary credentials for Spring Boot
AWS RDS, Aurora and DynamoDB: managed databases for a Spring Boot service
AWS S3 and CloudFront: storing files, presigned URLs from Spring Boot and a CDN in front
Deploying Spring Boot on AWS: ECS Fargate, Lambda, SQS, CloudWatch and Secrets Manager
AWS VPC: public and private subnets, route tables, NAT gateways and security groups
Kubernetes for backend developers: architecture, Pods, Services, ConfigMaps, autoscaling and debugging failing pods
Logging for backends: log levels, structured logs, MDC and a centralized log pipeline with ELK or Loki
Deployment strategies: rolling, blue-green, canary, feature flags and zero downtime on Kubernetes
CI/CD for a Spring Boot backend: a GitHub Actions pipeline from commit to production
Code review: resolving disagreements and two worked reviews of real code
Code review: goals, a checklist, the process and writing comments
Distributed tracing with OpenTelemetry: traces, spans, traceparent and sampling
Docker for Spring Boot: images, multi-stage Dockerfiles, the JVM in a container and Compose
Working with AI coding agents as a backend engineer: workflow, project rules and verification
Linux for backend engineers: inodes, links, permissions and shell scripts
Maven and the layout of a Spring Boot project
Mentoring as a senior engineer: onboarding, SBI feedback, delegation and behavioural questions
Performance testing: load, stress, spike, soak and coordinated omission
Reverse proxying with Nginx: path-based routing and X-Forwarded headers
The Twelve-Factor App: 12 principles for cloud-ready services, applied to Spring Boot and Kubernetes
Estimating and breaking down work: ranges, PERT, spikes and negotiating scope
Handling production incidents and writing postmortems
Git: version control, the staging area, the object model and commit conventions
Git: branching, merge vs rebase, conflicts, reflog and the pull request flow
Git: remotes, cloning, release tags and a daily push habit
MiniWallet: one e-wallet pet project that grows with the backend roadmap
Distributed job scheduling: Quartz clustering, misfires and splitting big jobs across workers
Primary–replica replication and read/write splitting: replication lag, read-your-writes and failover
Designing a notification system: push, SMS, email, per-channel queues, deduplication and frequency caps
Architecture docs part 2: ADRs, quality requirements, the risk register and an address component example
Cache-aside, write-around and keeping the cache consistent with the database
Caching in system design: cache tiers, the limits of Redis, and a 1-million-QPS counter case study
Tuning Kafka for your goal: throughput, latency, durability, availability
Choosing a database in system design: SQL, NoSQL, NewSQL, columnar and time-series
Distributed transactions: 2PC, TCC, saga, pivot transactions and the transactional outbox
Problem solving like a senior: definitions, causal diagrams, 5 Whys and a checklist
Communication in system design, part 1: a message's journey, Protobuf, REST or gRPC
Communication in system design, part 2: Kafka or RabbitMQ, real-time push and a fraud detection case study
A liveness system: from a Redis sorted set to a timing wheel and the LMAX Disruptor
Idempotency part 2: Kafka consumers, the idempotent producer and payment-gateway IPNs
Idempotency part 1: at-least-once, unique constraints and an Idempotency-Key on PostgreSQL
I/O models: blocking, non-blocking, epoll and file descriptors
Inside Kafka consumer groups: rebalancing, assignors, static membership and liveness
Kafka in practice (2): dual writes, exactly-once and message ordering
Inside the Kafka producer: send(), batching, the partitioner and transactions
Case study: a synchronous fraud check over Kafka and Redis — good idea or not?
Kafka serialization and Schema Registry: choosing a format, the wire format and compatibility modes
Kafka in practice (1): partition count, large messages, lag and long-running tasks
Why Kafka is fast and durable: the log, zero-copy, batching and replication
Discover the domain before you design: Event Storming, Domain Storytelling and pivotal events
Pragmatic software architecture: architectural drivers, the architect's role and context-driven decisions
CCDAK practice part 2: 34 self-made questions on clients, Connect, Schema Registry and Streams
Networking for backend engineers: DNS, TCP, TLS and debugging connections
Message brokers: four problems with request-response and how to choose a broker
Microservices: when to split, finding service boundaries, and carving up a monolith step by step
Design principles: CAP, PACELC, scalability, performance and availability
CCDAK review: 40 Kafka questions worth remembering
Analysing trade-offs like a senior: ideality, sweet spots, coupling and separation
Case study: fraud detection with Kafka and Redis — topics, keys, windows and failures
The system design interview: a four-step process and clarifying requirements
Rate limiting: five algorithms, a token bucket on Redis, and designing a distributed limiter
Reviewing a Redis distributed lock: six common bugs
Redis: persistence, replication, Sentinel and Cluster
Sharding in system design: choosing a shard key, four case studies and resharding
Cache failures: avalanche, breakdown, penetration, hot keys and big keys
Architecture docs part 1: arc42, the C4 model, runtime/deployment views and docs-as-code
Payments after the integration: late IPNs, reconciliation and a failure-mode table
Designing a Discord-style chat system: WebSocket gateways, message storage and fan-out for huge servers
Case study: designing a liveness system for 1 million IoT devices sending heartbeats
Designing a Threads-style news feed: push, pull, hybrid and celebrities
Designing a URL shortener: short codes, Base62, token ranges and redirects
Third-party integration: choosing a provider, sync versus async, webhooks and an anti-corruption layer
Integrating a VNPay-style payment gateway: redirect, signatures and IPN
Timeouts, retries, circuit breakers and bulkheads for third-party calls
Back-of-the-envelope estimation: numbers to know and how to calculate fast
The hotel booking example: APIs, preventing overbooking and the Spring Boot plan
Requirements analysis and data design through a hotel booking example
Storing passwords and encrypting personal data: salts, Argon2id, AES-GCM and blind indexes
Encoding, hashing, encryption and signatures: picking the right crypto tool as a backend engineer
Authorization, SSO and OAuth2: from RBAC to OpenID Connect
Rotating refresh tokens and permission-based authorization in Spring Security
Form login with Spring Security: the filter chain, UserDetailsService and role-based access
Spring Security for REST APIs: a stateless filter chain, login and JWT with the resource server
Sessions and remember-me in Spring: Spring Session JDBC, session limits and three ways to stay logged in
Web attacks and the OWASP Top 10: MITM, SQL injection, XSS, CSRF, DDoS
Authentication: Basic, API keys, session cookies and JWT
Bắt đầu ghi chép
Progress is saved in this browser. Export it to take it to another device.
That file isn't a progress export.