Review today
Nothing to review yet. Mark a roadmap topic as "Learning" and its cards show up here.
Open roadmapPosts
172 postsVirtual memory, page cache, swap and the JVM in containers
Dates and times in the backend: epoch, UTC, time zones, ISO 8601 and java.time
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
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
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
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
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
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
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
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
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
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