An engineering publication by Abhishek Goyal

Engineering Atlas

Frameworks change every year. The fundamentals underneath them don’t.

Learn what actually happens under the hood — one diagram at a time.
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.

    ~50 min readBeginner → Advanced
  • 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.

    ~32 min readIntermediate
  • 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.

    ~31 min readBeginner → Intermediate
  • 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.

    12-step playbookInterview prep
  • 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.

    ~14 min readIntermediate
  • 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.

    ~22 min read3+ YOE
  • 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.

    ~90 min readIntermediate → Advanced
  • 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.

    75 questionsMid → Senior
  • 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.

    ~30 min readCollege → Senior
  • 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.

    ~25 min readAny career stage
  • 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.

    ~8 min readAny career stage

Learning paths

Not sure where to start?

Curated sequences that build on each other — read them in order.

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.