ský · cloud raun · experiment, proof

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.

Get SkyRaun Foundations $99 once Read a whole lab, free →

Clone the repo · one command to start · your materials stay yours · private Discord · no video lectures

The map you should be able to draw from memory

semantics

what your application promised

app proto

HTTP · gRPC · WebSocket · SSE · MQTT · AMQP · Kafka · DNS

transport

TCP · QUIC · UDP

network

link

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.

Why this, why now

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.

Lab 04 · a taste, running right here

Your client timed out. Did the payment fail?

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.

timeout-ambiguity client timeout: 2.0s idle

0.000s

client

POST /payments amount=4200

0.014s

server

request received, handler entered

1.870s

server

payment committed · charge_01H8Z written to the ledger

2.000s

client

socket read timeout — no response bytes received

2.001s

client

reported to the caller: payment failed

2.410s

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.

How it actually reaches you

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.

01 git clone <your-access>

You get repository access on purchase. Version history, branches, diffs — the workflow you already live in.

02 python skyraun.py

One command opens the whole course in your local browser. Lesson, terminals, editable code and proof tests in one workspace.

03 git pull

New labs and fixes land the way any code lands. Your notes, answers and progress stay local and untouched.

127.0.0.1 — skyraun workspace 01 tcp byte streams

Lab 01 · foundations

TCP is a byte stream

When one program sends messages over TCP, how does the receiver know where each message ends?

TCP preserves byte order. It does not label application messages.

The client sent ALPHA, BRAVO, CHARLIE. Your server received three chunks that respect none of those boundaries:

ALPHA\nBRAVO\nCHARLIE\n

framing.py test_framing.py README.md

class Decoder:
    """Turn a byte stream into application messages."""

    def feed(self, chunk):
        self.buffer += chunk
        # a partial message must survive to the next read
        *done, self.buffer = self.buffer.split(b"\n")
        return done

Server

$ python raw_server.py --read-size 8
listening 127.0.0.1:9001
recv 8  b'ALPHA\nBR'
recv 8  b'AVO\nCHAR'
recv 5  b'LIE\n'

Client

$ python client.py --mode fragmented
sent 3 messages over 1 stream

$ python test_framing.py
FAIL split mid-message
FAIL two messages, one read

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.

The progression

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.

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.

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.

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.

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.

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.

See the incident challenges →

Inside Foundations

Fifteen modules 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.

Orientation

How to form a hypothesis, gather evidence, document a finding.

shipped

Processes, sockets, framing

Build a TCP client/server. Discover bytes are not messages. Repair the decoder, prove it against hostile read boundaries.

shipped

UDP and freshness

Datagrams, loss, ordering. When is stale data worse than missing data?

in build

HTTP fundamentals

Request/response on the wire, connection reuse, statelessness in practice.

in build

Timeout ambiguity

Client observation is not server reality. The flagship lab.

in build

Retries and idempotency

Duplicate side effects, idempotency keys, at-least-once. Incident: the customer was charged twice.

planned

DNS

Recursive resolution, TTL, caching, negative caching, failure behaviour.

planned

TLS

Certificates, identity, trust, handshake. Break trust on purpose.

planned

Realtime: polling, SSE, WebSockets

Three models for one requirement. Choose with reasons.

planned

RPC and gRPC

Contracts, protobuf, unary and streaming, and what retries mean here.

planned

Messaging fundamentals

Acknowledgement, visibility, delivery semantics, dead-lettering, backpressure.

planned

SQS

Processing time exceeds visibility timeout. Watch two workers take the same job.

planned

AMQP / RabbitMQ

Explicit broker topology: exchanges, bindings, prefetch, acks.

planned

Kafka

Retained log versus queue. Partitions, offsets, consumer groups, replay.

planned

Distributed systems foundations

Partial failure, ordering, deduplication, consistency, leases, failure detection.

planned

That status column is deliberate. SkyRaun is being built the same way it teaches — one concept built, broken and proven at a time. You are buying what is shipped today, plus updates to the Foundations track while it is actively maintained. Not a promise of a finished library, and not “lifetime updates forever”, because nobody can honestly sell that.

Full curriculum, module by module →

Honest qualification

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 module finished before you will start. Read the status column again.

The offer

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.

Not included, and not promised

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

$99one time

Permanent access to the materials you purchase. No subscription, no seat, no expiry on what you cloned.

Buy and clone the repo

Secure checkout by Stripe. Repository access is provisioned by hand today — expect a short, human turnaround.

Before you ask

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.

Get SkyRaun Foundations $99 once Read Lab 01 first