Learn the systems
by breaking✦ them.
126 interactive builds160 playable lessons208 handbooks550+ free videosfree forever
A free, open-source place to learn AI and system design by doing — take a real system apart in the browser, watch it fall over, and build the intuition that sticks. No sign-up, no paywall. Built in the open by an AI engineer.
Come back tomorrow.
A fresh challenge and a lab every day — keep the streak alive.
Become a Forward Deployed Engineer.
Learn the engineering, applied AI and customer judgment needed to move a real deployment from an ambiguous problem to production, measurable value and handoff.
- 3
- entry routes
- 7
- guided phases
- 1
- customer capstone
- 6
- mock interview rounds
Every path threads handbooks, system designs, runnable challenges and tools into one ordered course — follow the whole thing or dip in. Free, with your progress saved as you go.
Become an AI Engineer
For developers building real features on top of LLMs.
Adapt to the AI Era
For engineers who want to get more valuable as AI makes code cheap.
Ace the AI Engineer Interview
For AI/ML engineer interview loops.
Ship an AI Product
For indie hackers and founders shipping AI products solo.
Master LLM Evaluation
For engineers who need to prove their AI actually works.
ML Engineering Foundations
For developers moving from app code into machine learning.
Master Context Engineering
For engineers whose agents forget, ramble, or blow the window.
The Papers Bootcamp
For engineers who want to read the canonical deep-learning papers in the right order.
AI for Product Managers
For PMs shipping AI features who want to reason about them without writing code.
Land Your First Dev Job in the AI Era
For new and bootcamp grads facing "AI is killing junior roles — what do I even learn?"
Switch Careers into Tech and AI
For career switchers coming from a non-tech field into tech/AI.
Pass the System Design Interview
For engineers prepping the system-design loop.
Level Up as a Backend Engineer
For backend engineers going deeper on distributed systems.
Reliability & Scale (SRE)
For engineers who keep systems up as traffic grows.
Become a Forward Deployed Engineer
For engineers who want to own the whole arc — problem to production, at the customer.
System Design in 30 Days
For engineers who want to design real systems, not memorize diagrams.
Distributed Systems Deep Dive
For engineers who want consensus, replication and consistency in their bones.
From Sysadmin to DevOps / SRE
For system administrators moving into DevOps, SRE, or platform engineering.
From DBA to Data Platform Engineer
For database administrators moving into data engineering / data platform work.
Crack the Coding Interview
For the algorithms half of the loop.
Advanced Algorithms & Data Structures
For when the interview basics aren’t enough.
Build an LLM From Scratch
For engineers who want to understand a language model down to the matrix multiply.
The 4-Week Interview Sprint
For engineers with a loop on the calendar and four weeks to prepare.
From Manual Tester to SDET
For manual QA testers moving into software development engineer in test (SDET) / automation.
Interactive builds — take a real system apart.
System designs, AI systems, algorithms and labs you can run, break, and rebuild right in the browser. This is the part you can’t get from a blog.
Builds you can break.
System designs, AI systems, algorithms, and labs — every one is a working build. Build Netflix step by step, make the calls, break the system, run the quiz.
Design Netflix
Build a planet-scale video streaming service. See how the play path splits authorization from byte delivery, how origin storage and CDN edges serve immutable segments, how an adaptive-bitrate ladder adapts to any connection, how a parallel transcoding pipeline builds it, and how Open Connect, recommendations and QoE events fit together.
Design Uber
Build a planet-scale ride-hailing system. Learn how to handle real-time location tracking, matching algorithms, scalability, and payments.
Design WhatsApp
Build a real-time messaging system. See how persistent WebSockets, a session registry, offline inbox queues, the ✓✓ delivery receipts, group fan-out, media on a CDN, and end-to-end encryption fit together.
Design a URL Shortener
Build a URL shortener (think Bitly or TinyURL). Learn how to mint unique short codes with base62, make the read-heavy redirect path sub-millisecond with caching, shard billions of mappings, and track clicks asynchronously.
Design Instagram
Build a photo-sharing app. See how splitting media from metadata, a CDN for immutable images, async image processing, a precomputed feed cache, asynchronous like/view counters, TTL-based ephemeral stories, and sharding fit together to serve billions of photos.
Design a Conversational AI
Build a production conversational AI system (think ChatGPT). See how the request path splits an inference gateway from the model servers, how the context window is assembled and token-budgeted, how conversation memory is stored and recalled, how tokens stream back over a persistent connection, and how guardrails gate every prompt and response.
Design a RAG Pipeline
Build a retrieval-augmented generation pipeline. See how documents are chunked and embedded, how a vector store answers semantic search, how two-stage retrieval with reranking finds the best passages, how the prompt is grounded to stop hallucination, and how evals keep a quietly-drifting index honest.
Dijkstra: The Last Mile
Don't watch Dijkstra's algorithm — play it. Drive a courier through a living isometric city, lose the fastest route to your own instincts, then meet the Dispatcher who floods the streets to find the optimal path every time. Four acts: drive it, watch the frontier, predict the next lock, then break it with a negative cycle.
Binary Search: The Vault
Don't memorize binary search — play it. Crack a vault of sorted dials, burn through guesses by instinct, then meet the Halver who throws away half the search space with every single look and finds any value in O(log n). Three acts — crack it, watch the window collapse, predict the midpoint.
Quicksort: The Pivot Pit
See quicksort actually work — then drive it. Watch the pivot partition an array in place, smaller-left and larger-right; pick your own pivot and feel how its position sets the balance; then feed it an already-sorted list and watch a fixed pivot melt down to O(n²) — and fix it with one random line. Three acts — watch the pivot, pick the pivot, break the worst case.
Merge Sort: The Cascade
Don't read about merge sort — play it. Watch single-element runs cascade upward into one sorted array, merge two sorted halves by hand by always taking the smaller front, then prove the payoff: O(n log n) on sorted, reversed and shuffled input alike — the guarantee quicksort can't make. Three acts — watch the cascade, merge two runs, prove the guarantee.
BFS: The Flood
Don't memorize breadth-first search — play it. Find your own way through a maze, then release the flood that spreads from the start in rings and touches the exit by the shortest path every time, then watch depth-first search dive deep and miss it. Three acts — navigate it, release the flood, BFS vs DFS.
A* Search: The Ascent
Don't memorize A* — fly it. Orbit a real 3D mountain, climb it by instinct, then meet the Pathfinder who folds one optimistic guess into Dijkstra's flood so the whole search leans straight at the summit. Four acts in live 3D — climb it, watch the heuristic beat the blind flood, predict the lowest-f pop, then break optimality with a heuristic that lies.
Sieve of Eratosthenes: Prime Time
Find every prime under 100 without dividing once. Hit play and watch the multiples fall away in cheerful waves while the primes light up gold — whatever's left standing is prime. A playable take on the 2,000-year-old sieve, with the theory, a worked example and a quiz.
Build Order: DFS & Topological Sort
Don't memorize topological sort — play it. Schedule eight interdependent build tasks by hand and feel the constraints bite, then let a depth-first search dive to the bottom of every dependency and surface a valid build order by reversing its finish times. Three acts — schedule it yourself, watch DFS reverse-post-order it, then add one bad edge and watch it detect the cycle and refuse.
Six Degrees: Union-Find
Don't memorize the Disjoint Set Union — play it. Wire up nine strangers one handshake at a time and watch separate friend circles merge into one, hit a redundant connection and see it refuse to close a cycle, then click any node to run find and watch path compression flatten the tree so the next lookup is instant. Union by rank, path compression and the near-constant O(α(n)) that powers Kruskal's MST — plus full theory, a runnable challenge and a quiz.
The Tournament: Heap Sort
Don't memorize heap sort — watch the tournament play out. See an array read as a binary tree, build it into a max-heap where every parent beats its children so the champion sits at the root, then pluck that root maximum to the end again and again as the sorted region grows from the right. Sift-down, the two phases, and why it's O(n log n) in place with no extra memory — plus full theory, a runnable challenge and a quiz.
Gradient Descent: The Descent
Don't read about gradient descent — play it. Roll a ball into the valley of a loss landscape by hand and waste steps, then let the algorithm read the slope and step downhill on its own. Crank the learning rate until it overshoots and explodes, dial it down until it crawls, then switch on momentum to escape a local minimum. Four acts — descend it, follow the gradient, tune the learning rate, escape the trap.
The Tokenizer
A language model can't read words — it reads tokens. Watch your text shatter into sub-word chunks, race character vs word vs sub-word tokenizers head-to-head, then build Byte-Pair Encoding by hand: merge the most frequent pair over and over to grow a vocabulary and shrink the sequence. Five acts — shatter it, race three tokenizers, build BPE, tune the vocab size, and feel why 'strawberry' trips up an LLM.
Everything here actually runs.
Real Python & TypeScript, executed in your browser — no install, no backend. Every algorithm and system-design page carries an editor like this: read it, edit it, run it, break it.
The library — handbooks and roadmaps.
Long-form field manuals and visual paths, fundamentals to production. Free, no sign-up.
Longer form, for when you're ready.✦
Full-length handbooks and visual roadmaps — agentic AI, LLM evals, RAG, Angular, Python. Free to read, take what you need.
The Prompting Handbook
A hands-on field guide for everyday humans — CRISP framework, real recipes, a drag-and-drop game, and a quiz. No code required.
The Prompting Handbook.
A friendly, hands-on field guide for everyday humans — learn the CRISP framework, spot bad prompts, practice with real recipes, play a drag-and-drop game, and test yourself with a quiz. No code required.
The Agentic AI Interview Handbook.
Twenty topics every senior AI engineer should be able to reason about live — from eval pipelines to reliability patterns for generative systems.
The Senior AI Engineer Interview Handbook.
60 questions across architecture, production incidents, agentic systems, RAG, evals, cost, safety, and leadership — what staff-level AI interviewers actually probe for.
50 Angular Interview Questions.
A visual handbook covering components, change detection, RxJS, signals, routing, forms, performance, and testing — what interviewers actually probe for in senior Angular roles.
50 Python Interview Questions.
Fundamentals to advanced: data structures, OOP, iterators & generators, the GIL, asyncio, memory, testing, and the standard library — a visual walk through everything a Python interview touches.
51 LLM Evals Interview Questions.
Golden sets, LLM-as-judge, regression testing, offline vs online evals, RAG evals, agent evals, red-teaming, and observability — demystified for interviews and production.
Forward-Deployed Engineer Roadmap.
A visual transit-map roadmap to the most in-demand AI role of 2026 — the engineer who ships AI where the customer lives. From rapid prototyping, enterprise RAG and integration glue through discovery, customer data wrangling, VPC deployment, security reviews and client evals to stakeholder craft, incidents, proving ROI, and scaling pilots into repeatable production. 18 stations across 3 tracks — The Craft, The Field, The Outcome.
AI Engineer Roadmap.
A visual transit-map roadmap to become an AI engineer in 2026. From how LLMs work through embeddings, RAG, agents, and fine-tuning to evals, guardrails, inference serving, and observability. 18 stations across 3 tracks — Foundations, Build, Production.
System Design Roadmap.
A visual transit-map roadmap for system design in 2026. From APIs, databases, caching, and load balancing through sharding, queues, consistent hashing, and consensus to end-to-end designs of Twitter, YouTube, and Uber. 18 stations across 3 tracks — Fundamentals, Building Blocks, Real Systems.
AI Harness Roadmap.
A visual transit-map roadmap to build an AI harness — the runtime around a model that turns it into an agent. From the messages API, tokens, and structured output through tool calling, the agent loop, context management, memory, and sandboxing to permissions, subagents, evals, observability, and cost control. 18 stations across 3 tracks — Model I/O, the Agent Loop, Production.
Backend Engineer Roadmap.
A visual transit-map roadmap to become a backend engineer in 2026. From HTTP APIs, SQL, NoSQL, caching, and auth through API design, message queues, testing, and observability to Kubernetes, CI/CD, sharding, and reliability. 18 stations across 3 tracks — Foundations, Core Backend, Production.
Prompt Engineering Roadmap.
A visual transit-map roadmap from tokens and CRISP through chain-of-thought, RAG, and agent prompting to production monitoring. 18 stations across 3 tracks — interactive, free, your own pace.
Build a Real AI App.
A hands-on, build-along course: go from a naive 10-line RAG script that breaks at scale to a production retrieval-augmented app — chunking, embeddings and vector search, hybrid retrieval and reranking, grounded citations, the agent loop, evals, caching and streaming, prompt-injection defense, and deploy + monitoring. Every episode embeds the video and links to the deeper reference on each idea.
How LLMs Actually Work.
A visual, first-principles course on what's really happening inside a language model: attention, tokenization, embeddings, mixture-of-experts, fine-tuning and LoRA, RLHF, and diffusion. Seven short episodes, each embedded with a hands-on lab and the deeper reference — the mechanism, not the analogy.
The AI Engineer.
A concepts-first course on the craft of AI engineering: context and memory, embeddings and vector search, tools and agents, hallucination and grounding, the glue around the model, evals, deploy and monitoring, and prompt-injection security. Nine short episodes, each embedded with a hands-on companion and the deeper reference.
Data Structures & Algorithms.
The CS-interview core, made visual: hash tables, Big-O, binary search trees, heaps, tries, dynamic programming, and graphs. Seven short episodes, each embedded and paired with an interactive game in the Algorithms arcade — watch the idea, then play it.
Concurrency.
The topic that humbles confident engineers, made visual: race conditions, locks and mutexes, deadlock, threads vs processes, the async event loop, concurrency vs parallelism, and the actor model. Seven short episodes, each embedded with the deeper systems reference.
How the Internet Works.
Follow one web request from the moment you hit Enter to the pixels on your screen: DNS, IP and packets, TCP, HTTP, HTTPS/TLS, and CDNs. Seven short episodes that trace the whole journey end to end, each embedded with the deeper reference.
How Databases Work.
Open the black box: how indexes find one row in a billion, how transactions and the write-ahead log survive a crash, how isolation stops two writes from colliding, how caching absorbs read load, and how vector databases search by meaning. Five short episodes, each embedded with the deeper reference.
How Your Computer Works.
The layers under your code, one short episode each: the CPU, floating point, UTF-8, segmentation faults, garbage collection, flash memory, compression, public-key crypto, the speed of light, and what a container really is. Ten visual episodes that turn "it just works" into "I know why."
Browse the whole workshop.
Every format, one place. Pick a subject or a shape and dive in.
- Guided pathsGoal-first courses
- TopicsBrowse by subject
- System designsBreak real systems
- AI system designsLLM & agent stacks
- AlgorithmsPlayable DSA
- LabsRunnable concepts
- HandbooksLong-form manuals
- RoadmapsSkill maps
- PapersBreakdowns
- ChallengesSolve in-browser
- CoursesVideo series
- ToolsFree calculators
- CheatsheetsQuick reference
- GlossaryPlain-language terms
- FDE AcademyCollege to job
- Daily ByteFive a day
- FlashcardsSpaced repetition
- My dashboardStreak & progress
More: open-source projects · writing from the bench · about Vibe Engines
Stop reading. Break something.
Pick a real system, knock a node out, and watch it reroute — or fall over. That’s the intuition that sticks.
Questions people ask before they start
Is everything on Vibe Engines really free?
Yes. Every system-design build, handbook, roadmap, lab, coding challenge and tool is free, with no paywall, no trial and no upsell. The site is static and open-source; there is nothing to buy.
Do I need an account to use it?
No. There are no accounts and no sign-up. Your progress, streak and flashcard reviews are stored in your own browser (localStorage) and never leave your device — which also means clearing site data resets them, so use the export button on the dashboard if you want a backup.
Where should I start?
Start with one interactive system-design build — break a node and watch the system reroute or fall over. From there, /learn has guided courses by goal or role, and /handbook has the written explanations behind every build.
What is an FDE (Forward Deployed Engineer)?
A Forward Deployed Engineer builds and ships software directly alongside a customer — part engineer, part solutions architect, embedded in the deployment rather than behind a backlog. The FDE Academy track covers the full skill set: system design, AI systems, customer discovery, and the interview loop.
What makes this different from reading a system-design blog post?
The diagrams run. Each build reveals one concept at a time, you can trigger real failure modes and see traffic reroute or drop, and the labs and challenges execute actual Python in the browser. You practise the system rather than read about it.
Is this useful for system design interviews?
Yes — the interactive builds walk the same architectures interviews ask about (Uber, Netflix, a URL shortener, RAG pipelines, inference serving), one decision at a time, with the trade-offs named. Each finishes with a quiz that checks you can defend the design.
Build with the workshop.
The repositories are open, the issues are tagged, and contributions are welcome — from a typo fix to a whole module.
Contribute to a repository.
All projects are MIT-licensed and live on GitHub with open issues. Start with anything tagged good first issue or propose your own. PRs get reviewed fast.
Drop a line.
Working on something interesting? Want to collaborate, trade notes, or just say hello? Email finds its way here. Genuine messages get genuine replies.