Summary:
- How to evaluate throughput requirements and map them to Kinesis shards versus Kafka partitions for predictable capacity planning
- Why operational overhead differs dramatically between fully managed Kinesis and self-hosted or MSK-managed Kafka deployments
- When to choose MSK Serverless over Kinesis Data Streams based on ecosystem requirements, retention needs, and consumer patterns
- What changed in 2025: Kinesis On-demand Advantage mode now offers 60% lower data ingest pricing and supports up to 50 enhanced fan-out consumers
Choosing between AWS Kinesis and Apache Kafka determines how your organization handles real-time data at scale for the next several years. Both platforms process millions of events per second, yet they impose fundamentally different operational burdens, cost structures, and architectural constraints. The decision affects not just your streaming pipeline but your team’s capacity to iterate on features versus manage infrastructure. This guide breaks down the architectural differences, quantifies performance trade-offs, and provides concrete decision criteria so you can commit to the right platform without second-guessing.
Comparing AWS Kinesis and Apache Kafka
AWS Kinesis Data Streams is a fully managed service for collecting, processing, and analyzing real-time streaming data at any scale. It eliminates the operational burden of provisioning servers, managing storage, or handling replication. You define shards as your unit of capacity, and AWS handles availability across multiple Availability Zones automatically. Kinesis integrates natively with Lambda, Firehose, and Amazon Managed Service for Apache Flink, making it the default choice for teams already invested in the AWS ecosystem.
Apache Kafka is an open-source distributed event streaming platform originally developed at LinkedIn. It uses a publish-subscribe model where producers write to topics partitioned across brokers, and consumers read from those partitions in order. Kafka’s strength lies in its ecosystem, including Kafka Connect for integrations, Kafka Streams for stateful processing, and ksqlDB for SQL-based stream processing. You can run Kafka self-hosted on EC2, use Amazon MSK for a managed experience, or opt for MSK Serverless to eliminate broker management entirely.
The core trade-off is control versus convenience. Kafka gives you fine-grained control over retention, replication factors, and consumer group behavior at the cost of operational complexity. Kinesis abstracts these details, charging you per shard-hour and data volume while limiting configuration options. Understanding this tension is essential before evaluating specific features like throughput limits, retention policies, or ecosystem tooling.
Architecture and data model
Kinesis organizes data into streams composed of shards. Each shard provides 1 MB/s write throughput and 2 MB/s read throughput, supporting up to 1,000 records per second for writes. When you need more capacity, you add shards. On-demand mode automatically scales shards based on traffic, reaching up to 10 GB/s write and 20 GB/s read throughput in US East, US West, and Europe regions. Other regions scale to 200 MB/s write and 400 MB/s read by default, with higher limits available via support ticket.
Kafka organizes data into topics divided into partitions distributed across brokers. Each partition is an ordered, immutable sequence of records. Unlike Kinesis shards, Kafka partitions have no fixed throughput limit at the protocol level. Throughput depends on broker instance size, disk I/O, and network bandwidth. MSK Express brokers on express.m7g.16xlarge instances support up to 500 MB/s sustained ingress and 1,000 MB/s egress per broker. Partition-level throughput caps at 15 MB/s for Express brokers.
Replication and durability
Kinesis replicates data synchronously across three Availability Zones within a region. You cannot configure the replication factor. This simplicity means you never lose data due to misconfigured replication, but you also cannot trade durability for lower latency in specific use cases.
Kafka lets you configure replication factor per topic, typically set to 3 for production workloads. The min.insync.replicas setting controls how many replicas must acknowledge a write before it succeeds. This flexibility enables tuning for latency-sensitive workloads where you accept slightly higher risk, or for compliance scenarios requiring stronger guarantees. MSK manages broker replacement and rack awareness automatically, but you own the replication configuration decisions.
Metadata management with ZooKeeper versus KRaft
Kafka historically relied on Apache ZooKeeper for cluster metadata, leader election, and configuration management. Starting with Kafka 3.9, Amazon MSK supports KRaft mode, which moves metadata management into Kafka controllers themselves. KRaft eliminates the ZooKeeper dependency, simplifying operations and enabling faster metadata propagation. MSK Express brokers on Kafka 3.9 use KRaft by default. KRaft-based clusters support up to 60 brokers per cluster compared to 30 for ZooKeeper-based clusters.
Kinesis has no equivalent concept. AWS manages all metadata internally, and you interact only with stream and shard abstractions. This difference matters when evaluating operational complexity. Kafka teams must understand controller quorums and metadata replication, while Kinesis teams focus purely on application logic.
Performance and latency
Latency in streaming systems has two components: producer acknowledgment time and consumer propagation delay. Kinesis shared-throughput consumers using GetRecords experience average propagation delays around 200 ms with a single consumer, increasing to 1,000 ms with five consumers sharing the same shard. Enhanced fan-out consumers receive dedicated 2 MB/s throughput per shard via HTTP/2 push, achieving average propagation delays of 70 ms regardless of consumer count.
Kafka’s latency depends heavily on configuration. With acks=1 (leader acknowledgment only), producer latency typically falls under 10 ms. With acks=all and three replicas, expect 20-50 ms depending on network conditions. Consumer latency depends on poll intervals and fetch sizes. Well-tuned Kafka deployments routinely achieve end-to-end latencies under 100 ms for the 99th percentile.
| Metric | Kinesis (shared throughput) | Kinesis (enhanced fan-out) | Kafka (MSK Express) |
|---|---|---|---|
| Producer acknowledgment | ~50-100 ms | ~50-100 ms | 10-50 ms (varies by acks setting) |
| Consumer propagation delay | 200-1000 ms | ~70 ms | 10-100 ms (varies by poll interval) |
| Throughput per unit | 1 MB/s write, 2 MB/s read per shard | 1 MB/s write, 2 MB/s read per consumer per shard | Up to 15 MB/s per partition |
Data retention and replay
Kinesis default retention is 24 hours, extendable up to 365 days (8,760 hours). Extended retention incurs additional charges. With On-demand Advantage mode, extended retention pricing dropped 77% to $0.023/GB-month from the previous $0.10/GB-month. You can replay data from any point within the retention window using shard iterators with AT_TIMESTAMP positioning.
Kafka retention is configured per topic with no hard upper limit. MSK Serverless supports unlimited retention duration. Standard and Express brokers store data on EBS or tiered storage. Tiered storage, available on MSK clusters running Kafka 3.6.0 or higher, automatically moves older data to low-cost S3-backed storage while maintaining read access through standard Kafka APIs. This enables cost-effective retention of months or years of data without provisioning additional broker storage.
- Kinesis retention: 24 hours default, up to 365 days maximum, charged per GB-month for extended retention
- MSK Standard: Configurable per topic, limited by EBS storage (up to 16 TB per broker)
- MSK Serverless: Unlimited retention duration, charged per GB stored
- MSK Tiered storage: Virtually unlimited, automatic tiering to low-cost storage
Pricing model and cost at scale
Kinesis pricing has three components: shard hours (provisioned mode), data ingestion, and data retrieval. On-demand Advantage mode, launched in November 2025, charges $0.032/GB for data ingest and $0.016/GB for data retrieval in US East (N. Virginia), representing a 60% reduction from On-demand Standard rates. Enhanced fan-out retrieval costs match shared-throughput retrieval under On-demand Advantage. The mode requires minimum usage of 25 MB/s ingestion and 25 MB/s retrieval across all on-demand streams in a region.
MSK pricing depends on broker type. Standard brokers charge per broker-hour based on instance size, plus EBS storage costs. Express brokers charge for cluster hours, storage, and data transfer. MSK Serverless charges for cluster hours, partition hours, and data retention. There are no upfront costs for any MSK option.
| Workload profile | Kinesis On-demand Advantage (monthly) | MSK Express (monthly) | MSK Serverless (monthly) |
|---|---|---|---|
| Small (10 MB/s ingress) | ~$830 (ingress) + retrieval | ~$1,200 (3x express.m7g.large) | ~$400-600 (varies by partitions) |
| Medium (100 MB/s ingress) | ~$8,300 (ingress) + retrieval | ~$3,600 (3x express.m7g.4xlarge) | ~$2,000-3,000 |
| Large (500 MB/s ingress) | ~$41,500 (ingress) + retrieval | ~$10,800 (3x express.m7g.16xlarge) | Exceeds Serverless limits (200 MB/s max) |
Ecosystem and tooling
Kinesis integrates tightly with AWS services. Lambda event source mappings process records with automatic checkpointing. Amazon Data Firehose delivers data to S3, Redshift, or OpenSearch without custom code. Amazon Managed Service for Apache Flink (formerly Kinesis Data Analytics) provides SQL and Java/Python APIs for stream processing. The Kinesis Producer Library (KPL) aggregates multiple user records into single Kinesis records, increasing throughput by reducing per-record overhead.
Kafka’s ecosystem is broader but requires more integration work. Key components include:
- Kafka Connect: Framework for streaming data between Kafka and external systems. MSK Connect manages connectors as a fully managed service with automatic scaling.
- Kafka Streams: Client library for building stateful stream processing applications. Supported on MSK Express and Serverless clusters.
- ksqlDB: SQL interface for stream processing (not managed by AWS and requires self-hosting or Confluent Cloud).
- Schema Registry: AWS Glue Schema Registry integrates with MSK for schema evolution and validation.
Security and operations
Both platforms support encryption at rest and in transit. Kinesis uses AWS KMS for server-side encryption with no configuration required beyond enabling it. MSK supports TLS encryption between clients and brokers, with options for mutual TLS (mTLS), SASL/SCRAM, or IAM authentication. MSK Serverless requires IAM authentication exclusively.
Operational differences are substantial. Kinesis requires no patching, no capacity planning for infrastructure, and no broker management. You monitor shard-level metrics in CloudWatch and respond to throttling by adding shards or switching to on-demand mode.
MSK Standard brokers require you to manage Kafka versions, plan storage capacity, and handle broker replacements during failures. MSK Express brokers eliminate maintenance windows and automate hardware updates, but you still own Kafka configuration tuning.
Use cases and migration paths
Choose Kinesis when your team prioritizes speed to production over configurability. Kinesis excels for AWS-native architectures where Lambda, Firehose, and Flink handle processing. It suits workloads with predictable throughput patterns or teams without dedicated streaming infrastructure expertise. The On-demand Advantage pricing makes it cost-effective for workloads ingesting 10-100 MB/s with multiple consumers using enhanced fan-out.
Choose Kafka (via MSK or self-hosted) when you need ecosystem compatibility, extended retention without premium pricing, or fine-grained control over consumer behavior. Kafka fits organizations with existing Kafka expertise, multi-cloud requirements, or workloads requiring Kafka Connect integrations. MSK Replicator enables cross-region replication with up to 1 GB/s throughput, supporting active-passive disaster recovery patterns.
Handling exactly-once semantics
Neither platform provides exactly-once delivery out of the box at the transport layer. Kinesis may deliver duplicate records due to producer retries or consumer restarts. Kafka supports idempotent producers and transactional writes, enabling exactly-once semantics within Kafka Streams applications. For cross-system exactly-once guarantees, both platforms require idempotent consumers that deduplicate based on record identifiers or sequence numbers.
Conclusion
The Kafka vs Kinesis decision hinges on three factors: operational capacity, ecosystem requirements, and cost structure at your specific scale. Kinesis delivers faster time-to-production with zero infrastructure management, making it ideal for teams building AWS-native applications without dedicated streaming expertise. The 2025 On-demand Advantage pricing eliminated the cost penalty that previously pushed high-throughput workloads toward Kafka.
MSK becomes the better choice when you need Kafka Connect integrations, retention beyond 365 days at reasonable cost, or compatibility with existing Kafka tooling. MSK Express brokers close the operational gap significantly, offering managed infrastructure with Kafka’s protocol compatibility. For workloads exceeding MSK Serverless limits (200 MB/s ingress), MSK Express or Standard brokers provide the headroom Kinesis cannot match without substantial shard counts.
Start with your throughput requirements and consumer patterns. Map them to the pricing tables above. Then evaluate whether your team can absorb Kafka’s configuration complexity or whether Kinesis’s constraints are acceptable trade-offs for operational simplicity. The right answer depends on your organization’s specific context.