DevTab/Labs

DevTab Labs

Learn by watching it run

Interactive, step-by-step visualizations of the concepts you use every day but rarely see drawn out. Pick a lab, hit play, then change the inputs and break it on purpose.

Watch every frame

Step, pause and rewind. Each state change is explained in plain language.

Change the inputs

Edit code, headers or config and see the outcome change instantly. Break things on purpose.

Private by design

Everything runs in your browser. No sign-up, nothing is sent anywhere.

JavaScript

How the language runtime really schedules your code.

1 lab

JS Event Loop Visualizer

See the call stack, microtasks and timers run, frame by frame.

  • Why a resolved promise always beats setTimeout(0)
  • What await really does to a function
  • How to predict console.log order in interview puzzles
10 minIntermediate12 examplesOpen lab

Networking & the Web

What happens between the browser and the server, from DNS to caches to CORS.

3 labs

CORS & Preflight Simulator

Edit the request and the server headers, then see exactly why the browser blocks it.

  • When the browser sends a preflight — and when it doesn't
  • Why * and cookies can never be combined
  • How to read and fix the classic CORS console errors
12 minIntermediate9 examplesOpen lab

HTTP Caching Explained

Cache-Control, ETag and 304s, one request at a time.

  • The real difference between no-cache and no-store
  • Why a deploy can stay invisible for hours
  • How reload and hard reload behave differently
12 minIntermediate8 examplesOpen lab

What Happens When You Type a URL

DNS, TCP, TLS and HTTP — with a stopwatch.

  • The full DNS lookup chain, hop by hop
  • Why every new connection costs round trips
  • What TLS 1.3, keep-alive and HTTP/3 actually save
10 minBeginner8 examplesOpen lab

Databases

Indexes, transactions, load, sharding and replication — how SQL databases cope.

4 labs

How Database Indexes Work (B-Tree)

See a B-tree lookup beat a full table scan, and why some queries ignore your index.

  • Why an index turns millions of reads into a handful
  • The leftmost-prefix rule for composite indexes
  • When the planner ignores an index on purpose
12 minIntermediate8 examplesOpen lab

What Happens When 100 Reads Hit the Database

Connection pools, CPU workers, caches and replicas, as 100 requests arrive at once.

  • Why a small connection pool queues requests
  • The difference between waiting for a connection and for CPU
  • How index, cache and replicas each multiply capacity
12 minIntermediate9 examplesOpen lab

SQL Isolation Levels Lab

Run two transactions side by side and watch dirty reads, phantoms and write skew appear.

  • What each isolation level actually guarantees
  • Why REPEATABLE READ still allows write skew
  • When SERIALIZABLE aborts a transaction (and why you must retry)
15 minAdvanced5 examplesOpen lab

Sharding & Replication

Split data across servers, copy it for reads, and see what each choice costs.

  • How range, hash and consistent hashing place rows
  • Why adding a shard can move almost every key
  • How replication lag causes stale reads
15 minAdvanced9 examplesOpen lab

Redis

In-memory data structures, commands and caching patterns.

2 labs

Redis Commands & Data Structures

Strings, lists, hashes, sets and sorted sets, one command at a time.

  • Which Redis structure fits which problem
  • How TTL and expiry work
  • Counters, queues, leaderboards and locks in a few commands
15 minBeginner8 examplesOpen lab

Redis Caching: Cache-Aside, TTL & Eviction

Hit or miss? Watch LRU, LFU, TTLs and a cache stampede decide your database load.

  • How cache-aside reads and fills the cache
  • Why LFU beats LRU when a scan runs
  • What a cache stampede is and how single-flight stops it
12 minIntermediate9 examplesOpen lab

Queues & Jobs

Webhooks, cron, BullMQ and RabbitMQ — how background work is scheduled, delivered and retried.

4 labs

Webhooks: Delivery, Retries & Signatures

Why you get duplicate deliveries, lost events and forged requests — and how to stop them.

  • Why webhooks are delivered at-least-once
  • How slow handlers cause duplicate processing
  • Fast ack + queue, idempotency keys and HMAC verification
12 minIntermediate9 examplesOpen lab

Cron Jobs: Schedules, Overlaps & Missed Runs

Write a cron expression and watch what really happens when jobs overlap or the scheduler is down.

  • How the five cron fields combine (and the dom/dow OR trap)
  • What happens when a run takes longer than the schedule
  • Why plain cron silently misses runs during downtime
10 minBeginner9 examplesOpen lab

Job Queues with BullMQ (Redis)

Watch jobs move through waiting, active, delayed, completed and failed — and see what BullMQ stores in Redis.

  • The five states of a job and who moves it between them
  • Retries, exponential backoff and poison jobs
  • How a crashed worker's job is detected and recovered
14 minIntermediate9 examplesOpen lab

RabbitMQ: Exchanges, Queues, Acks & Dead Letters

Direct, topic and fanout routing, competing consumers, prefetch, redelivery and dead-letter queues, drawn.

  • How direct, topic and fanout exchanges route a message
  • Why prefetch decides whether work is shared fairly
  • What happens to unacked and poison messages
14 minIntermediate9 examplesOpen lab

Git

Commits, branches, HEAD and refs — drawn so they finally click.

2 labs

Git Commands, HEAD & Refs (Visual)

Every core git command drawn with arrows: three areas, commits, branches, HEAD and remotes.

  • What HEAD, branches and tags really are
  • The three areas and the command that moves files between them
  • reset --soft/--mixed/--hard, revert, cherry-pick and fetch vs pull
15 minBeginner10 examplesOpen lab

Git Merge vs Rebase

Watch the commit graph change under merge, rebase and squash.

  • Why rebase gives new commit IDs
  • When a merge is a fast-forward
  • The one rule: never rebase shared history
10 minBeginner7 examplesOpen lab

Want a lab on something else?

Tell us which concept never clicked for you — the next lab is picked from requests.

Request a lab