Free lessons for software engineers
Learn DSA, system design, DevOps, JavaScript and more, one clear lesson at a time.
31 lesson series and 414 lessons, written in plain English. Each series reads like a small book: start at the first lesson and go forward. Every idea is traced step by step, and most lessons end with interview questions and model answers.
Recommended paths
Start with a guide
Pick your goal and follow a ready-made reading order, so you never wonder what to read next.
- SDInterview
System Design Interview Guide: Basics to Case Studies
A reading order for system design interviews: requirements, estimation, caching, databases, queues, reliability and worked designs, with practice problems.
46 lessonsStart reading → - </>Interview
Coding Interview Preparation Guide: DSA Study Plan
A step-by-step coding interview plan: how to study, the patterns that matter (arrays, hashing, trees, graphs, DP), mock interviews and interview-day habits.
43 lessonsStart reading → - JSInterview
JavaScript Interview Guide: Core Concepts and Questions
Learn how JavaScript really works, then practise the questions: scope, closures, the event loop, prototypes, this, promises, modules and coding-round utilities.
22 lessonsStart reading → - SQLDatabases
SQL and PostgreSQL Guide: From First Query to Production
Learn SQL with PostgreSQL step by step: SELECT, joins, grouping, window functions, schema design, indexes and EXPLAIN, transactions and safe migrations.
15 lessonsStart reading → - gitTools
Git and GitHub Guide: Commits, Branches, Pull Requests
Learn Git from the mental model to team workflows: the daily loop, branches and conflicts, remotes and pull requests, undoing mistakes, rebase and CI.
9 lessonsStart reading → - opsCloud
DevOps and AWS Guide: From Git Push to Production
A path from Linux and networking to a production setup on AWS: DNS, TLS, IAM, VPC, EC2, Docker, Nginx, scaling, CI/CD, Terraform, monitoring and cost.
25 lessonsStart reading → - TSFront end
TypeScript, React and Next.js Guide for Developers
Learn TypeScript from zero, then go deeper on React rendering, hooks, Server Components, state management, testing and the browser performance basics.
24 lessonsStart reading → - FSInterview
Full-Stack Developer Interview Guide: Questions and Answers
Prepare for a full-stack interview: front end, back end, databases, auth and security, debugging scenarios, experience questions and the people side.
26 lessonsStart reading → - TLLeadership
Team Lead Guide: Decisions, People and Delivery
How a team lead thinks: answering why questions, choosing tools, estimates and reviews, 1:1s and feedback, hiring, incidents, strategy and culture.
18 lessonsStart reading → - QAQuality
Software Testing Guide: Unit, Integration and E2E Tests
Learn testing from the first test: unit tests and test doubles, UI tests, API and integration tests, Playwright end-to-end tests, TDD and a team test strategy.
10 lessonsStart reading → - OOPDesign
Design Patterns and Low-Level Design Guide
Learn SOLID and the classic design patterns with TypeScript, then practise object-oriented design: parking lot, LRU cache, state machines, rate limiter.
10 lessonsStart reading → - SECSecurity
Web Security Guide for Developers: OWASP Top 10 Basics
Learn web app security in plain English: injection, XSS, CSRF, passwords, access control, secrets, supply chain and APIs, with small examples that were run.
13 lessonsStart reading → - APIBack end
API Design Guide: REST, Errors, Pagination and Versioning
Design APIs other developers enjoy: resources and URLs, methods and status codes, errors, pagination, versioning, idempotency, auth, OpenAPI, GraphQL and gRPC.
13 lessonsStart reading → - RXFront end
React Guide: Components, Hooks, State and Performance
Learn React in a clear order: components and JSX, state and rendering, effects, hooks, forms, data fetching, performance and testing, with a full interview Q&A.
12 lessonsStart reading → - JSBack end
Node.js Guide: Event Loop, Streams, Servers and Production
Learn Node.js from the runtime and event loop to streams, HTTP servers, Express, Fastify, errors, workers and production habits, with an interview Q&A.
12 lessonsStart reading → - HRCareer
Behavioral Interview Guide for Developers: Stories to Salary
Answer the questions that are not about code: tell me about yourself, failure, conflict, leadership, tricky questions, salary and offers, with full model answers.
11 lessonsStart reading → - NXFull stack
Next.js Guide: App Router, Server Components and Deploying
Learn the Next.js App Router in order: routing, Server and Client Components, data and caching, Server Actions, auth, rendering, SEO, deployment and interview questions.
14 lessonsStart reading → - K8sCloud
Docker and Kubernetes Guide: Containers to Clusters
Learn containers and Kubernetes in order: images, Dockerfiles, volumes, Compose, pods, services, config, scaling, debugging and interview questions, with runnable examples.
11 lessonsStart reading → - AIAI
AI Engineering Guide: Build and Secure LLM Features
From LLMs, agents and RAG to production: the OWASP Top 10 for LLM apps, prompt injection, evaluation, cost and latency, observability and guardrails.
8 lessonsStart reading →
Programming foundations
Learn the building blocks from zero, with every example traced or run.
DSA for Interviews, From Zero
Data structures and algorithms for coding interviews, starting from the very first loop. Every idea is traced step by step and then practised on interview-style questions with full answers, so that it stays with you long term.
JavaScript Core Mastery
A lesson-by-lesson deep dive into how JavaScript actually runs under the hood — execution context, call stack, scope, closures, this, and the event loop. Pure execution-model JavaScript: no array methods, no framework code.
JavaScript Part 2: Objects, Async and Modules
The second half of JavaScript: objects and prototypes, this and classes, promises and async/await, modules, iterators and generators, the DOM and events, errors and Proxy, and memory. Each idea is traced with small examples that were run.
TypeScript From Zero to Confident
TypeScript from the first project to real-world configuration: basic types and narrowing, objects and classes, functions and generics, utility and conditional types, modules and tsconfig, React and runtime validation with Zod, and migrating to strict mode. Every compiler error shown was reproduced.
SQL and PostgreSQL From Zero
SQL and PostgreSQL from your first SELECT to production habits: joins, aggregates, window functions, schema design, indexes and EXPLAIN, transactions and locks, JSONB and safe migrations. Every query was run on a real PostgreSQL server and the real output is shown.
Git and GitHub From Zero
Git from the first commit to team workflows: the mental model, the daily loop, branches and conflicts, remotes and pull requests, undoing mistakes and rebase. Every command was run in a throwaway repository and the real output is shown.
Computer Science Foundations Interviewers Assume
The computer science underneath your code: how programs run, memory and CPU caches, floating point, Unicode, binary and bit tricks, probability, hard problems and string searching, explained in plain English with runnable examples.
Testing From Zero: What, Why and How
Testing from the first test to a team strategy: the shapes of a test suite, unit tests and test doubles, UI tests with Testing Library, API and integration tests, end-to-end tests with Playwright, and TDD, property-based and mutation testing. Every example was run.
Security for Developers: Web App Security From Zero
The security a working developer needs: how attackers think, injection, XSS and CSRF, passwords and login, access control, secrets and cryptography, dependencies and supply chain, and APIs. Small examples, every one run, based on OWASP, PortSwigger and the Node.js security guides.
React in Depth: From Components to Performance
React from the first component to confident senior answers: how rendering really works, state, effects, hooks rules, forms, data fetching, context, performance, patterns, testing and a React interview Q&A. Every example was run.
Next.js App Router From Zero to Production
Next.js 16 the practical way: routing and layouts, Server and Client Components, data fetching and caching, Server Actions and forms, route handlers, middleware and auth, performance and SEO, and deploying. Based on the official docs, with every example run.
Linux and the Command Line for Developers
The Linux and shell skills developers use every day: the file system, permissions, processes, pipes and text tools, shell scripting, SSH, package managers, cron and systemd, logs and troubleshooting a slow or broken server. Every command was run.
Computer Networking for Developers: IP, TCP, DNS, HTTP and TLS
The networking every developer should know: layers, IP and subnets, TCP and UDP, DNS, HTTP/1.1, HTTP/2 and HTTP/3, TLS and certificates, load balancers, CDNs and how to debug network problems with real tools. Every example was captured or run.
Backend, systems and DevOps
How real systems are built, scaled, deployed and kept running.
DevOps, From Zero
A lesson-by-lesson series that takes you from "just git push to Vercel" to running your own production setup on raw AWS — servers, networking, databases, and the mindset behind them.
System Design, Step by Step
Learn how real systems are built, one idea at a time. Start with what happens when you press Enter, then work through scaling, caching, databases, queues, reliability and security, and finish by designing a URL shortener, a chat app and a news feed. Every short form is explained when you hover over it, and every idea comes with a diagram.
System Design Case Studies, Part 2
Twelve more system design case studies, each with requirements, back-of-envelope numbers, API, data model, architecture, deep dives, failure modes and a runnable simulation: web crawler, key-value store, Dropbox-style sync, collaborative editing, CDN, top-K, unique IDs, multi-region, matching engine, sales ranking, finance pipeline and scaling on AWS.
Backend in Depth: Designing an API You'd Put in Production
From folder structure to N+1 queries: the choices a senior full-stack engineer must explain. Clean code, layers, REST design, validation, errors, logging, auth, databases, Prisma, GraphQL, Node speed and testing.
The Browser Contract: Auth, Storage, Security & HTTP
What happens between the address bar and your React app, and the safety choices interviewers like to ask about: storage, sessions vs JWT, XSS and CSRF, CORS, HTTP caching, status codes, rendering and Core Web Vitals.
Design Patterns and Low-Level Design (OOD) for Interviews
Object-oriented design interviews and the design patterns behind them: SOLID, creational, structural and behavioural patterns, the patterns you already use, and worked class designs for a parking lot, LRU cache, vending machine, elevator, blackjack, chat server, rate limiter and notifications. All examples are TypeScript that was run.
API Design: REST, GraphQL and gRPC From Zero
How to design an API other developers enjoy using: resources and URLs, methods and status codes, errors, pagination, versioning, idempotency, authentication, rate limits, OpenAPI, and when to choose GraphQL or gRPC. Small examples, every one run.
Node.js From Zero: Event Loop, Streams and Servers
Node.js the way a working developer needs it: the event loop, modules, files and streams, building an HTTP server without a framework, Express and Fastify, errors and logging, async patterns, worker threads and production habits. Every example was run.
Docker and Kubernetes From Zero
Containers and orchestration in plain English: images and layers, writing a good Dockerfile, volumes and networks, Docker Compose, then Kubernetes pods, deployments, services, config, scaling, rollouts and debugging. Commands run for real wherever the sandbox allows.
Observability and SRE: Logs, Metrics, Traces and Reliability
How to know what your system is doing and keep it reliable: structured logs, metrics and Prometheus, tracing with OpenTelemetry, SLIs, SLOs and error budgets, alerting, dashboards, incident response and blameless post-mortems. Examples were run locally.
Interview prep
Questions with model answers, debugging scenarios and design problems.
Full-Stack Interview Questions for 4+ Years
Real questions for a full-stack engineer with four or more years of experience: HTML and CSS, Tailwind, TypeScript, React, Next.js, Node.js, Express, MongoDB, Prisma, Hasura, LLMs, agents, RAG, the AI SDK, Meilisearch, Mixpanel and the libraries teams use every day. Every answer is written in plain English.
Senior Frontend Depth: React Internals, TypeScript & Testing
Topics that come up most in interviews: how React really renders, hooks in depth, concurrent React and Server Components, how to manage state, advanced TypeScript, how to test, and accessibility.
Scenario Debugging: The “It's Slow, Fix It” Guide
Scenario questions answered with one method you can repeat: measure, isolate, fix, check. API fast but UI slow, UI fast but API slow, re-renders, memory leaks, duplicate requests, slow first loads, huge lists and layout shift. Plus many cases about incidents, backend, frontend, security and architecture.
Practical Design Problems: From Whiteboard to Working Code
Small, practical design problems with the details interviewers listen for: IDs, collisions, caching, headers and what happens when things fail. A URL shortener, a rate limiter, pagination, file upload, notifications, autocomplete and classic mini-designs.
AI Engineering for Full-Stack Developers
Building LLM features you can trust: the OWASP Top 10 for LLM apps, prompt injection and safe tools, evaluation harnesses, cost and latency, and observability with guardrails. Every demo uses a deterministic fake model, so nothing needs an API key.
Career and leadership
Resumes, study plans, and the thinking of a team lead.
Software Engineer Career and Interview Playbook
How to prepare for software engineering interviews: a resume that gets read, a study plan mapped to the DSA lessons on this site, and mock interviews with a scoring sheet and a mistake log. Built from the public Tech Interview Handbook.
Team Lead & Development Mindset: The Questions Behind "Why?"
How a team lead thinks and the questions they ask: why this package, why this language, what are you thinking, how long will it take, what if it fails. Simple answer shapes, checklists and model answers for developers who want to lead.
Behavioral Interviews for Developers: Stories, Salary and Soft Skills
How to answer the questions that are not about code: tell me about yourself, strengths and weaknesses, conflict, failure, leadership, working with managers, notice periods and salary talks. Story frameworks and complete model answers in plain English.
Looking for a definition? Every series has a glossary, and they are all listed on the glossaries page.