🛸 Hitchhiker's Guide — Phase 00: The Principal Data Infra Engineer

Read this if: you can build a data pipeline but "design our data platform" still sounds like a different job. It is. This is the compressed tour the WARMUP derives slowly. Skim it, then read the WARMUP.

0. The 30-second mental model

You are hired to build the layer other engineers build on, and to be the person who, when latency and cost and correctness fight, picks the winner with numbers and writes down why. One sentence to tattoo: you don't own a pipeline, you own the lifecycle and the tradeoffs across it — encoded into a platform.

1. The lifecycle, one breath

creation → ingestion → validation → transport → processing →
storage → query → serving → governance → replay → deletion

Every technology in this track is one slot in that line. Learn the slot, then the tool. The bugs live in the seams between slots (processing-time logic that breaks on replay; PII that flows from creation to an open query table). Principals think in seams.

2. The five forces (score everything on these)

ForceThe questionThe trap
Correctnessdoes output match reality?silent corruption — you find out from an exec
Latencyp99 event→result?"real-time" with no number
Throughputsustained & peak, read:write ratio?sizing to average, dying at peak
Cost$/event, $/TB scanned, $/TB storedoptimising latency nobody asked for
Operabilitycan a 4-person on-call run it?the cost juniors forget; it dominates

A "requirement" with no number on these axes is a wish, not a spec.

3. The dials you'll turn forever

low latency ⟷ low cost            (what does a minute of staleness cost?)
exactly-once ⟷ simplicity         (what does one dup / one loss cost?)
flexible schema ⟷ safe contract   (how many consumers, how costly is breakage?)
self-service ⟷ governance         (answer is usually: self-service WITH guardrails)
freshness ⟷ replay-correctness    (can you replay deterministically? → Kappa, else Lambda)
serving speed ⟷ analytical reach  (you need both; wire them safely — P11)
cloud lock-in ⟷ OSS portability   (fast to adopt vs yours to leave)

The interview signal: when they add "…and cheap," can you name the dial and price it?

4. The numbers you'll actually use

ThingNumber
Athena/Trino scan$5 / TB scanned → layout is a cost feature
S3 request scaling~3,500 PUT/s, 5,500 GET/s per prefix
Spot savingsup to ~90%, 2-min reclaim warning
Kinesis shard1 MB/s & 1000 rec/s in, 2 MB/s out
Strong quorumR + W > N (equal is not strong)
Parquet target file128 MB – 1 GB (small files = the tax)
Cassandra partition< 100 MB, < ~100k cells

5. Budget the latency, spend the slack

Decompose an end-to-end SLA across stages. If the SLA is 15 min and you consume 42 s, the other 14 min is a cost lever — batch writes harder, use spot, compact lazily. Juniors optimise latency they don't need; principals convert it to dollars.

6. War story shapes you'll relive

  • "Our counts doubled overnight." → a replay hit a processing-time aggregation. Fix is event-time + idempotency, not "stop replaying" (replay is the platform's best feature).
  • "The query bill 10×'d." → someone wrote a million small files / dropped partitioning. The fix is layout, not a bigger warehouse.
  • "12 jobs are down!" → they all read one Hive metastore. One incident, not twelve. Ask "what's the shared resource?" first.
  • "It's exactly-once, we're fine." → only inside Kafka. Crossing into Cassandra you re-earn it (upsert/dedup) or you don't have it.

7. Vocabulary that signals you've held the pager

  • Blast radius / failure domain — what fails together; the first incident question.
  • Exactly-once effect — the only exactly-once that exists.
  • Data product — a dataset with an owner, SLA, contract, lineage.
  • Backpressure — downstream slowness as upstream flow control.
  • ADR — the durable record of a decision and what would reverse it.
  • Kappa vs Lambda — one replayable streaming path vs two code paths.
  • Self-service with guardrails — the only scalable answer to the governance dial.

8. Beginner mistakes that mark you in interviews

  1. Jumping to "use Kafka" before extracting numbers and the read:write ratio.
  2. Saying "real-time" or "scalable" with no percentile / no peak number.
  3. Treating exactly-once as a free platform default instead of a per-product dial.
  4. Optimising latency the SLA didn't ask for (and paying for it).
  5. Designing without a failure-domain picture, then being surprised by blast radius.
  6. Making decisions in chat instead of ADRs — so they're re-litigated every quarter.

9. How this phase pays off later

  • The lifecycle is the spine: every later phase fills one slot.
  • The five forces + dials are the scoring function behind every later architecture choice and every interview round.
  • The latency budget + cost model (the lab) is literally Round-1 mental math.
  • The ADR habit is Round-5 (architecture leadership) and your day job as a principal.

Now read the WARMUP slowly, then build the modeler. You'll use its functions as back-of-envelope checks for the rest of the track.