Skip to main content

Learning Path — A Guided Onboarding Sequence

The Concepts chapters are a ~2.5-hour read that gives you the full picture. This page is for going deeper, hands-on — a paced sequence (~5–6 focused days) that interleaves reading with tracing the real system, so you reach working fluency, not just familiarity.

Two tracks​

  • Conceptual (½ day): read the Concepts chapters in order (Parts 1→4). That's the whole mental model. If that's all you need, you're done.
  • Hands-on deep dive (this page, ~5–6 days): for engineers who'll change the code — pair each chapter with a live trace through the running stack.

Prerequisite — stand up your own sandbox first​

Everything below is far more concrete against a team you own. Before Day 1:

  1. How to run the stack locally
  2. Tutorial: Set Up Your Own Sandbox Team (with How to onboard a new team as the terse recipe)

You'll end up with a Flex + Premium schema, a published program, and built inventory — your own specimen to trace.

The loop — run it on every topic​

Don't read passively. For each subsystem:

  1. Read the chapter(s) below — don't re-derive what's already written.
  2. Map the code with the knowledge graph — graphify query/path/explain (cross-repo) or the code-review-graph tools (callers/callees/flows/impact). Get the route → service → repo → table chain without manual grep.
  3. Trace it live — exercise the feature in your sandbox, watch the Network tab (route → payload), and inspect the DB (read-only) to watch the tbl_* rows change.
  4. Capture — a short note + a diagram, and a list of open questions.

The spine — two loops the whole platform is built around​

  • Admin write → fan read: Cortex writes tbl_* → flex-v3-backend reads them (cache invalidation closes the loop).
  • Fan purchase journey: catalog → inventory → cart → checkout.

Everything else (auth, vendors, crons, config layers, Premium/Flow) hangs off these.

Day 0 — Orientation & toolkit​

  • Read: Start Here + Concepts Part 1 (1–5) + 27 — Environments & Sandboxes.
  • Do: the prerequisite above (run the stack + set up your own team).
  • Internalize: the multi-tenant spine — X-Team-Schema → whitelist guard → schema-aware repos, the same on both backends.
  • Deliverable: a running stack + your own sandbox team.

Day 1 — The data model (tables & relationships)​

  • Read: the Entities & Tables reference (one page per domain) + Glossary.
  • Trace: inspect your populated schema in the DB — group the tbl_* by domain (catalog/venue · program/pricing · suites · inventory · cart/order · config) and the dashboard schema (clients/products/schemas/users). Note the FKs.
  • Deliverable: a per-domain ER diagram built from your real schema.

Day 2 — Catalog & inventory (admin build → fan read)​

  • Read: Concepts 6–9, 13, 16–20.
  • Trace: the inventory build you just ran (Cortex → TM manifest → tbl_seats/tbl_sections) → the fan read. Tutorial: trace the inventory build — coming soon.
  • Deliverable: an "inventory lifecycle" note (vendor → tables → fan) with the route names.

Day 3 — Cart & checkout (the core transaction)​

  • Read: Concepts 22, 24, 25, 26 + Cart & Orders reference.
  • Trace: Tutorial: Trace a Purchase through the 4 core APIs, then run a live cart→checkout in your sandbox. Tutorial: trace cart→checkout live — coming soon.
  • Deliverable: a sequence diagram of cart→checkout for both vendors, with table writes annotated.

Day 4 — Admin write path + config layers + cache​

  • Read: Concepts 18 — Snapshots & the Config Layers + Debug wrong pricing (shows config in action).
  • Trace: a Cortex save → tbl_* row → cache invalidation → the fan seeing it; the 4 config layers (base/program/client/frontend). Tutorial: admin write → fan read — coming soon.
  • Deliverable: a "one mutation, end to end" note.

Day 5 — Cross-cutting: auth, vendors, crons, Premium/Flow​

  • Read: 25 — The Two Ticketmasters + 27 — Environments & Sandboxes.
  • Topics: TM OAuth flow (redirect → JWT → Bearer); the vendor flattening layer (Archtics/Host/TDC/SeatGeek → common interface); the crons; the Premium divergence and the (tiny) Flow product.
  • Deliverable: a vendor-integration map + an auth-flow diagram.

Day 6 — Frontend deep-dive (route → page → API)​

  • Read: Working with team schemas + the app-config system you touched setting up your team.
  • Trace: map each fan-journey page (events_home → select_events → select_inventory → checkout) to the backend routes it calls; how app-config themes per schema; Cortex admin pages → write routes. Tutorial: route ↔ page ↔ API map — coming soon.
  • Deliverable: a "route ↔ page ↔ API" matrix per frontend.

Where a day points to a tutorial that doesn't exist yet, run the trace yourself — the loop above is all you need. A guided version will join Trace a Purchase over time.