Skip to main content

🏗️ Serverless Architect Track

You are here:

This track teaches how to design production-grade serverless systems using system-design thinking. Not tutorials. Not vendor marketing. Just architecture.

🎯 Who this track is for​

  • Cloud engineers & platform engineers moving toward architecture responsibilities
  • Solution architects in training who must evaluate trade-offs across patterns and platforms
  • Experienced engineers seeking a disciplined, systems-first approach to serverless design

Not for absolute beginners? You should know what AWS Lambda and Google Cloud Functions are. This path teaches how to think about them, not how to click buttons in the console.

💡 Skills you will develop​

By the end of this track, you'll understand:

SkillWhat you'll know
System DesignMental models for stateless functions, event-driven flows, externalized state
Pattern LiteracyChoreography, orchestration, sagas, idempotency, backpressure handling
Multi-Cloud DesignHow AWS Lambda and Google Cloud Functions differ; how to avoid lock-in
Operational ThinkingObservability, cost attribution, reliability, failure modes at scale
Decision FrameworksWhen serverless wins, when it loses, how to make that call confidently

📚 How the track is structured​

🏗️ Foundation (7 lessons, ~25 min read)​

Building blocks and core principles. Conceptual models and why they matter.

  • Lesson 1: What serverless really means
  • Lesson 2: Event-driven thinking
  • Lesson 3: Stateless vs stateful
  • Lesson 4: Loose coupling and scale
  • Lesson 5: Compute concepts (cold starts, concurrency)
  • Lesson 6: What you can build with serverless
  • Lesson 7: When NOT to use serverless

Goal: Understand the serverless responsibility model and know whether it fits your problem.

⚙️ Advanced (7 lessons, ~30 min read)​

Patterns, trade-offs, and design matrices. How to assemble building blocks into durable systems.

  • Lesson 1: Architecture building blocks
  • Lesson 2: API-driven architectures
  • Lesson 3: Event-driven architectures
  • Lesson 4: Event brokers and message ordering
  • Lesson 5: Error handling and resilience
  • Lesson 6: Orchestration vs choreography
  • Lesson 7: Observability at scale

Goal: Design systems you can operate confidently. Know the trade-offs for every decision.

🚀 Expert (6 lessons, ~25 min read)​

Large-scale operational concerns, advanced patterns, cross-cloud resilience. For architects making high-stakes decisions.

  • Lesson 1: Advanced patterns (Saga, CQRS, event sourcing)
  • Lesson 2: Distributed systems fundamentals
  • Lesson 3: Multi-cloud operations
  • Lesson 4: Advanced security (IAM, secrets, supply chain)
  • Lesson 5: Cost engineering
  • Lesson 6: Chaos and resilience testing

Goal: Make confident architecture decisions across AWS and GCP. Operate reliably and cost-effectively at scale.

🎨 Tone and approach​

Lessons are calm, practical, and senior-level.

  • Architectural thinking first, concise examples second
  • Multi-cloud perspective throughout (AWS Lambda + Google Cloud Functions)
  • No marketing language — just honest trade-offs and guardrails
  • Decision-focused — why a pattern matters, when to use it, when to avoid it
  • Real gotchas — common mistakes with solutions

✅ How to use this track​

First time here?​

  1. Start with Foundation Lesson 1
  2. Read sequentially through Foundation (builds on itself)
  3. Take a break—synthesize what you've learned
  4. Jump to whichever Advanced lesson matches your current project

Already have serverless experience?​

  1. Skim Foundation to verify mental models (30 min)
  2. Deep-dive into Advanced lessons that match your gaps
  3. Use Expert as reference material

Building something right now?​

  1. Find the closest match in the table above
  2. Read that lesson + related ones
  3. Open the style guide and FAQ for quick lookups

📖 Before you start​

  • Have 20–30 minutes per lesson (don't rush)
  • Code examples are optional — the explanation is the core
  • Try it yourself — apply concepts to your own systems
  • Disagree with something? Contribute your perspective

Ready? Start with Foundation →

Full read time: ~80 minutes (all lessons). You can read one lesson at a time.