Reports మరియు ML కోసం ఒక high-volume event-tracking pipeline డిజైన్ చేయండి — ఏ stack?

Question

IT Interview Practice · Accepted Answer

రోజుకు hundreds of millions of events (~సెకనుకు కొన్ని వేలు, peaks వద్ద ఎక్కువ) వద్ద గెలిచే move ఏమిటంటే ingestion ను serving నుండి decouple చేయడం: writes ను ఒక durable log లోకి absorb చేయండి, stream ను ఒకసారి process చేయండి, మరియు వ్యతిరేక jobs కోసం tune చేయబడిన రెండు stores కి fan out చేయండి — parents కోసం pre-aggregated (fast reads), ML కోసం raw మరియు full-fidelity.

ఒక mailroom — collector mail ను receive చేస్తుంది, Kafka అనేది conveyor belt, మరియు ప్రతి item రెండు shelves పైకి copy చేయబడుతుంది: parents చూసే ఒక , మరియు ML team తవ్వే ఒక .

**Mental model:** ఒక mailroom — collector mail ను receive చేస్తుంది, Kafka అనేది conveyor belt, మరియు ప్రతి item రెండు shelves పైకి copy చేయబడుతుంది: parents చూసే ఒక *summary board*, మరియు ML team తవ్వే ఒక *full archive*.

## Write path (ingest)

```text
Client ─(batch)─▶ Collector ─▶ Kafka ─▶ Stream proc ─┬─▶ OLAP rollup  (daily summaries)
 (learning app)    (HTTP)     (buffer,   (read once)  └─▶ S3 / Parquet (raw events)
                              replay)
```

- **Collector** HTTP ద్వారా **batched** events ను తీసుకుంటుంది — client పై batching hundreds of millions of tiny writes ను చాలా తక్కువ requests గా మారుస్తుంది.
- **Kafka** అనేది durable buffer: ఇది spikes ను absorb చేస్తుంది, producers ను consumers నుండి decouple చేస్తుంది, మరియు ML ఒక feature ను add చేసినప్పుడు లేదా మీరు కొత్త rollup ను introduce చేసినప్పుడు history ను **replay** చేయనిస్తుంది.
- **Stream processor** Kafka ను ఒకసారి read చేసి రెండు sinks కి వ్రాస్తుంది — lake కి raw ను append చేయండి, reports కోసం rollups ను upsert చేయండి.

```js
// ఒక consumer Kafka ను ఒకసారి read చేసి రెండు sinks కి వ్రాస్తుంది
for await (const batch of kafka.consume('events')) {
  await lake.appendParquet(batch);                      // raw -> S3/Parquet (ML)
  for (const e of batch)
    rollup.add({ childId: e.childId, day: dayOf(e.ts) },// aggregate -> OLAP (reports)
               { lessons: 1, studiedMs: e.studiedMs ?? 0 });
  await rollup.flush();
}
```

## Read path (serving)

```text
Parent app ─▶ API ─▶ OLAP rollup                 (pre-aggregated: report = O(1), no scan)
ML / Data  ─▶ Spark / warehouse ─▶ S3 / Parquet  (raw, flexible, ad-hoc)
```

Parents **pre-aggregated summaries** ను hit చేస్తారు, కాబట్టి ఒక report అనేది ఒక key lookup, billions of rows పై scan ఎప్పటికీ కాదు. ML **raw lake** ను query చేస్తుంది, feature engineering కోసం ప్రతి field ను ఉంచుతుంది.

## Stack & ఎందుకు
- **Kafka** — buffer, decouple, replay.
- **ClickHouse / daily summary tables** — parent dashboards కోసం read-optimized.
- **S3 + Parquet** — ML కోసం cheap, columnar, flexible raw storage.
- **Schema registry** — event contract ను enforce చేయండి, తద్వారా producers నిశ్శబ్దంగా consumers ను break చేయలేరు.

## Interview lens
మీరు **write-optimized ingest ను read-optimized serving నుండి** separate చేస్తారా, ప్రతి parent report కోసం raw events ను scan చేయడాన్ని నివారిస్తారా, మరియు ML కోసం raw data ను ఉంచుతారా అని interviewer probe చేస్తారు. **Weak:** "అంతా Postgres లో పెట్టి query చేయండి." **Strong:** durable buffer + రెండు serving paths + replay + ఒక schema contract, scale పై అవగాహనతో.

## Trade-offs
Pre-aggregation instant reads ను ఇస్తుంది కానీ dimensions ను ముందుగానే fix చేస్తుంది; raw lake flexible కానీ slow. **రెండింటినీ** ఉంచండి — classic write-once, read-many split.

Write path (ingest)

Read path (serving)

Stack & ఎందుకు

Interview lens

Trade-offs

సంబంధిత ప్రశ్నలు