Python test workbench
test_cache.pyTerminalPASSED
Example: a Python test checks that an LRU cache evicts its least recently used item, and both tests pass.
Open the workbench ↗
FREE, HANDS-ON SOFTWARE LABS
Practice software engineering by taking systems apart.
Interactive labs on caching, queues, consistency, architecture, and AI-assisted delivery, with real Python in your browser and a project you can show in your portfolio. New to programming? A free path takes you from your first function.
- Free
- No account needed
- Progress stays on your device
- English and Spanish
LRU cache & request queue
CACHE
QUEUE
Requests wait in the queue. Each one is a hit or a miss.
Open the full experiment ↗
THE LABS
Change one thing. Watch the system react.
Each lab isolates one idea: predict what will happen, move a lever, and check. Use them on their own, or as practice for a lesson.
- ExperimentALGORITHMSSearch, made visiblePut linear and binary search on the same track. Watch how a better question eliminates work.Open the lab
- ExperimentPERFORMANCEInside an LRU cacheWalk a request stream through a small cache. Discover why recency is useful—and when it fails.Open the lab
- ExperimentSYSTEM DESIGNWhen queues get longerControl incoming work, worker count, and service time. Find the point where a system falls behind.Open the lab
- ExperimentDISTRIBUTED SYSTEMSThe cost of a stale readWrite to a leader, read from a replica, and make replication lag tangible.Open the lab
- WorkbenchDESIGN UNDER CONSTRAINTSThe architecture decision deskChange the context, compare three designs, and write down the tradeoff you are willing to own.Open the lab
- WorkbenchAI-ASSISTED DELIVERYThe AI delivery labWrite a contract, turn it into a brief for an AI assistant, and review the patch it proposes before you accept it.Open the lab
- Python practiceREAL PYTHON15 Python challengesWrite code in the browser against real tests, from small functions to queues and retries. Hints when you are stuck.Open the lab
8 more labs are in the works. See what is coming ↓
NEW TO PROGRAMMING? START HERE
Learning paths
A path is a sequence of stages with short lessons, practice, and checkpoints, free from start to finish. Lessons shared between paths count once.
Available
Software engineering
From values and functions to data structures, tests, APIs, architecture, distributed systems, production, and engineering with AI.
8 stages · 40 lessons · 15 Python challenges · 5 experiments
Open the path ↗- 01First principles
- 02Data & decisions
- 03Code you can trust
- 04Programs meet the world
- 05Software Architecture
- 06Systems under pressure
- 07Engineering in the open
- 08Engineering with AI
4 more paths are in the works. See what is coming ↓
HOW YOU LEARN HERE
Understand, experiment, build, repeat.
Lessons you can see
Every lesson has a diagram, short sections, glossary terms explained on the spot, and a two-question checkpoint. Spaced recall brings ideas back before you forget them.
Real Python, no setup
Write and run Python in the browser against real tests. Hints when you are stuck, and your drafts are saved as you type.
Experiments with levers
Change one variable and watch a cache, a queue, or a replica react. Predict first, then check.
A project that grows with you
Relay starts as a tiny job queue and gains an API, a database, workers, and observability, one stage at a time.
THE PROJECT
Relay: from a list in memory to a system that survives failure.
One codebase, seven evolutions. Each stage adds a capability you can explain, test, and show in an interview.
- 01A useful programFirst principles
- 02Make the data do the workData & decisions
- 03A codebase someone else can trustCode you can trust
- 04Turn the program into a servicePrograms meet the world
- 05An architecture with a reasonSoftware Architecture
- 06Design for concurrency and failureSystems under pressure
- 07Operate it and explain your decisionsEngineering in the open
WHAT’S NEXT
New labs first, then new paths.
A direction, not a promise: what is being planned and in which order. New labs come first, because each one is practice you can use on its own. Everything here will be free, like the rest.
Labs in the works
SQL workbench
Write SQL against a small seeded database that runs in your browser, check each query against the expected rows, and keep your drafts as you go. The same editor as the Python challenges, for joins, grouping, and constraints.
Rate limits under pressure
Send bursts of traffic to a fixed window, a sliding window, and a token bucket side by side. See where each one lets a burst through, what a refused client receives, and how a limit protects a shared service. The Python challenge builds one token bucket; this lab compares the algorithms under traffic.
Retries without a storm
Many clients retry against a service that is recovering. Compare immediate retries, exponential backoff, jitter, and a retry budget, and watch when retries help and when they keep the service down. The Python challenge computes one schedule; here you see a crowd of clients at once.
Index or full scan
Move a selectivity slider and compare reading a table through an index with scanning all of it, then add writes and watch each index slow them down. The search experiment compares two ways to search a sorted list; this one asks when a database should keep that sorted shortcut at all.
Visual Git
Run commit, branch, merge, rebase, reset, and revert, and watch the commit graph and HEAD change as you type. Challenges ask you to reach a target graph or recover a lost commit, without touching your own repositories.
A terminal you cannot break
A simulated shell on a virtual file system: move around, combine small tools with pipes and redirection, and solve tasks checked by the files you leave behind. It is deterministic and safe, so a wrong command costs nothing.
Spread the load
Send requests to several servers with round robin, least connections, and two random choices. Slow one server down and see which policy notices. The queues experiment has one shared line; here each server has its own, and the balancer has to choose.
Follow the signal
A service gets slow. Use its logs, metrics, and a trace to find the dependency behind it, write down the evidence, and decide which alert would have caught it sooner.
Paths in the works
Fundamentals
Start from zero: how a computer works and why software runs, logic and your first programs in Python, and algorithmic thinking with searching, sorting, and recursion. The recommended first path.
Terminal & Git
Move around a Linux shell with confidence, combine small tools with pipes, write safe bash scripts, and use Git without fear: branches, merges, and recovering lost work. With a simulated terminal and a visual Git lab in the browser.
Data engineering
From your first SQL query to modeling, query plans, isolation levels, and incremental pipelines, then streaming and data in production. With a SQL workbench in the browser and Pulse, an analytics pipeline built on Relay.
DevOps
Servers, containers, continuous delivery, infrastructure as code, orchestration, and reliability, practiced with browser simulations and guided local exercises, ending with Ship Relay: package, deploy, observe, and operate the system you built, optionally on a free cloud account.
Honest by design
No account, your data stays with you
Your progress, notes, and drafts live in your browser, not on a server. Export a backup whenever you like.
Evidence over hype
The learning design follows research on retrieval, spacing, and worked examples, and says where the evidence ends.
Built to be reviewed
Every exercise is tested automatically, and the content says plainly what has not been reviewed yet.
Not sure where to begin?
Answer a few short questions and get a starting stage. About three minutes, nothing is graded.