An engineering publication by Abhishek Goyal
Engineering Atlas
Frameworks change every year. The fundamentals underneath them don’t.
- In-depth guides
- 11
- Hand-built diagrams
- 75
- Learning tracks
- 6
- Free to read
- 100%
Explore
Search the Atlas
Every guide, across every track. Search by concept — volatile, isolation, circuit breaker, RAG — or narrow to one track.
11 guides
-
Java
Java Concurrency & Multithreading
End-to-end, internals-first: JVM memory architecture, CPU cache visibility, all six thread states, synchronized and volatile, wait/notify, thread pools, the full java.util.concurrent toolkit, ThreadLocal, CompletableFuture, the Java Memory Model, common bugs, and a full interview Q&A.
-
JavaNew
Why wait() and notify() Must Be Called Inside synchronized
The lost-wakeup race that forces the rule, what the monitor’s entry set and wait set really do, why wait() must live in a while loop, notify vs notifyAll — and how Lock/Condition inherits the same contract.
-
JavaNew
Why Strings Are Immutable in Java
Inside java.lang.String: the final byte[], compact strings and the cached hash — and the five reasons immutability was chosen: the string pool, hash-based collections, security, thread safety and class loading.
-
Java
The Java LLD Rulebook
A complete, step-by-step guide on how to tackle Low-Level Design and machine coding interview rounds. Learn how to confidently apply Object-Oriented Design principles, leverage common design patterns, and structure scalable Java applications from scratch.
-
Distributed Systems
Concurrency Control in Distributed Systems
Why local locks stop working the moment you scale past one instance, and how optimistic and pessimistic concurrency control pick up the slack — with isolation levels, lock types, and working Spring/JPA code.
-
Backend
Backend Under Load: Eight Failure Modes
A system design interview field guide to how backends actually degrade — connection pool saturation, cache stampedes, lock contention, hot partitions, slow queries, network bottlenecks, and GC pauses — plus how they cascade into each other in a real incident.
-
System Design
Distributed Systems & Backend Patterns
60+ patterns that keep production systems alive under failure, load, and scale — resilience, load management, caching, messaging, databases, distributed coordination, traffic routing, reliability, scalability, security, and observability.
-
AI Engineering
AI Engineer Interview Question Bank
75 detailed Q&A pairs across 15 topics — every one paired with a production scenario. The pattern that separates senior candidates: they answer the conceptual question cleanly in 30–60 seconds, then handle the production follow-up.
-
Career
Java Backend Developer + AI Roadmap
From core Java and concurrency to Spring Boot, databases, distributed systems, system design, production engineering, and AI — a granular roadmap focused on the concepts you actually need to understand to become a strong modern backend engineer.
-
Career
The Project Deep-Dive Playbook
Interviewers don’t grill you on the job description — they grill you on your projects. Turn any project you touched, even a single bug fix, into an end-to-end, interview-ready handbook, and use AI to build it so you can steer the interview instead of surviving it.
-
Career
The Resume Building Guide
Why most resumes read like a copy-pasted job description instead of proof of your work — plus how to turn a small bug fix into a real project, quantify every bullet, and a filled-in sample resume to see it all applied.
No guides match that search yet.
Tracks
Delve into a track
Each track is a hub of sub-topics. Pick one and go as deep as you like — every hub grows as new deep dives are published.
-
Language & JVM
Java
Concurrency, the memory model, core language design and low-level design — how Java actually behaves at runtime.
- Concurrency & multithreading
- Core Java internals
- Design & LLD
-
Services & data
Backend
How backends behave under real load — transactions, locking, connection pools, caches, queues and failure.
- Data & consistency
- Reliability & performance
- Concurrency
- Becoming a backend engineer
-
Architecture
System Design
Architecture patterns, scaling, trade-offs and the interview framework to reason about them out loud.
- Patterns & building blocks
- Failure & scale
- Data & consistency
- Low-level design
-
Coordination & failure
Distributed Systems
Coordination, consistency and partial failure — what changes once work spans more than one machine.
- Consistency & concurrency control
- Failure modes
- Patterns
-
LLMs in production
AI Engineering
LLMs, RAG, agents and evaluation — from the concept to the production follow-up question.
- Interview preparation
-
Growth & interviews
Career
Roadmaps, resumes and project deep-dives that help your engineering work get noticed.
- Roadmaps
- Interviews & resumes
Just published
New deep dives
- JavaNew Why wait() and notify() Must Be Called Inside synchronized The lost-wakeup race that forces the rule, what the monitor’s entry set and wait set really do, why wait() must live in a while loop, notify vs notifyAll — and how Lock/Condition inherits the same contract.
- JavaNew Why Strings Are Immutable in Java Inside java.lang.String: the final byte[], compact strings and the cached hash — and the five reasons immutability was chosen: the string pool, hash-based collections, security, thread safety and class loading.
Learning paths
Not sure where to start?
Curated sequences that build on each other — read them in order.
-
Backend foundations
From threads on one JVM to correctness across many instances.
- Java Concurrency~50 min read
- wait/notify & synchronized~32 min read
- Concurrency Control~14 min read
- Backend Failure Modes~22 min read
-
Java internals
The design decisions behind the language you use every day.
- String immutability~31 min read
- wait/notify & synchronized~32 min read
- Java Concurrency~50 min read
- Java LLD Rulebook12-step playbook
-
Interview ready
Design rounds, project deep-dives and the resume that gets you there.
- Java LLD Rulebook12-step playbook
- Backend Patterns~90 min read
- Project Interview Playbook~25 min read
- Resume Guide~8 min read
The approach
Why Engineering Atlas
-
Internals, not trivia
Every topic starts from what the machine, the JVM or the network is actually doing — so the rules stop being things to memorise.
-
Diagram-first
Hand-built diagrams for every core idea. If a concept can be drawn, it is drawn — with the flow, the states and the failure path.
-
Production lens
Failure modes, trade-offs and the follow-up questions interviewers really ask, next to the theory they come from.
About the author
Hi, I’m Abhishek Goyal.
I’m a software engineer who learns by taking things apart. Engineering Atlas is where I write up what I find — how the JVM really schedules threads, why a cache stampede takes a database down, what a distributed lock can and can’t promise — drawn as diagrams and explained from first principles.
Every guide here is written to be the explanation I wish I had found the first time: deep enough for production work and interviews, but built up step by step so it stays readable. New deep dives land regularly — follow along on Instagram and LinkedIn for short-form breakdowns of each one.