Skip to content
Engineering deep-divesAll articles

Redpanda vs Kafka in 2026: KRaft, Cross-AZ & 3-Year TCO

Redpanda vs Apache Kafka 4.x and Confluent Cloud in 2026: Seastar C++ vs Kafka KRaft and KIP-848, the Redpanda license (BSL 1.1) vs Apache 2.0, AWS cross-AZ fees, a PostgreSQL transactional outbox, and 36-month TCO at 65 TB/mo.

Artem Zaitsev
Artem ZaitsevCTO · Idealogic
Author: Artem ZaitsevPublished: Updated: Reading time: 18 minHow we write →
On this page
Idealogic 2026 engineering comparison of Redpanda vs Apache Kafka 4.0 and Confluent Cloud covering Seastar C++, KRaft, AWS cross-AZ networking, PostgreSQL 17 outbox, and 36-month TCO

Redpanda vs Kafka is the first fork CTOs hit when event streaming outgrows webhook scripts, and it widens fast into Redpanda vs Confluent Cloud versus self-hosted Apache Kafka 4.x on Kubernetes. Benchmarks get the attention, but the bigger 2026 budget surprises are AWS cross-AZ transfer at $0.02 per GB and the Enterprise licenses around tiered storage and SAML SSO.

Redpanda is a Kafka-API-compatible streaming engine written in C++ on the Seastar framework, shipped as one binary under the Business Source License (BSL 1.1). Apache Kafka is the Apache 2.0 JVM original, and since 4.0 it runs only on KRaft, with no ZooKeeper. Your Kafka clients work with either, so the real kafka vs redpanda differences are internals, licensing, and what you end up paying AWS. Below roughly 5,000 events per second, many B2B SaaS teams need neither broker once a PostgreSQL transactional outbox is in place.

At Idealogic, our custom software development and SaaS development teams build event backbones for fintech, logistics and supply chain, and manufacturing clients, with software development consulting and product development alongside. Temporal vs Airflow covers sagas and Inngest vs Trigger.dev covers background queues. This piece covers the log broker: internals, a FORCE RLS outbox with an idempotent relay, and a 36-month TCO model at 25 MB/s.

The short version

  • Kafka 4.x runs on KRaft, with no ZooKeeper. Apache Kafka 4.0 made KRaft mandatory and KIP-848 GA; Kafka 3.9 made KIP-405 tiered storage production-ready (S3 via a third-party plugin). Strimzi runs it on Kubernetes.
  • Redpanda trades the JVM for C++ Seastar and skips GC pauses. The catch: Redpanda Community (BSL 1.1) leaves out Tiered Storage, Data Balancing, Read Replicas, and SSO, so long retention pushes you toward an Enterprise license or Redpanda Cloud.
  • Cross-AZ transfer is the line item people miss. An unoptimized Kafka on EKS with 30 days of local EBS lands at $624,000 over three years, far above Confluent Cloud Dedicated at $360,600, unless you turn on KIP-392 follower fetching and tiered storage or move to S3-native brokers such as WarpStream and AutoMQ.
  • Redpanda vs Confluent vs owned Kafka at 25 MB/s, over 36 months: owned Kafka 4.x with KIP-392, S3 tiering, and a PostgreSQL outbox ($183,600 at CEE rates) beats Redpanda BYOC ($250,200) by $66.6k and Confluent Dedicated ($360,600) by $177.0k in our model.

Redpanda vs Kafka in 2026: broker internals, licensing and S3-native alternatives

Kafka 4.x, Redpanda, and the S3-native brokers split on three things: the I/O engine, the license, and how traffic crosses AZs. That's how two teams streaming 65 TB a month end up with three-year bills $177,000 apart.

Four architectural and commercial fault lines separating Redpanda, Apache Kafka 4.x, Confluent Cloud, and S3-native brokers in 2026

1. Kafka KRaft, KIP-848 and Kafka tiered storage in Apache Kafka 4.x

  1. No ZooKeeper (KIP-500, KIP-833). Kafka 4.0 removed ZooKeeper. Metadata lives in an internal Raft log on controller nodes (three c8g.large in our model), which fail over quickly.
  2. KIP-848 consumer groups. GA in 4.0, it moves assignment to the group coordinator, so deploys stop stalling the whole group for seconds to tens of seconds. Opt in with group.protocol=consumer; it shortens pauses rather than removing all of them.
  3. Kafka tiered storage plus Strimzi. KIP-405 is production-ready since 3.9, but Kafka ships only the RemoteStorageManager interface. A plugin such as Aiven's tiered storage for Apache Kafka moves segments past a roughly 12-hour hot window to Amazon S3, while CNCF Incubating Strimzi handles KafkaNodePool CRDs, Cruise Control, and mTLS.

2. Redpanda (BSL 1.1 + Enterprise): C++ Seastar speed and the Redpanda license wall

  1. Thread-per-core C++. Redpanda pins one Seastar shard per vCPU, uses direct (DMA) I/O, and runs Raft per partition. In Redpanda's own 2023 benchmark, p99.9 latency came out roughly 4x or more lower than Kafka on the tested workloads. It's vendor-run, so reproduce it on your hardware.
  2. One redpanda binary embeds Schema Registry and HTTP Proxy, with no JVM sidecar. Redpanda Connect (300+ connectors) is a separate component you run through rpk connect or its own binary.
  3. BSL 1.1 vs Enterprise. Community Edition is under the BSL 1.1, and each version converts to Apache 2.0 four years after release. In practice the Redpanda license only bites if you sell Redpanda as a managed service; internal self-hosting is fine. The feature split hurts more: Tiered Storage, Continuous Data Balancing, Remote Read Replicas, Audit Logs, and SAML/OIDC with RBAC are Enterprise. Keeping 30 days (about 195 TB at 3x) without it means big local disks, Enterprise, or Redpanda Cloud (Serverless, Dedicated, BYOC). On Redpanda pricing, our BYOC figure below is an assumption, not a quote.

3. Redpanda vs Confluent, AWS cross-AZ costs and Kafka alternatives (WarpStream, AutoMQ)

  • AWS cross-AZ transfer. Per AWS EC2 On-Demand pricing, traffic between AZs costs $0.01/GB out plus $0.01/GB in, so $0.02/GB. At 65,000 GB/mo ingress, RF=3, and two consumer groups, leader-only routing moves 43.3 TB producer, 130 TB replica, and 86.7 TB consumer traffic across zones: 260,000 GB x $0.02 = $5,200/mo. The replica share is unavoidable. Confluent Cloud Dedicated bills CKU hours plus per-GB network and PrivateLink rates, so in Redpanda vs Confluent the network line matters as much as the base fee.
  • KIP-392 and compression. Follower fetching needs client.rack, broker.rack, and replica.selector.class=org.apache.kafka.common.replica.RackAwareReplicaSelector, and it only removes the consumer share. Our model gets self-hosted cross-AZ fees from $5,200 to $1,450 a month (about 72%) only by also assuming zstd at roughly 2.4x. Compression helps every option, so that 72% isn't a pure KIP-392 effect.
  • Kafka alternatives built on S3. WarpStream (stateless agents that write straight to object storage, acquired by Confluent in 2024) and AutoMQ skip inter-broker replication traffic by writing to S3 through a free Gateway VPC Endpoint. You still pay S3 request charges, and latency goes up: WarpStream documents p99 produce under 150 ms and end-to-end under 400 ms with S3 Express, and AutoMQ's default S3 WAL sits around 500 ms. Fine for telemetry like in our IoT app development cost guide.
  • The 5,000 msg/sec rule of thumb. Below about 5,000 msgs/sec (under 2 MB/s, assuming ~400-byte messages), you can often skip brokers. A PostgreSQL outbox, or PostgreSQL logical replication (pgoutput) with Debezium, streams events straight from Postgres. Still picking a Postgres host? Neon vs Supabase compares two common options.
Architectural dimensionApache Kafka 4.x (Apache 2.0)Redpanda (BSL 1.1 / BYOC Ent.)Confluent Cloud DedicatedWarpStream / AutoMQ (S3)
Runtime & consensusJava 17+ JVM brokers + native KRaftC++ Seastar (thread-per-core, Raft)Managed Kafka (eCKU / CKU)Stateless agents -> multi-AZ S3
Core licenseApache 2.0 (OSI open source)BSL 1.1 core + proprietary EnterpriseProprietary SaaSWarpStream proprietary BYOC; AutoMQ check its LICENSE
S3 tiered storageKIP-405, via a third-party RSM pluginPaid Enterprise / Cloud onlyIncluded (billed per GB-mo)S3-native (no local log disk)
Latency (illustrative)Higher p99.9 under load in vendor testsLower p99.9 in Redpanda's own tests (vendor-run)Kafka-like, plus a PrivateLink hopp99 produce under 150 ms, end-to-end under 400 ms (WarpStream, S3 Express)
Schema RegistrySidecar (Apicurio / Karapace)Embedded in redpanda binaryManaged Stream GovernanceExternal or Confluent SR
Cross-AZ mitigationKIP-392 follower fetch + zstdRack awareness + BYOC tieringPer-GB Cloud throughput ratesNo inter-broker cross-AZ (S3 replicates)

Transactional outbox pattern for Kafka and Redpanda: PostgreSQL outbox and idempotent relay

Swapping Kafka for Redpanda won't fix the Dual-Write Bug. In event-driven architecture, data pipelines, and payment gateway integration stacks, committing to Postgres and calling producer.send() separately drops events on crashes and emits phantoms on rollbacks.

The transactional outbox pattern fixes that, and it works the same whichever broker sits behind it. Our version uses PostgreSQL range partitions, Row-Level Security (RLS) so one tenant can't read another's events, FOR UPDATE SKIP LOCKED for claiming batches, and @confluentinc/kafka-javascript as the producer. We target PostgreSQL 17, though nothing in the design needs 17. These are the decisions that matter:

Design decisionWhere it livesWhy it matters
Business row and outbox row commit in one transactionDatabaseA crash can't leave a change without its event, and a rollback can't leave an event without its change
FORCE RLS with restrictive tenant policies on the outbox and inbox tablesDatabaseTenant isolation fails closed for the app role, and the relay role can only touch status columns (see multi-tenant SaaS and multi-tenant SaaS architecture)
Monthly range partitions on the outboxDatabaseA cron job drops old partitions in milliseconds instead of fighting VACUUM bloat
Relay claims batches with a 60-second lease and SKIP LOCKED, oldest first per aggregateRelaySeveral relay pods can run without double-claiming, and events for one aggregate never overtake each other
Idempotent producer with acks=-1, zstd, and a tenant plus aggregate message keyBroker clientProducer retries don't create broker duplicates, and per-aggregate order holds within a partition
After 10 failed attempts a row moves to a dead-letter statusRelayOne poisoned event can't stall the whole queue
Consumers record each event ID in an inbox table inside their own transactionConsumerRe-sent batches become effectively-once side effects

The broker-specific part is the relay's producer, and it is the same for Kafka 4.x and Redpanda because both speak the Kafka protocol. It runs with idempotence on, acks set to all replicas (-1), zstd compression, and a short 10 ms linger. Rows are grouped by topic and sent as one batch, with the event ID carried in a header and the tenant plus aggregate ID as the message key.

With idempotence on and acks=-1, producer retries don't leave duplicates on the broker. The relay can still crash after sending a batch and before marking its rows published. When that happens the rows go out again, and the consumer inbox table absorbs the repeats. One caveat: client.rack only changes where consumers fetch from, so KIP-392 does nothing for the relay producer.

Paying $5,000+ a month in AWS cross-AZ Kafka transfer or Confluent CKU overages?
Share your MB/s ingress, consumer fan-out ratio, retention window, and compliance perimeter. Our architects will benchmark Redpanda BYOC, Confluent Cloud, and right-sized Kafka 4.x.
Audit your streaming TCO

Redpanda vs Kafka vs Confluent Cloud: 36-month TCO at 25 MB/s

Owned Kafka 4.x wins this model: $66.6k under Redpanda BYOC and $177.0k under Confluent Cloud over 36 months. The workload: a regulated B2B backbone with 25 MB/s sustained ingress (75 MB/s peak, 65 TB/mo written), 2x consumer fan-out (130 TB/mo read), 3-AZ HA (RF=3), 30-day retention, and SOC 2 Type II, PCI DSS v4.0.1, and SAML SSO.

Assumptions: 2026-11-14 list prices, us-east-1, zstd at about 2.4x, RF=3, 30-day retention. Confluent and Redpanda figures are modeled at assumed prices, not quotes; check Confluent's pricing calculator and ask Redpanda.

Labor: Idealogic's $75/hr senior CEE rate vs an assumed $165/hr US agency rate (2.2x). For context, the 2025 EU whole-economy hourly labour cost (lc_lci_lev) was EUR 34.9 for the EU and EUR 38.6 for the euro area (EA20), and US software developer wages (15-1252) are in BLS OEWS and O*NET:

  1. Option A: Confluent Cloud Dedicated (2 CKU, 3-AZ, PrivateLink, 65 TB write / 130 TB read, 65 TB storage):
    • Setup: 80h at $75/hr CEE = $6,000 ($13,200 at $165/hr US). Terraform, PrivateLink, Schema Registry, SAML SSO, outbox.
    • 36 months of cloud: $9,400/mo x 36 = $338,400. 2 CKU plus governance ($3,100/mo), network and PrivateLink over 195 TB/mo ($4,950/mo), 65 TB storage ($1,350/mo). Plus 6h/mo ops (216h: $16,200 CEE / $35,640 US) = $360,600 ($387,240 US).
  2. Option B: Redpanda Cloud BYOC Enterprise (3-AZ Tiered Storage, SAML SSO, customer VPC):
    • Setup: 120h at $75/hr = $9,000 ($19,800 US). BYOC IAM, PrivateLink, rpk CI, SAML GBAC, relay.
    • 36 months of BYOC plus AWS: $6,100/mo x 36 = $219,600: BYOC Enterprise ($3,250/mo) plus 3x i4i.2xlarge, S3 tiering, and cross-AZ ($2,850/mo). Plus 8h/mo ops (288h: $21,600 CEE / $47,520 US) = $250,200 ($286,920 US).
  3. Option C: unoptimized baseline, self-hosted Kafka 4.x on EKS (no KIP-392, no compression, no tiering, full st1 EBS retention):
    • Setup: 280h at $75/hr = $21,000 ($46,200 US). EKS nodes, Helm charts, 195 TB st1 EBS, alerts.
    • 36 months of AWS: $15,400/mo x 36 = $554,400. Broker and KRaft compute ($1,425/mo), 195 TB of st1 EBS ($8,775/mo at the us-east-1 list price of $0.045/GB-mo, or $15,600/mo on gp3), and 260 TB/mo of unoptimized cross-AZ transfer ($5,200/mo). Plus 18h/mo SRE (648h: $48,600 CEE / $106,920 US) = $624,000 ($707,520 US). It's here to show what defaults cost.
  4. Option D: owned, right-sized Kafka 4.x (KRaft, Strimzi, KIP-392, KIP-405 to S3, PostgreSQL FORCE RLS outbox):
    • Turnkey build: 600h at $75/hr = $45,000 ($99,000 US). Strimzi KafkaNodePool with KRaft and Cruise Control, KIP-848, KIP-392, zstd and KIP-405 S3 tiering, Apicurio, outbox/inbox SDK.
    • 36 months of right-sized AWS: $3,100/mo x 36 = $111,600. 3x i4i.xlarge brokers with a ~12-hour zstd hot window (24 hours won't fit 2.8 TB of NVMe) plus 3x c8g.large controllers ($980/mo modeled; on-demand list is nearer $930, so it's rough), S3 tiering via a free Gateway VPC Endpoint ($670/mo), and cross-AZ cut to $1,450/mo from $5,200. Plus 10h/mo SRE (360h: $27,000 CEE / $59,400 US) = $183,600 ($270,000 US).

Options A and B model a minimal 80h/120h integration; a full greenfield setup falls in the 180 to 280h tier priced below.

Worked 36-month streaming TCO ($k) at 25 MB/s ingress (65 TB/mo write, 130 TB/mo read, 3-AZ HA, 30d retention): Owned Kafka 4.x + KIP-392 + S3 saves $66.6k vs Redpanda BYOC and $177.0k vs Confluent Cloud
36-month line item (65 TB/mo in, 130 TB/mo out)Option A: Confluent Ded.Option B: Redpanda BYOCOption C: Unoptimized Kafka EKSOption D: Owned Kafka 4.xEconomic driver
1. Setup / build (at $75/hr CEE)$6,000 (80h; $13.2k US)$9,000 (120h; $19.8k US)$21,000 (280h; $46.2k US)$45,000 (600h; $99.0k US)Turnkey Strimzi + Outbox
2. 36-mo Cloud / AWS + Network$338,400 ($9,400/mo)$219,600 ($6,100/mo)$554,400 ($15,400/mo)$111,600 ($3,100/mo)KIP-392 + zstd + S3
3. 36-mo SRE ops (at $75/hr)$16,200 (6h/mo; 216h)$21,600 (8h/mo; 288h)$48,600 (18h/mo; 648h)$27,000 (10h/mo; 360h)KRaft + Cruise Control
Total 36-Month TCO (CEE)$360,600$250,200$624,000$183,600 (CapEx incl.)Saves $66.6k to $177.0k vs managed
Total 36-Month TCO (US $165/hr)$387,240$286,920$707,520$270,000 (CapEx incl.)Wins at US rates too
Year-2+ Annual Run-Rate (CEE)$118,200/yr$80,400/yr$201,000/yr$46,200/yrSaves $34.2k to $154.8k/yr
License & Lock-InProprietary CKU SaaSBSL 1.1 + EE TieringApache 2.0 (st1 + cross-AZ)Apache 2.0, low vendor lock-inPortable core; plugins can still lock in

Sensitivity check: the 5,000 msg/sec PostgreSQL cutoff and payback math

  • Under 5,000 msgs/sec (under 2 MB/s): run the PostgreSQL outbox into workers (~$120/mo modeled, $9,000 setup) until replay passes about 5 MB/s.
  • At 2 to 10 MB/s with strict tail-latency needs, Redpanda Serverless or BYOC is worth its licensing.
  • Payback at 25 MB/s and up. At $75/hr CEE, Option D's monthly OpEx is $3,850 ($3,100 AWS + $750 SRE). Its extra CapEx pays back in 6.50 months against Confluent Cloud ($39,000 / $6,000/mo saved), 12.63 months against Redpanda BYOC ($36,000 / $2,850/mo saved), and 1.86 months against the unoptimized baseline ($24,000 / $12,900/mo saved).

Weighing managed vs owned more broadly? See build vs buy software and cloud migration cost.

2026 event streaming & outbox engineering costs (senior CEE vs US)

Our custom software development, SaaS development, and software development consulting teams deliver fixed-milestone builds at a $75/hr senior CEE rate versus an assumed $165/hr US agency rate (2.2x):

Engagement tierTimelineHoursSenior CEE ($75/hr)US Agency ($165/hr)Deliverables
PostgreSQL Outbox Sprint2 to 3 wks120 to 180h$9,000 to $13,500$19,800 to $29,700Partitioned FORCE RLS outbox, SKIP LOCKED relay & dedup
Redpanda / Confluent Setup3 to 5 wks180 to 280h$13,500 to $21,000$29,700 to $46,200BYOC/Dedicated Terraform, PrivateLink, Schema Registry & SSO
Owned Kafka 4.x Platform (600h)8 to 11 wks520 to 720h$39,000 to $54,000 ($45k)$85,800 to $118,800 ($99k)KRaft + Strimzi, KIP-392, KIP-405 S3 tiering & PostgreSQL outbox
Multi-Region Streaming Mesh12 to 16 wks840 to 1,160h$63,000 to $87,000$138,600 to $191,400MirrorMaker 2 / Read Replicas, Flink/Debezium CDC & DR drills
Dedicated Streaming PodOngoing240h/mo (2)From $18,000/moFrom $39,600/moDistributed systems, Kafka/Redpanda & PostgreSQL engineers

Inside the worked 600-hour ($45,000 CEE vs $99,000 US) owned Kafka 4.x platform build

Worked model, assumptions in text: 600-hour ($45,000 at $75/hr CEE vs $99,000 at $165/hr US) owned Apache Kafka 4.x KRaft, Strimzi, KIP-392 follower fetching, S3 Tiered Storage & PG17 Outbox build
  • 1. KRaft & Strimzi GitOps (25% / 150h / $11,250 CEE vs $24,750 US): i4i and Graviton4 pools, KafkaNodePool CRDs, Cruise Control, mTLS rotation, OTel lag alerts.
  • 2. FORCE RLS outbox (25% / 150h / $11,250 CEE vs $24,750 US): partitioned domain_event_outbox, AS RESTRICTIVE guards, SKIP LOCKED relay, DLQ CLI.
    1. KIP-392 and KIP-405 S3 tier (20%, 120h, $9,000 CEE vs $19,800 US). AZ rack tags, S3 Gateway Endpoint routing, zstd tuning, and 12h/30d lifecycle rules.
  • 4. Schemas & dedup (20% / 120h / $9,000 CEE vs $19,800 US): Protobuf/Avro CI gates, KIP-848 group configs, and consumer_inbox_dedup SDKs.
    1. Chaos and cutover (10%, 60h, $4,500 CEE vs $9,900 US). Single-AZ kill drills, 75 MB/s burst QA, shadow dual-write checks, and runbooks.

Teams argue about JVM versus C++ microbenchmarks while paying AWS five thousand dollars a month in avoidable cross-AZ traffic. Kafka 4.x already has KRaft, KIP-848, and tiered storage. Pair it with Strimzi, KIP-392, and a PostgreSQL outbox and, in our model, three-year TCO drops by about half, with no BSL limits.

Artem Zaitsev · CTO at Idealogic

Shipped Idealogic proof and a 5-step Redpanda vs Kafka checklist

Choose Kafka 4.x if you sustain 15 MB/s or more and want Apache 2.0 with the lowest TCO. Choose Redpanda or Confluent Cloud when tail latency or zero-ops matters more than the bill. Work behind that view:

Five checks settle Redpanda vs Kafka vs Confluent Cloud in 2026:

  1. Under 5,000 events/sec (below 2 MB/s)? Skip brokers and deploy a PostgreSQL outbox (~$120/mo).
  2. Need the lowest tail latency and have an Enterprise budget? Pick Redpanda BYOC Enterprise, after benchmarking your traffic.
  3. Telemetry firehose (50 MB/s+) that tolerates a few hundred milliseconds? WarpStream or AutoMQ removes inter-broker cross-AZ replication.
  4. Zero-ops multi-cloud mandate with Flink SQL? Negotiate a committed Confluent Cloud contract and cap PrivateLink meters.
  5. Sustained 15 to 100+ MB/s, Apache 2.0, lowest TCO? Deploy Kafka 4.x (KRaft + Strimzi + KIP-392 + KIP-405 S3) with a PostgreSQL outbox. Here Redpanda vs Kafka tips toward Kafka. Contact our team for a 48-hour TCO audit.
Choosing between Redpanda, Confluent Cloud, Apache Kafka 4.x, or a PostgreSQL outbox?
Send your peak MB/s, retention days, consumer count, and AWS/GCP topology. Our senior CEE architects will return an itemized 36-month TCO model within 48 hours.
Request a 48-hour streaming TCO audit

Occasional field notes on building software, no spam

Protected by Cloudflare Turnstile · Privacy · Terms

Artem Zaitsev
Artem ZaitsevCTO · Idealogic Development OÜ

CTO and Co-founder at Idealogic. Directing engineering, systems architecture, security, and full-stack delivery across web, mobile, and blockchain.

Frequently asked questions

  • Pick Redpanda if you want one C++ binary with Schema Registry and HTTP Proxy built in, no JVM garbage collection to tune, and a managed BYOC option. Pick Apache Kafka 4.x if you need Apache 2.0 licensing end to end, KIP-405 Tiered Storage without an Enterprise contract (cloud backends come from plugins), Kubernetes GitOps through CNCF Strimzi, or the deepest Kafka Streams and Flink tooling. Redpanda's latency edge shows up in its own benchmarks, but those are vendor-run, so test on your workload.

  • No. Apache Kafka 4.0 (March 2025) removed ZooKeeper and runs only on KRaft, the Raft metadata quorum proposed in KIP-500 and declared production-ready in KIP-833. Kafka 4.0 also made the KIP-848 consumer rebalance protocol generally available, though clients have to opt in with group.protocol=consumer. Tiered Storage isn't new in 4.0: Kafka 3.9 declared KIP-405 production-ready and 4.x inherits it. Kafka ships only the RemoteStorageManager interface, so S3, GCS, or Azure Blob backends come from plugins.

  • Apache Kafka is Apache 2.0 throughout, including KRaft, KIP-848, and the KIP-405 Tiered Storage interfaces. The Redpanda license for Community Edition is the Business Source License 1.1: you can self-host it in production for internal use, but you can't offer it as a competing managed streaming service, and each version converts to Apache 2.0 four years after release. Tiered Storage, Continuous Data Balancing, Remote Read Replicas, and SAML SSO need a paid Enterprise license or Redpanda Cloud.

  • It's a major and often overlooked line item. AWS bills $0.01 per GB in each direction, so $0.02 per GB, whenever traffic crosses Availability Zones. In our 25 MB/s model (65 TB a month written, RF=3 across three AZs, two consumer groups), about 260 TB a month crosses zones, roughly $5,200 a month. Half of that, 130 TB, is replication you can't avoid with RF=3 in three AZs; the rest is producer and consumer traffic that rack-aware routing can shrink. In the same unoptimized model, local EBS storage costs even more.

  • KIP-392 lets consumers read from a replica in their own AZ instead of the leader. It needs client.rack on consumers, broker.rack on brokers, and replica.selector.class=org.apache.kafka.common.replica.RackAwareReplicaSelector on the brokers, and it only affects consumer fetches. WarpStream (now owned by Confluent) and AutoMQ write to S3 instead, which removes inter-broker replication traffic but raises latency: WarpStream documents p99 end-to-end latency under 400 ms with S3 Express.

  • There's no standard threshold, but many smaller B2B SaaS systems can start with a transactional outbox. Our rule of thumb: under about 5,000 messages per second (under 2 MB/s at roughly 400-byte messages), with no multi-terabyte replay or stateful Flink windows, a partitioned PostgreSQL outbox polled with FOR UPDATE SKIP LOCKED, or streamed through pgoutput logical replication, keeps ACID ordering on your existing database. We model the extra RDS cost at about $120 a month.

  • Don't commit a PostgreSQL transaction and call producer.send() as two separate steps. A pod crash or broker timeout between them drops events, and a rollback after a send emits phantom messages. Write the business change and a domain_event_outbox row in one transaction (with FORCE ROW LEVEL SECURITY for tenant isolation), relay batches with an idempotent acks=-1 producer, and deduplicate consumers with an inbox table.

  • At Idealogic's $75 per hour senior Central and Eastern European rate (versus an assumed $165 per hour US agency rate), a PostgreSQL transactional outbox sprint costs $9,000 to $13,500 and a Redpanda BYOC or Confluent Cloud production setup runs $13,500 to $21,000. A turnkey 600-hour owned Kafka 4.x platform with KRaft, Strimzi, KIP-392, and tiered storage to S3 costs $45,000, or $99,000 at US rates. Over 36 months our model puts it $66,600 below Redpanda BYOC, $177,000 below Confluent Cloud, and $440,400 below an unoptimized self-hosted baseline. Those vendor numbers are modeled at assumed list prices, not quotes.

Still unanswered
Ask us directly

A senior engineer replies under 4 hours.