Walk into any system and know exactly where it breaks.
SkyRaun is a hands-on infrastructure laboratory you clone and run on your own machine. Sockets, HTTP, queues, Kafka, partial failure — each one predicted, observed, deliberately broken, repaired, and proven. You come out able to name the guarantee, find its edge, and show evidence for what actually happened.
Beta price $99 · then $149 founder · $199 full price · clone the repo · one command to start · your materials stay yours · private Discord · no video lectures
what your application promised
HTTP · gRPC · WebSocket · SSE · MQTT · AMQP · Kafka · DNS
TCP · QUIC · UDP
IP
ethernet · wifi · cellular
Point at any row and say what breaks, who retries, and where the guarantee ends. That is the whole job. That is what SkyRaun trains.
Generating the code was never the hard part.
Your assistant is very good at producing a plausible retry loop, consumer, or client. It is not the thing that gets woken up when the plausible version quietly does the wrong thing twice.
It will write your retry. It will not tell you the POST already committed on the other side before the timeout fired.
It will wire up your consumer. It will not tell you the acknowledgement you are trusting means “received”, not “processed”.
It will scaffold the architecture. It will not be on the incident call explaining why the same invoice went out to 40,000 customers.
Code got cheap. Judgment about boundaries, guarantees and evidence did not.
Your client timed out. Did the payment succeed?
This is the first real aha in SkyRaun, and you can have it before you buy anything. Run it. Answer honestly. Most engineers get it wrong the first time, and that is exactly the point.
client
POST /payments amount=4200
server
request received, handler entered
server
payment committed · charge_01H8Z written to the ledger
client
socket read timeout — no response bytes received
client
reported to the caller: payment failed
server
200 OK written to a socket nobody is reading any more
Run the request, then answer.
Nothing has happened yet. Start the exchange and watch where the two sides stop agreeing about reality.
Two minutes from clone to a system you can break.
No platform login, no streaming player, no “module 1 of 84”. It is a real repository on your disk, and it stays on your disk.
git clone <your-access> You get repository access on purchase. Version history, branches, diffs — the workflow you already live in.
python skyraun.py One command opens the whole course in your local browser. Lesson, terminals, editable code and proof tests in one workspace.
git pull New labs and fixes land the way any code lands. Your notes, answers and progress stay local and untouched.
Prefer your own tools? Every lesson is plain Markdown with real commands. Open the folder in your editor, run the programs in your own terminal, skip the workspace entirely.
Progress is yours. Your last lesson, layout, notes and answers are stored locally alongside the lesson — not in someone else's database.
Convenience is removed on purpose, stage by stage.
Every course starts by holding your hand. Very few deliberately let go. SkyRaun's whole structure is the letting go — by the end nobody tells you which layer is lying to you.
01
Guided
“Today we are studying HTTP timeout ambiguity.” The system is built for you, the concept is named.
you leave able to Describe the mechanism in your own words.
02
Experimental
Change the variables and predict first. Raise the timeout. Add a retry. Remove idempotency. Slow the worker.
you leave able to Predict behaviour before you run it.
03
Fault lab
You know the system. You do not know what has been broken in it. “This message is processed more than once. Find out why.”
you leave able to Form a hypothesis and pick the tool that tests it.
04
Incident
Symptoms only, the way they actually arrive. “Customers occasionally receive duplicate invoices.” Here are logs, config, a diagram, a terminal.
you leave able to Separate a symptom from a cause under pressure.
05
Black box
The failing layer is not disclosed. “Requests intermittently take 8–12 seconds.” DNS? Retransmission? Pool exhaustion? Retry amplification?
you leave able to Walk into an unfamiliar system and ask the right question first.
Sixteen lessons of mental models, not a technology tour.
Concept before vendor: durable queue before SQS, publish/subscribe before SNS, retained log before Kafka. Cloud services show up as implementations of ideas you already understand.
00
How SkyRaun works
How to form a hypothesis, gather evidence, document a finding.
shippedPREP
Python syntax calibration
Optional warm-up on the small Python forms the labs reuse. Skip it if Python is covered.
prep01
TCP byte streams
Build a TCP client/server. Discover bytes are not messages. Repair the decoder, prove it against hostile read boundaries.
shipped02
UDP datagrams and freshness
Datagrams, loss, reordering. Stop stale telemetry from moving state backward.
shipped03
HTTP on the wire
A real HTTP/1.1 exchange, and a Unicode Content-Length defect that ASCII concealed.
shipped04
Timeouts and unknown outcomes
Client observation is not server reality. The flagship lab.
shipped05
Safe retries and idempotency
Duplicate side effects, idempotency keys, at-least-once. Replay the original result instead of charging twice.
shipped06
DNS caching and TTL
Resolver memory versus authoritative truth. Repair a cache that serves answers past expiry.
shipped07
Digital signatures
What a signature binds, what it detects, and the trust question it cannot answer.
shipped08
Certificates and chain trust
Path discovery versus trust. Accept a service key only after every parent authorises its child.
shipped09
TLS 1.3: authenticate a live server
Separate encryption from identity, then restore chain and hostname verification.
shipped10
Polling and Server-Sent Events
Turn repeated snapshots into one long-lived, server-driven event stream.
shipped11
WebSockets
A real HTTP Upgrade, a reconnect that silently skips state, and the replay policy that recovers it.
shippedPREP
Go syntax and tooling calibration
Optional warm-up: compile and test a real Go package so Lesson 12 stays about gRPC.
prep12
Protocol Buffers and gRPC
Typed contracts, generated APIs, and a deadline that actually cancels server work.
shippedPREP
Docker and Compose
Optional checkpoint: declare, run, probe and tear down a container environment.
prep13
Durable queue fundamentals
Acknowledgement, visibility, dead-lettering — and a worker crash that redelivers instead of losing.
shipped14
SQS visibility and duplicate delivery
Processing time exceeds visibility timeout. Watch two workers take the same job.
shipped15
RabbitMQ and AMQP
Explicit broker topology: exchanges, bindings, prefetch, acks.
shipped16
Kafka foundations and replay
Retained log versus queue. Partitions, offsets, consumer groups, replay.
shipped17
Distributed systems capstone
Evidence from every layer combines in one incident. Included when released — it lands in your clone as an update.
includedSixteen lessons are shipped and runnable today, organised into six paths, with three optional prep checkpoints that calibrate you right before the lessons that need them. The capstone is part of your purchase and arrives with git pull when it releases. You are buying what is shipped today, plus updates to the Foundations track while it is actively maintained — beta buyers get every one of them. Not “lifetime updates forever”, because nobody can honestly sell that.
This will suit some engineers badly.
Built for you if
- You ship production code and could not, right now, say precisely what your broker's acknowledgement guarantees.
- You are moving toward senior backend, platform, infra or SRE work and want stories you actually lived.
- You would rather spend an evening making something fail on purpose than watching someone else's screen recording.
- You are comfortable in a terminal and can read code in at least one language.
Skip it if
- You want lectures to play in the background while you do something else.
- You want a certificate, a badge, or a completion percentage to show someone.
- You are learning to program. Come back once you have shipped something real.
- You need every last module shipped before you will start. Sixteen lessons are runnable tonight — only the capstone is still to land.
One payment. The materials stay yours.
- The complete private repository — curriculum, runnable systems, starters and solutions, on your disk.
- Guided labs with fault injection — every lab includes the breaking, not just the building.
- Incident challenges — symptoms first, cause hidden, diagnosis on you.
- The local browser workspace — lesson, terminals, editable code, proof tests, one command.
- Or just the Markdown — real commands, your editor, your terminal, no workspace required.
- Private Discord — lab help, incidents, architecture, show-your-work. See what's in it.
- Updates while maintained — new labs arrive with git pull, like any code you depend on.
- The beta promise — buy at the beta price and you get every Foundations update, the capstone included when it releases.
A hosted lab environment (“SkyRaun Live”) is being explored for instant clusters and richer incidents. If it ever launches, Foundations buyers get a complimentary period. It has no date, and everything above runs entirely without it.
SkyRaun Foundations
Beta price — then $149 founder pricing, $199 full price. Permanent access to the materials you purchase. No subscription, no seat, no expiry on what you cloned.
Buy and clone the repoSecure checkout by Stripe. Your repository invite is sent automatically the moment payment is confirmed; if anything fails, a human fixes it fast.
The four things people push back on.
Is any of this video?
No. There is no player, no talking head and no playback speed control. Lessons are written the way one engineer briefs another: the concept, the prediction, the command, the evidence, the explanation. You spend your time in a terminal and an editor. Read a whole lab and judge for yourself.
Do I need an AWS account or paid cloud services?
Not for the foundations. Labs are local-first — Python, Docker and Docker Compose cover the early curriculum, and Lab 01 needs nothing but Python and a browser. Where a lab genuinely requires a managed service, it says so up front, including that it may cost you money.
I already know TCP. Is this too basic?
Lab 01 exists because engineers who "know TCP" still ship framing bugs that only appear under unfriendly read sizes. The curriculum is not measured in facts you can recite — it is measured in failures you have caused, diagnosed and repaired. If you can already explain where every guarantee in your stack ends, and prove it with a tool, you do not need this.
What exactly do I own afterwards?
The clone on your machine. It keeps working with no login, no subscription and no dependency on anything staying online. Updates to Foundations are included while the track is actively maintained, and pulled with git. If SkyRaun disappeared tomorrow, what you cloned still runs.
Break something on purpose tonight.
Clone it, run one command, and find out whether your mental model survives contact with a real socket. Beta price $99 · then $149 founder · $199 full price.