Mini Map
Search
⌘ K
AI Features
Log In
Grokking the Product Architecture Interview*
1.
Introduction to the Course
The Restaurant Analogy
Understanding the Client in Software
From Cafe to Code: The API
Understanding the Server
Highlighting the Power of APIs
Understanding API Gateways
APIs Are Products: Prioritize Clarity, Good Documentation, and De
Design-First vs Code-First: A Comparison
Quiz: Functional vs Non-Functional
The Power of APIs
The Importance of Good API Architecture
Understanding API Business Models
Understanding SLIs
Understanding SLOs
Understanding SLAs
How APIs connect systems, teams, and businesses.
2.
Network Intricacies
The Internet Layer Cake
Understanding the Narrow Waist in Networking
The Rise of HTTP
Understanding Throughput vs. Latency
Understanding Network Latency
Understanding Transmission Delay
Propagation Delay
Understanding Queuing Delay
Understanding Processing Delay
Understanding Jitter in Network Communication
Latency Check - Quiz
Understanding Sockets
Comparison of TCP and UDP Sockets
Key Terms to Remember
3.
Different Ways of Client-Server Communication
Understanding the Global Web
The Journey of a Click
Understanding Website Addresses
Understanding DNS Queries
Connecting to the Server
Understanding HTTP: The Backbone of the Web
Understanding HTTP Requests
Quiz: Choose the HTTP Methods
Understanding HTTP Status Codes
HTTP Evolution: From 1.0 to 2.0
HTTP/1.0: One-Off Trips
Understanding HTTP/1.1 Persistent Connections
HTTP/2.0: Parallel Streams
Understanding RPC: Remote Procedure Call
How RPC Really Works
Marshalling the Call
Handling Networking with RPC Runtime
Unpack, Run, Reply
The Challenge of Real-Time Communication
HTTP vs WebSocket: A Comparison
Understanding WebSocket Handshake
Web Architecture Recap
4.
Common Data Formats for Web APIs
Understanding API Communication
The Format Trade-Off
Journey of Data
Clash of Titans: XML vs. JSON
Check Your Knowledge: Mobile App Data Formats
Need for Speed: Binary Formats
The Power of Shared Schema
Choosing the Right Tool
5.
Comparison of API Architectural Styles
Blueprints for Communication
API Design Trade-offs
Understanding the Big Three API Styles
Understanding REST - An Architectural Style for Scalable APIs
REST's Stateless Superpower
Next Request: Total Amnesia
Avoid Using Verbs in REST URLs
CRUD vs HTTP Verbs: Which is the UPDATE HTTP Method?
REST's Data Problem
Understanding GraphQL: Efficient Data Retrieval
Write the Perfect Query
Efficient Data Matching with GraphQL
Introduction to gRPC: Google's High-Speed RPC Framework
Understanding gRPC with Binary Messages
Choosing an API Style: REST vs GraphQL & gRPC
Best Fit for Mobile Data
API Styles: Big Picture
6.
API Design Security
Why API Security Matters
The CIA Triad
The Importance of TLS Encryption
TLS Handshake: Hello Step
TLS: Server Verification
TLS: Sharing a Secret
TLS: Secure Session Establishment
Why Input Validation Matters
Client vs Server Validation: Which is More Secure?
Understanding Same-Origin Policy
Understanding CORS: Granting Cross-Origin Access
Authn vs Authz: Understanding Authentication and Authorization
Understanding JSON Web Tokens
Understanding OAuth 2.0
OAuth: Starting the Flow
Understanding OAuth: User Grants Access
OAuth: Code to Token
Comparison: OIDC vs SAML
Zero Trust Mindset
Recap: API Design Security
7.
Important Concepts in Product Architecture - I
The API Update Trap
Understanding Backward Compatibility
3 Ways to Version
Understanding URL Path Versioning
Using HTTP Headers for Versioning
Strategy 3: Hostname
Understanding API Evolution
Bulk Actions & Filters
Rate Limiting: The API Bouncer
How APIs Say "Slow Down"
Understanding HTTP 429 Error: Too Many Requests
Understanding Rate-Limit Headers
Rate Limit Check: What Should Your Client Do Next?
Optimizing API Responses
Comparison: Client-side vs Server-side Logic
Understanding Polling
Understanding Long Polling
Understanding WebSockets
Pick the Pattern
Key Concepts in Product Architecture
8.
Important Concepts in Product Architecture - II
The "Are We There Yet?" Problem
Visualizing the Event Flow
Understanding Webhooks
Comparison: Webhooks vs. Server-Sent Events vs. WebSub
Understanding HTTP Statelessness
Cookies vs. Sessions: A Comparison
Understanding the Auth Handshake
Setting the ID
Understanding User Recognition
Idempotency in Payment Requests
Understanding Idempotency Keys
Rendering: Server vs. Client
Understanding Client-Side Rendering
Title: Scenario: The SEO Challenge
Understanding Blockers in Web Development
Optimizing the Web
9.
Important Concepts in Product Architecture - III
The Need for Speed
Prefetch vs. Preload
Cutting the Line
Debouncing: The Traffic Cop
Understanding Circuit Breakers
State 1: Closed (Normal)
State 2: Open (Tripped)
State 3: Half-Open (Testing)
Understanding Circuit Breaker in Microservices Architecture
The Problem with Retries
Smart Retries: Backoff + Jitter
Handling HTTP Errors: Best Practices
Caching: The Memory Shortcut
Understanding Browser Cache
Understanding CDNs and ISP Caches
Layer 3: The Server
Understanding Stale Data Prevention
Eyes on the System
Robots vs. Humans: A Comparison
Tips for Optimization: Resource hints, Circuit breakers, Smart re
10.
Back-of-the-Envelope Calculations for Latency
The Speed of Data
Latency vs. Response Time
Journey of a Request
Understanding DNS Lookup
Understanding the SSL/TLS Handshake
Understanding HTTP Request and Response
Understanding Server Processing
Understanding Serial vs Parallel Work
Understanding Serial Processing
Understanding Parallel Processing
Pull vs Push Requests
Understanding Cold Starts
Highlight: Minimize Download Size for Faster Responses
Equation Quiz: Network Latency and Server Processing
Optimizing API Responses
Understanding CDNs for Faster Loading
Understanding Compression and Caching
Key Strategies for Optimizing Response Time
11.
REDCAMEL FRAMEWORK
The API Design Maze
Decoding REDCAMEL
Understanding API Requirements
Design Consideration
Designing the API Model
Evaluate & Latency
Designing Endpoints with REDCAMEL
Comparing REST and Other APIs
Interface vs. Implementation
Highlight Card: Reusing Core Blocks
Understanding the 4 Foundation Blocks
The Search Service
Understanding The File Service
The Comment Service
Understanding Pub-Sub Services
Knowledge Check: Order of Applying REDCAMEL Approach
REDCAMEL Overview: Design Principles and Best Practices
12.
Design a Search Service
The Importance of Designing a Search API
Functional vs Non-Functional Needs
Understanding the Search Engine Inner Flow
Indexer: Preparing the Data
Index Table: Fast Lookups
Searcher: Answering Queries
Comparison of Offset vs Cursor Pagination
Search System Overview
Quiz: Choosing REST & HTTP/1.1
Understanding Search GET Requests
Understanding Search API JSON Responses
Filter at Source, Not Edge
Understanding Search API Caching and Rate Limiting
Tips for Search API Essentials
13.
Design a File Service
The Cloud Storage Boom
Quiz: Core Functionality - What are the core functions a File API
Highlighting the Importance of a Reliable File API
Choosing the Architecture: REST vs gRPC
Understanding the Data Format Mix
Building the Workflow
Understanding Step 1: The Gateway
Step 2: Metadata Separation
Step 3: Blob Storage
Speeding Up Downloads
Handling Large Files
Tips for File API Design
14.
Design a Comment Service
The Journey of a Comment
The Journey of a Comment
Understanding the Request
Step 2: The Gatekeeper
Step 3: Storage
Key Features of Comment System
Highlighting the Importance of a Scalable Comment System
API Styles Overview: REST vs GraphQL & gRPC
Why APIs Love JSON
Match REST Verbs to Actions
Building a POST Body
Understanding Request Headers in Web Development
Designing the JSON Body
Async to Beat Slowdowns
Understanding GET and POST Requests
Key Features of Comment API
15.
Design a Pub-Sub Service
The Microservice Bottleneck
Sync vs. Async Communication
Visualizing Pub-Sub Flow
Understanding the Trigger Event
Step 2: Broadcasting
Step 3: Consumption
The 4 Core Actions
Key Features of a Reliable Pub-Sub System
Understanding High-Level Architecture
Comparison of REST and WebSub for Control and Events
Understanding Subscription Payloads
Handling API Failures: 404 Not Found vs 400 Bad Request
Should Subscription Requests Be Automatically Accepted?
Delivery Semantics
At-most-once (Fire & forget)
At-least-once (retries)
Understanding Exactly-Once Delivery
Key Concepts of Pub-Sub System
16.
YouTube Streaming API Design
The YouTube Challenge
YouTube: A Platform for Watching and Uploading Videos
How Streaming Really Works
Understanding Video Streaming Pipeline
Shrinking the Video: Understanding Encoding
Transcoding: Many Qualities
Segmentation: Tiny Chunks
Adaptive Bitrate in Action
Segmentation & ABR Check
Comparison: Publishing vs. Streaming
Why HTTP/2 Matters
Understanding Manifest Files
Client-Server Streaming Flow
Understanding the Video Request Process
Step 2: Get the Manifest
Fetching Segments
CDNs: Speeding Up Streams
Improving Video Startup Time
YouTube Architecture Recap
17.
Facebook Messenger API Design
Designing for Low Latency and High Consistency
Highlighting Modern Messenger Features
Splitting Text And Media
Protocol Showdown: HTTP/2 vs WebSocket
The Journey of a Message
Understanding the Send Process
Step 2: The Queue
Step 3: Delivery
WebSocket Handshake Process
Ensuring Message Delivery for Offline Users
Avoiding Media Duplicates
Architecture Quiz: Why WebSocket for Chat and HTTP/2 for Media Up
Tips for Optimizing Messenger Performance
18.
Google Maps API Design
Exploring Google Maps Backend
The Four Pillars of Mapping
The Map Service
The Route Finder
Live Navigation
Highlighting the Balance Between Accuracy and Latency
The Big Picture Architecture
Comparison: REST vs. WebSockets
How Maps Load: The Tile System
Understanding Map Requests
Understanding CDN Lookup
Stitching it Together
Match the Endpoint
Upgrading to Real-Time
Optimizing for Speed
Understanding Prefetching
Route Caching
Google Maps Design Recap
19.
Zoom API Design
Beyond the "Join" Button
Comparison: Features vs. Infrastructure
Signaling vs. Streaming
Scaling Multi-User Video
Understanding Peer-to-Peer Mesh Networking
Understanding MCU in Video Conferencing
Understanding SFU: A Traffic Routing Approach
Highlight Card: Efficient Video Quality Handling
Comparison: REST vs WebSockets
Pick the Right Protocol
Understanding WebSockets
Join Flow Overview
Validate Meeting
Setup Media Session
Connect and Stream
Beating Latency with Geo
Key Architecture Recap
20.
Leetcode API Design
Building LeetCode: The Challenge
Core Functional Requirements
Optimizing Browsing Experience
Understanding Code Submission
Contests & Leaderboards
Highlight: Strictly Sandboxed Execution
Splitting Microservices for Better Maintenance
GraphQL vs REST: A Comparison
Secure Containerized Execution
API Endpoint Design
Understanding Submit Request Payload
Handling Traffic Spikes: Quiz
Queues for Spiky Load
System Design Recap
21.
Payment Gateway API Design—Stripe
The Hidden Complexity of "Pay Now"
Consistency in Payment Systems
Visualizing the Payment Journey
Adding a Payment Gateway like Stripe
Understanding the Banks
Auth vs. Settlement
Design Decision: The API Split
Why might a payment API use x-www-form-urlencoded for requests bu
Preventing Double Charges
Understanding Card Network Communication
Is Stripe the Source of Truth for Card Validity and Funds?
Storage Strategy: SQL vs NoSQL
Understanding Reconciliation
Stripe API Journey Recap
22.
Twitter API Design
The Twitter Challenge
Twitter's Core Functionality: Write and Read
The Journey of a Tweet
Step 1: The Gateway
Step 2: Storage & Trigger
Notify Timeline
Comparison: Optimization - Active vs. Inactive
Understanding Twitter's API Protocol Choices
The Media Two-Step
Recall: Media Flow
Designing for Reliability
Understanding Latency Budget
Twitter Recap: How Tweets are Processed and Displayed
23.
Uber API Design
The Uber Orchestration
Identifying External Dependencies in Ride Experience
Comparison of REST and Pub/Sub Architecture
Workflow: Booking a Ride
Step 1: The Request
Step 2: Finding a Driver
Step 3: The Match
Defining the Endpoint
Title: Fill in the Blank - HTTP Requests for Ride Creation
Understanding Ride Request Processing
Optimizing Real-Time Tracking with Keep-Alive
Should Mobile Apps Call Third-Party Map APIs Directly from the Cl
Key Takeaways: Uber API Recap
24.
CamelCamelCamel API Design
Tracking Price Drops
Highlight: C3 - Amazon's Product Advertising API Wrapper
The Middleman Architecture
Step 1: The Request
Step 2: Amazon Handshake
Handling Orchestration Seamlessly
Comparing REST and WebSub Protocol
Bypassing Rate Limits
Designing API Endpoint Paths
Fill in the Blanks: Watch List Product Request
Amazon's API Security: HMAC-SHA256-signed Headers
Automating Data Updates
The Cost of Latency
Quiz: Availability Strategy
Overview of C3 Architecture
25.
Gaming API Design
Simulating a Living World
The Need for Speed: Engineering Challenge
Understanding the Authoritative Server Model
The Client Request
Understanding Server Validation
Understanding Game State Synchronization
Understanding Lag Compensation
Comparison of Elastic (REST/HTTP) vs Real-time (Game Servers)
Why Not HTTP?
Comparison: Data Diet - JSON vs. Binary
The Connection Upgrade
Understanding Matchmaking in HTTP
The Upgrade Handshake
Open Pipe (WebSocket)
Comparison: TCP vs. UDP
Gaming API Recap
26.
API Failures and Mitigations
Understanding API Failures
The 5 Pillars of Failure
Infrastructure Issues
Understanding Security Vulnerabilities
Development Bugs
Design Flaws and Dependencies
Knight Capital's $440M Value Loss
Anatomy of the Crash
The Dead Code
The Repurposed Flag
The Missed Server
Manual vs. Automated Deployment: A Comparison
The Typo That Broke the Internet
The Domino Effect
Input Error
Subsystems Crash
The Long Reboot
Why did the Amazon S3 reboot take around 4 hours?
Excessive Data Exposure
Case Study: The "View As" Hack
Understanding Broken Object Level Authorization
Fail-Proofing Strategies
Claim your Certificate
Home
Courses
Grokking the Product Architecture Interview*
Comparison: Client-side vs Server-side Logic
We'll cover the following...
This component is not supported in the current context
...