Learn Networking via Game

NetRoute is a packet logistics game. You wire up computers, switches, routers, firewalls and gateways, set each device, and watch glowing packets travel. If a packet gets dropped, the game shows you which header field was wrong. Every level adds one device or one rule. You start by plugging in a cable and end by keeping a Kubernetes app alive while Pods crash.

What you will learn

Level 1 · Cables and packets: what a packet carries (MAC, IP, port, protocol)
Level 2 · Hub vs switch: watch a hub flood every wire and collide, then let a switch learn MAC addresses
Level 3 · Broadcasts and ARP: shout "who has 10.0.0.7?" and fill the MAC table
Level 4 · VLANs: split one switch into separate rooms
Level 5 · The router and subnetting: join two coloured networks, then masks, /24 vs /16 vs /26, network and broadcast, splitting and sizing networks
Level 6 · Default gateway: give every computer a way out of its own network
Level 7 · DHCP: hand out addresses automatically instead of typing them
Level 8 · DNS: turn names into IPs before anything can be sent
Level 9 · Ports and protocols: TCP vs UDP, and which service lives on which port
Level 10 · The TCP handshake: SYN, SYN-ACK, ACK, and what a reset means
Level 11 · Firewall rules: green packets in, red packets out (ALLOW 80, DENY UDP)
Level 12 · Stateful vs stateless firewalls: why the reply packet still needs a way back
Level 13 · NAT: many private computers share one public IP
Level 14 · MTU and fragmentation: packets that are too big for the pipe
Level 15 · TLS: lock the packet so only the server can read it
Level 16 · Load balancer: spread a flood of packets across servers, skip dead ones
Level 17 · Cloud VPC: public and private subnets
Level 18 · Internet Gateway: let the world reach the web server
Level 19 · NAT Gateway: let the private database download updates without being reachable
Level 20 · Security groups vs network ACLs
Level 21 · VPN tunnel: join the office network to the cloud
Level 22 · CDN: answer from a nearby copy instead of the far server
Level 23 · BGP basics: how networks announce "send it to me"
Level 24 · Kubernetes Pods: every Pod gets its own IP, cni0 bridge and veth cables
Level 25 · Kubernetes Service: one steady virtual IP in front of Pods that come and go
Level 26 · Pod crash: the Service keeps routing to the Pods that survive
Level 27 · Ingress and Gateway API: route by host name and path
Level 28 · NetworkPolicy: zero trust, only the allowed arrows stay open
Guru · Rush hour: a huge flood of packets, nodes failing, and you keep every user online

How it works

Every level adds one device or one rule. You start by plugging in a cable and end by keeping a Kubernetes app alive while Pods crash.

More courses

Jobs, linked to lessons — Browse jobs where every requirement links to the chapter that teaches it. See how ready you are, how long the gap takes to close, and which listings look stale.
Match a job post to courses — Paste a job post. Each skill is matched to a track here and put in learning order, foundations first.
React from open source with patterns — Patterns extracted from Material UI, Radix, React Aria, React Hook Form, Redux Toolkit, TanStack, and Next.js — not slides about hooks.
Database in depth — How a query becomes work. Indexes, isolation, locks, and the plans that explain why a page is slow — not an ORM tour.
System Design — Core concepts first (SQL vs NoSQL, CAP, indexing, replication, sharding), then designs grouped by what carries them: the database, Redis, Kafka, or many services.
Build a real API with NestJS — One ticket-booking API, built in order: a plain Node server first, then NestJS modules, validation, a real database, and the features real clients lean on.
Microservices — Microservice patterns one diagram at a time: how to split a monolith, how services talk, and how data stays consistent without distributed transactions.
Kafka — A beginner-to-senior path through event logs, reliable delivery, production operations, and disaster recovery.
AI engineering for software engineers — Eight free reads, in order, for software engineers moving into AI: when to build an agent, how to build one, how to test it, and how the model works underneath.
Frontend system design — How a UI is sliced when it is a product, not a page: ownership of state, cache, routes, and what happens when the network lies.
TypeScript in depth — The type system as a design tool. Inference, narrowing, generics, and the errors that mean the model is wrong — not a catalog of utility types.
CSS in depth — See the box, then the page. Visual chapters from the box model through Flexbox surprises, Grid, selectors, and units, then backgrounds, shapes, and visual effects, each with a playground.
Accessibility — Foundations first (WCAG in plain words, semantic HTML, lists, alt text), then hands-on HTML labs, a full pass of WAI-ARIA 1.3, and a final fix-the-page challenge.
Docker — What an image is, why layers cache, and how containers find each other on a network.
Redis — Fifteen Redis patterns, one picture each: cache, session, lock, counter, rate limiter, queue, and when Redis is the wrong tool.
Kubernetes — Kubernetes from zero to operators: why it exists, Pods, Deployments and Services, then configuration, networking, storage, scheduling, scaling and security.