Overview
free

Appendix A - Diagram Templates by Step
Appendix B - Mapping Concepts to Real-World Streaming Stacks
Appendix C - Readiness Checklists
Appendix D - Glossary

Course Setup and the Incremental Ladder
Why Signals to Streams
How to Use This Course
The Incremental Ladder (Step 0 to Step 7)
The Course Lenses
Diagram Legend and Notation Types

Signals, Events, and Streams
Signals vs Events
Streams vs Batch
The Core Loop (Producer to Decision)

Time in Data Systems
Event Time vs Processing Time
Clocks and Skew
Time Semantics as a Contract

Ordering, Lateness, and Out-of-Order Data
Ordering Realities: Per-Partition Ordering vs the Myth of Global Order
Lateness and Out-of-Order: Late Arrivals, Backfills, and What "Correct" Means in Motion
Watermarks (Conceptually): Deciding "How Late Is Too Late" and Operationalizing That Decision

From Logs and Metrics to Streams
Telemetry as Streams: Logs, Metrics, Traces as Time-Series and Event Streams
Aggregation as Streaming: Metrics Rollups, Downsampling, and Near-Real-Time Views
Streaming Boundaries: Where Observability Pipelines Resemble Product Event Pipelines (and Where They Differ)

Diagramming Real-Time Data Systems
Timeline Diagrams: Event Sequences, Causality, and Ordering Assumptions
Producer-Broker-Consumer Flows: Queues and Logs as System Topologies
Processing DAGs and Stateful Operators: How to Draw Streaming Logic and Its State

Step 0 Modeling: Time-Series and Event Shapes
Modeling Time-Series: Measurements, Tags/Labels, Values, and Cardinality Risk
Modeling Events: Keys, Timestamps, Payloads, and Append-Only Thinking
Time-Series vs Events vs Logs: Choosing the Right Mental Model for the Question

Step 0 Sampling, Granularity, and Aggregation
Sampling and Downsampling: Choosing Resolution Without Destroying Meaning
Buckets and Rolling Aggregates: Time-Based Grouping and "Sliding" Interpretations
Storage/Query Trade-offs: Write Patterns, Query Patterns, and Retention Constraints

Step 0 Minimal Stream Architecture
One Producer, One Consumer: The Smallest Working Stream
Minimal Stores: Simple Append, Simple Reads, Simple Replays
Early Failure Modes: Timestamp Mistakes, Inconsistent Keys, and Accidental Distributed Time

Step 1 Messaging Models
Point-to-Point vs Pub/Sub: Distribution, Fan-Out, and Coordination Costs
Competing Consumers: Work Distribution and Concurrency Boundaries
Messaging Anti-Patterns: Request/Response Misuse and Coupling That Breaks Scaling

Step 1 Queues vs Append-Only Logs
Queue Semantics: Destructive Consumption and "Who Owns the Work"
Log Semantics: Immutable Append, Offsets, and Replay as a Feature
Choosing the Model: Latency, Durability, Reprocessing, and Cost Trade Spaces

Step 1 Producers, Consumers, and Delivery Semantics
Producer Responsibilities: Batching, Retry, Serialization, and Backoff
Consumer Responsibilities: Checkpoints, Idempotency, and Safe Restarts
At-Most vs At-Least Once: What "Duplicates" Mean to Your Downstream

Step 1 Offsets, Replay, and Reprocessing
Offsets as Positions: Why "Where Am I?" Is the Core Recovery Primitive
Rewind and Rebuild: Reconstructing Views From Logs and Designing for Repair
Reprocessing as Normal: Backfills, Bug Fixes, and Schema Evolution

Step 1 Message and Event Schema Design
Event Envelopes: Metadata, Correlation IDs, Trace IDs, and Routing Fields
Compatibility Over Time: Forward/Backward Evolution and Versioning Discipline
Schema Registries (Conceptual): Governance Mechanisms for Change at Scale

Streaming Platforms as Distributed Logs
Topics and Partitions: Scaling Throughput via Parallel Streams
Replication and Durability: Why "A Log" Becomes "A System"
Control Plane Roles: Brokers, Controllers, and Coordination (Conceptual)

Consumer Groups and Parallelism
Consumer Groups: Scaling Reads While Preserving Per-Partition Order
Assignment and Rebalancing: Why Coordination Events Cause Latency Spikes
Designing for Rebalance: Idempotency, Warm Caches, and Safe Pauses

Retention, Compaction, and Storage Policies
Retention as a Product Choice: Time/Size Policies and How Far Back Can We Repair?
Compaction as a Pattern: Latest-Value-Per-Key vs Full History
Storage Planning: Tiering, Cost Controls, and Long-Lived Streams

Acknowledgments and Delivery Guarantees
Producer Acks: Durability vs Latency vs Cost
Committing Offsets: Recovery Behavior and Failure Windows
Guarantee Trade-offs: The Practical Meaning of "Durable Enough"

Operating Streaming Clusters
Capacity Planning: Throughput, Partitions, Replication, and Disk
Upgrades and Scaling: Operational Risk, Rolling Changes, and Traffic Safety
Multi-Tenancy: Quotas, Isolation, and Noisy-Neighbor Problems

Managed vs Self-Managed Streaming Services
Responsibility Split: What You Keep vs What the Provider Owns
Cost and Lock-In: Portability, Hybrid Patterns, and Migration Planning
Operating Model Fit: Team Skill, Reliability Needs, and Compliance Boundaries

Batch vs Streaming vs Micro-Batch
Streaming as "Always-On Computation": Why Latency Budgets Shape Everything
Micro-Batch Models: Throughput Wins, Latency Costs, and Operational Simplicity
Choosing the Model: Workload Shape, Cost, and Correctness Expectations

Stateless Stream Processing
Core Operators: Map/Filter/Route/Enrich and Simple Aggregates
Lookups and Enrichment: Joining Against Reference Data Without Building State Machines Accidentally
Idempotent Transforms: Safe Replays and Repeatable Outputs

Processing Topologies and DAGs
DAGs as the Mental Model: Sources -> Operators -> Sinks
Partitioning Through the Graph: Where Keys Change and Costs Spike
Operator Boundaries: Coupling, Isolation, and Debugging Ergonomics

What Frameworks Provide
Runtime Scheduling and Execution: What "the Framework" Does for You
Connectors and Integrations: Sources and Sinks as First-Class Reliability Boundaries
Preview of State: Why State Management Is the Hard Part You Are About to Inherit

Designing Stream Processing Jobs
Decomposing Problems into Operators: Choosing Responsibilities That Survive Change
Debuggability by Design: Observability Hooks and Introspection Points
Operational Readiness: Failure Modes, Restart Behavior, and Safe Rollouts

State in Streaming Systems
Per-Key State: The Unit of Scalability (and the Unit of Pain)
Aggregates and Summaries: Building "Live Views" over Streams
State Growth and Eviction: TTLs, Compaction, and What Happens When State Never Dies

Windowing Concepts
Tumbling, Sliding, and Hopping Windows: Three Ways to Slice Time (and Three Ways to Confuse People)
Session Windows: Gap-Based Grouping and Behavioral Interpretation
Late Events and Completion: Allowed Lateness and When Results Become "Final Enough"

Streams–Tables Duality
Stream as Changelog: Turning Events into a Table of "Current Truth"
Materialized Views: Serving Real-Time Queryable State
Rebuild and Repair: Correctness via Replay and Deterministic Reconstruction

Joins in Streaming
Stream-Stream Joins: Windows, State, and Time Alignment
Stream-Table Joins: Enrichment and Dimension Lookups in Motion
Watermarks and State Costs: How "Correctness" Consumes Memory

Stateful Operator Design
Safe State Handling: Snapshots, Migrations, and Rebalances
Scaling Stateful Operators: Partitioning Strategies and Hotspots
Operational Realities: State Bootstrap Time and Recovery SLOs

Data Modeling for Streaming Use Cases
Entities vs Events in Real Time: Modeling for Joins, Aggregates, and Replays
Keys and Correlation: Multi-Stream Linkage Without Chaos
Designing for the Future: Schema Choices That Keep Reprocessing Viable

Failures in Streaming Systems
Failure Taxonomy: Node Loss, Partitions, Slow Tasks, Poison Messages
Partial vs Full Failure: What Restarts Actually Restart
Retries Revisited: Idempotency as the Survival Trait

Checkpointing and Recovery
Consistent Snapshots: What It Means to "Save State" in a DAG
Replay from Offsets + State: Rebuilding Exactly What You Had
Checkpoint Frequency Trade-offs: Overhead vs Recovery Point Objectives

Delivery Semantics in Depth
At-Most Once: When Losing Data Is Acceptable (and How to Be Honest About It)
At-Least Once: Deduplication, Idempotent Sinks, and Practical Correctness
Exactly/Effectively Once: End-to-End Constraints and Where Systems Cheat

Transactions and Two-Phase Commit (Conceptual)
Atomic Write + Offset Commit: The Core Problem Statement
When 2PC-Like Patterns Appear: Coordinating External Side Effects
When Not to Use It: Complexity Cliffs and Safer Alternatives

Compensating Actions and Sagas in Streaming
Irreversible Side Effects: Why "Undo" Is a Product Decision
Eventual Correctness: Compensation Patterns and Reconciliation
Designing for Human Repair: Auditability and Replayable History

Testing and Validating Guarantees
Failure Injection: Restarts, Partitions, Slowdowns, and Chaos-Style Tests
Synthetic Load Tests: Burst, Steady-State, and Pathological Keys
Proving It in Practice: Observing Semantics Through Metrics and Logs

Observability for Streaming Pipelines
Core Metrics: Throughput, Lag, End-to-End Latency, Watermark Progression
Logs and Structured Operator Events: Making Failures Diagnosable
Tracing Across Pipelines: Linking Ingest -> Process -> Serve in One Story

Backpressure and Flow Control
What Backpressure Means: When Sinks or Operators Cannot Keep Up
Buffers and Bounded Queues: Where Latency Hides and Outages Begin
Shedding and Degradation: Dropping, Sampling, and Protective Limits

Scaling and Resource Management
Scaling via Partitions and Parallelism: Changing the Shape of Work
Resource Bottlenecks: CPU vs Memory vs Network vs Disk in Practice
Autoscaling and Elasticity: What Can Scale Automatically (and What Cannot)

Hotspots and Skew
Key Skew: The Enemy of Parallelism
Mitigation Patterns: Salting, Repartitioning, Load-Aware Routing
Detecting Skew: Signals in Lag, Latency, and Per-Partition Metrics

SLOs and Capacity Planning
Streaming SLOs: Freshness, Latency, Availability, and Correctness Posture
Capacity Models: Headroom, Peaks, and Failure Scenarios
Planning for Growth: New Producers, New Consumers, and Retention Expansions

Operational Playbooks and Runbooks
Incident Types: Lag Spikes, Stuck Partitions, Failing Jobs, Corrupt State
Triage and Mitigation: Pause, Drain, Reroute, Replay, Roll Back
Postmortems and Continuous Improvement: Turning Incidents into Safer Defaults

End-to-End Architecture Patterns
Layered Architecture: Ingestion -> Transport -> Processing -> Serving
Unified vs Split Architectures: Speed/Batch Layering and Convergence Patterns
Serving Patterns: Materialized Views, OLAP-ish Stores, and Operational Stores

Real-Time Analytics and Monitoring
Observability Pipelines as Streaming: Metrics and Logs as First-Class Streams
Dashboards and Near-Real-Time Queries: Freshness Guarantees and Cost
Integration Boundaries: Streaming -> Time-Series Stores and Query Engines

Personalization, Recommendations, and Fraud Detection
Event-Driven Feature Pipelines: Turning Behavior into Features in Motion
Real-Time Scoring (Conceptual): Model Calls as Sinks with Strict Budgets
Feedback Loops: Online Learning Risks and Governance Boundaries

IoT and Edge Streaming
Device Streams: Intermittent Networks and Store-and-Forward Realities
Gateways and Aggregation: Edge Filtering and Upstream Compression
Buffering and Reconciliation: Correctness Across Connectivity Gaps

Multi-Region and Hybrid Architectures
Regional Clusters and Locality: Latency and Sovereignty Constraints
Cross-Region Replication: Durability vs Cost vs Consistency Trade-offs
Hybrid Patterns: On-Prem Sources, Cloud Processing, Shared Topics

Governance, Schemas, and Evolution
Schema Governance: Registries, Reviews, and Compatibility Policies
Ownership and Naming: Topic Conventions and Domain Boundaries
Migration Patterns: Resharding, Topic Evolution, and Safe Rewrites

Platformizing Streaming
Streaming as an Internal Platform: Self-Service Ingestion and Guardrails
Templates and Golden Paths: Standard Jobs, Standard Connectors, Standard SLOs
Developer Experience: Testing, Local Runs, Staging, and Safe Deployment Workflows

Reference Architectures and Case-Style Patterns
Observability Pipeline: From Telemetry to Alerts and Dashboards
Clickstream Analytics and Experimentation Feeds: Joins, Windows, and Backfills
Payments/Fraud Streams and IoT Telemetry: Exactly-Once Posture vs Best-Effort Posture

/signals-to-streams/signals-to-streams

Producer-Broker-Consumer Flows: Queues and Logs as System Topologies

Sign in to access this lesson.

Sign in Create account