Knowledge Guide

The Niche Backend Engineer Path

A routed journey from first principles to top-tier-interview-ready — built so you become the engineer who solves problems from fundamentals, not memorized answers. Nine ordered stages thread the whole guide into one path.

How to use this. Go top to bottom — each stage assumes the one above it. Don't read every page: use the checkpoint at the bottom of each stage as a filter. If you can already do all of a stage's checkpoint items, skip ahead; if not, that's exactly what to study next. The checkpoints are your interview-readiness rubric.
1

Foundations & Mental Models

Learn to think in complexity and trade-offs before writing a line of code — the lens every later stage is judged through.

Prerequisites: none. Start here.

DSA · Foundations Mental Models & Systems Thinking ▶ Big-O growth engine
Checkpoint — you can:
  • Derive the time & space complexity of any snippet from first principles, and drop constants correctly.
  • Rank O(1) < log n < n < n log n < n² < 2ⁿ and map a constraint (n ≤ 10⁵) to its target class.
  • Pick the right core data structure for a problem and justify it.
2

DSA Patterns — the problem-solving engine

Recognize the pattern from the problem statement and state its complexity + trade-off vs alternatives — the skill top-tier coding interviews actually test.

Prerequisites: Stage 1.

Recursion Dynamic Programming Graphs Trees Heap Advanced Patterns ▶ Interactive debuggers (10 engines)
Checkpoint — you can:
  • Given an unseen problem, name the pattern, the complexity, and why it beats the brute force — before coding.
  • Step any of binary search / DP-table / recursion tree / heap / graph DFS in the debugger and predict each fork.
  • State when a pattern does not apply and what you'd reach for instead.
3

OO & Low-Level Design

Turn fuzzy requirements into clean, extensible class designs — the LLD round pairs with DSA as the other half of the coding loop, so master it early.

Prerequisites: Stage 1–2 (foundations + basic problem-solving). Independent of the systems stages below.

OOD Foundations SOLID Principles Creational Patterns Behavioral Patterns OO Design Problems
Checkpoint — you can:
  • Drive an LLD interview (parking lot, elevator, rate limiter) from requirements to class diagram.
  • Apply each SOLID principle — and name the smell it fixes.
  • Pick the right design pattern and, crucially, say when not to use one.
4

Concurrency & the Runtime

Reason about shared state, the memory model, and lock-free design in both Java and Go — the backend engineer's daily hazard.

Prerequisites: Stage 1–2.

Concurrency Foundations Lock-Free & Memory Ordering Concurrency Problems
Checkpoint — you can:
  • Spot a data race and choose the right primitive (mutex / channel / atomic / CAS) with justification.
  • Explain happens-before, memory barriers, and false sharing.
  • Walk through a lock-free stack and the ABA problem, and how hazard pointers / RCU address it.
5

Data & Storage

Model data, index it, and know what the database does under your query — not just how to write SQL.

Prerequisites: Stage 1.

SQL Fundamentals Normalization Indexing & Storage Transactions & Concurrency Query Execution Database Engine Internals
Checkpoint — you can:
  • Design a normalized schema, then justify a denormalization for a real read pattern.
  • Choose indexes for a query set and predict which the planner will use.
  • Explain the buffer pool, WAL, MVCC, and B-tree vs LSM — and when each storage engine wins.
6

Distributed Systems

Build for partial failure; reason precisely about consistency, coordination, and delivery — the heart of the "niche" in niche backend.

Prerequisites: Stage 4–5 (Concurrency & Data).

CAP Theorem Replication Data Partitioning Quorum Scalable Systems (Advanced)
Checkpoint — you can:
  • Place a system on the consistency spectrum (linearizable → causal → eventual) and defend the choice.
  • Choose delivery semantics (at-least/exactly-once), and implement idempotency + dedup keys.
  • Design a shard key that avoids hotspots, and pick a conflict-resolution strategy (LWW / vector clocks).
7

System Design

Drive a full design interview end-to-end and defend every trade-off under questioning.

Prerequisites: Stage 5–6 (Data & Distributed).

Building Blocks Capacity Estimation Caching Trade-offs Microservices Patterns Worked Problems
Checkpoint — you can:
  • Run a design interview end-to-end: requirements → estimates → API → data → scale → trade-offs.
  • Do back-of-envelope QPS / storage / bandwidth sizing out loud.
  • Defend caching, partitioning, and consistency choices against "what if it fails?" follow-ups.
8

Production & Operations (Day-2)

Run what you build: observability, reliability, and the OS underneath it. What separates "it works on my machine" from "it holds at 3am."

Prerequisites: Stage 6–7 (Distributed & System Design).

Observability & SRE OS & Kernel Internals Authentication Authorization Encryption
Checkpoint — you can:
  • Debug a production incident with traces, metrics, and logs (the three pillars) and exemplars.
  • Set SLOs + error budgets and design burn-rate alerts.
  • Reason about syscalls, the scheduler, virtual memory/TLB — and secure an API end-to-end.
9

Interview Readiness

Convert mastery into offers: a repeatable process for coding, system-design, and behavioral rounds.

Prerequisites: Stages 1–8 (or the checkpoints you can already pass).

Interviews
Checkpoint — you can:
  • Tell 6–8 STAR behavioral stories mapped to leadership principles, from memory.
  • Run a repeatable coding-interview process: clarify → examples → pattern → code → test → complexity.
  • Negotiate an offer without leaving money on the table.
Or browse any track directly
DSA22 topicsConcurrency3 topicsDatabases13 topicsOO & Low-Level Design7 topicsSystem Design35 topicsCareer & Job Search14 topics