Kappa architecture
Kappa architecture handles all data processing through a single streaming pipeline that can be replayed from the beginning of the log when computations need to be reprocessed. Eliminates the dual-pipeline maintenance of lambda architecture at the cost of requiring streaming infrastructure capable of replay (Kafka with long retention, change-data-capture).
Jay Kreps introduced kappa in 2014 as the simplification of lambda. The model is uniformity: every computation is a stream processor over an immutable log; reprocessing happens by replaying the log into a new processor instance. The architecture matches the Kafka-as-source-of-truth pattern well. The trade-offs vs lambda: simpler conceptually (one pipeline, one set of code), more capable historically (streaming systems have matured), but more expensive in terms of log retention (must keep enough history for any replay you might need). Most modern data architectures sit closer to kappa than lambda; the lambda pattern survives mostly in legacy contexts.
Related terms
- Lambda architecture
Lambda architecture is the data-processing pattern that runs two parallel pipelines: a batch layer that computes complete views over all data with high latency, and a speed layer that computes incremental views over recent data with low latency.
- Event-driven architecture
Event-driven architecture is the design pattern where services communicate by emitting and consuming events rather than by direct synchronous calls.
- Event sourcing
Event sourcing is a persistence pattern that stores every state change as an immutable event in an append-only log.