Learning paths
Every topic, organized for search and for study.
A curriculum-style index of backend engineering, with each cluster broken into clear keywords, individual lessons, and internal links that make the site easier to explore and easier to rank.
Node.js · Go runtime · Python async · JVM performance
Language runtimes and execution mechanics
Start here to understand why code can behave differently when many people use it at once.
Phase 1
Node.js event loop
See how Node.js keeps handling work without waiting for every slow task to finish.
Phase 1
Asynchronous and non-blocking I/O
How Node.js starts slow work, such as reading a file, and keeps doing other things while it waits.
Phase 1
Concurrency primitives in Node.js
When one Node.js process is enough, and when it helps to give heavy work its own worker.
Phase 1
Streams and buffer management
How to move large amounts of data in small pieces without using too much memory.
Phase 1
Memory management and garbage collection
How Node.js cleans up unused memory, and how to spot when something is being kept by mistake.
Phase 1
The Go scheduler
How Go shares many small jobs across the computer's available workers.
Phase 1
Channels and CSP concurrency
How Go jobs can safely pass messages to one another and avoid stepping on each other.
Phase 1
Memory allocation and pointers in Go
Learn where Go keeps values in memory, and why some values need to live longer than others.
Phase 1
Python async IO and the GIL
How Python handles many waiting tasks, and what its main lock means for threaded work.
Phase 1
Threading models in Java and Kotlin
A simple comparison of the older and newer ways Java and Kotlin can run many tasks at once.
HTTP · REST · GraphQL · gRPC · WebSockets
Protocols, APIs, and networking
Learn how apps talk to servers, how APIs are shaped, and how you keep that traffic safe.
Phase 2
OSI, TCP/IP, and TLS
Follow a request from the internet connection to a private, secure conversation with a server.
Phase 2
HTTP 1.1, HTTP 2, and HTTP 3
See how each newer HTTP version helps websites load and respond more smoothly.
Phase 2
REST and OpenAPI
Learn to make APIs that are predictable, clear to use, and safe to call more than once.
Phase 2
GraphQL
Ask an API for exactly the data you need, while avoiding slow or overly expensive requests.
Phase 2
gRPC and Protocol Buffers
A faster way for services to talk to each other using a clear shared format.
Phase 2
Real-time communication
Choose the right way to send live updates, such as chat messages or delivery status.
Phase 2
Reverse and forward proxies
Understand the helpful middle layer that receives traffic before it reaches your app.
Phase 2
API gateways
Use one front door to route requests, check access, and keep backend services simpler.
Phase 2
Authentication and security standards
Learn the basics of signing people in, giving them the right access, and protecting common weak spots.
Phase 2
Rate limiting and throttling
Keep a busy API fair and stable by deciding how many requests each person can make.
PostgreSQL · Redis · caching · replication
Data storage, persistence, and caching
Use this section to learn where data lives and how to keep it quick, correct, and available.
Phase 3
ACID guarantees
The four promises a database makes when you save important information.
Phase 3
Transaction isolation levels
What can go wrong when many people read and change the same data at the same time.
Phase 3
Indexing mechanics
How databases find rows quickly, and how to check whether a query is doing too much work.
Phase 3
Connection management
How to share database connections safely instead of opening a new one for every request.
Phase 3
MongoDB document stores
How MongoDB stores flexible documents and helps you search or group them.
Phase 3
Redis in-memory data structures
The useful ways Redis can hold data when you need answers very quickly.
Phase 3
Wide-column and time-series stores
How databases built for huge amounts of data organise writes and find the right slice later.
Phase 3
Cache placement patterns
Where a cache can live, from inside your app to servers close to your users.
Phase 3
Caching design patterns
The common ways an app can read from and write to a cache.
Phase 3
Cache eviction and invalidation
How caches decide what to forget, and how to avoid a rush of requests when data disappears.
system design · scalability · queues · consensus
Backend scaling and system architecture
This is where you learn how separate parts of a system share work and stay in sync.
Phase 4
Vertical versus horizontal scaling
Decide whether to buy a bigger machine or add more machines to handle more people.
Phase 4
Stateless and stateful systems
Learn what happens when an app remembers a user, and why that can make scaling harder.
Phase 4
Load balancing techniques
How a traffic director spreads incoming requests across several app servers.
Phase 4
Database scaling and partitioning
Ways to split database work across machines when one database is no longer enough.
Phase 4
Consistent hashing
A way to spread data across machines without having to move everything when one machine changes.
Phase 4
Message queues versus event streams
The difference between handing a job to one worker and keeping a record that many workers can read.
Phase 4
Event patterns
Simple patterns for letting parts of a system react when something important happens.
Phase 4
Delivery semantics
What it means when a message might arrive once, twice, or not at all—and how to handle it safely.
Phase 4
Fault tolerance
How to stop one broken service from making the whole product feel broken.
Phase 4
Retries and backoff
How to try again after a temporary problem without making the problem worse.
Phase 4
Dead letter queues
Where to put messages that keep failing so they do not block everything else.
Phase 4
Distributed consensus
Why separate machines sometimes disagree, and how systems choose a safe answer.
AWS · Kubernetes · observability · DevOps
Cloud infrastructure, DevOps, and observability
Connect the app you write to the cloud services that run it for real people.
Phase 5
Virtualization versus containers
The difference between a full virtual computer and a lightweight container for your app.
Phase 5
Kubernetes and orchestration
How Kubernetes helps run, replace, connect, and grow many copies of an app.
Phase 5
Serverless execution
Run small pieces of code without managing servers, and understand the tradeoffs.
Phase 5
Object storage
Store files such as images and reports safely, then let people upload or download them directly.
Phase 5
CDN acceleration
Serve content from a location near each user so your site feels faster.
Phase 5
VPC architecture
Create a private network in the cloud and decide which parts can reach the internet.
Phase 5
Network gateways
See the routes cloud services use to reach the internet, private services, or another network.
Phase 5
Firewalls and access rules
Set clear rules for who can talk to each part of your cloud setup.
Phase 5
Metrics and golden signals
Track a few useful numbers so you can tell whether your system is healthy.
Phase 5
Structured logging and distributed tracing
Follow one request through several services using logs and traces that connect the dots.
system design · production engineering · real-world scenarios
Production engineering and real-world system design
Use these projects to practise turning a product idea into a clear backend plan.
Phase 6
Design a URL shortener
Turn a long link into a short one, save it safely, and send people to the right place.
Phase 6
Design a real-time chat system
Plan how people can send messages instantly, even when someone is temporarily offline.
Phase 6
Design a rate limiter API
Build a fair request limit that still works when your app runs in more than one place.
Phase 6
Design a distributed financial ledger
Keep a trustworthy record of money moving between accounts, even when requests repeat or fail.
Phase 6
Design video streaming infrastructure
Deliver video smoothly by sending the right quality to each viewer at the right time.
Built for growth
A searchable index today, lesson pages tomorrow.
SEO-friendly titles
Every cluster uses precise, searchable language.
Clear hierarchy
Topics are grouped by phase and learning intent.
Internal links
Each page can point back to the larger map.