The TCO of 1 Billion Rows: Arc vs InfluxDB 3

Every time-series deployment has a bill attached: servers to run it, a license to use it, and storage that grows every day. We took the same billion-row workload and priced that bill on Arc and on InfluxDB 3, end to end. Here is the number that matters.

The bottom line

For the same workload (10 million records/sec of ingest, 1 trillion rows stored), the fully-supported, licensed deployments cost:

• Arc Enterprise: ~$35,000/year
• InfluxDB 3 Enterprise: ~$235,000/year

That is ~$200,000/year saved, or 6.7x cheaper, for identical work. Over three years, about $600,000. The gap comes from three multiplying factors: Arc needs 6x fewer servers to ingest the same data, InfluxDB's compaction sits behind a metered per-core license, and Arc's data footprint is 1.75x to 2.15x smaller. The rest of this post shows the receipts.

We ran one billion rows of IoT sensor data into three engines, natively (no Docker, no container overhead), on the same 14-core / 36 GB machine: Arc, InfluxDB 3 Core, and InfluxDB 3 Enterprise. Only Enterprise has a real compactor, so it is the fair comparison for a production deployment; Core is included to show what you get without paying.

The Setup

Identical line-protocol IoT telemetry for every engine:

sensor_data,device_id=device-NNNNN,region=region-NN \
  temperature=<f>,humidity=<f>,pressure=<f>,battery=<f> <ns-timestamp>

• Measurement: sensor_data
• Tags: device_id (10,000 unique), region (10 unique)
• Fields: temperature, humidity, pressure, battery, all float64
• Timestamps: spread across a full year, 2020-01-01 to 2021-01-01
• Rows: 1,000,000,000
• Each engine at its own default Parquet codec. Arc uses snappy, InfluxDB uses zstd

That last point matters: we did not normalize the codec. Arc wins on size despite running the lighter-weight compressor.

The Results

Arc: smallest footprint, fewest files, fastest ingest. (Storage figures are from this billion-row run; peak ingest is from our dedicated ingestion benchmark, for the reasons below.)

Those three lines drive the whole cost model, so we go to the money first. If you want the engineering behind each number, it is in Where the gap comes from further down.

The Cost Math

Turn those measurements into what they cost to run. All assumptions are stated and deliberately conservative; treat the dollar figures as illustrative, not quotes. We price a 16-vCPU on-demand instance (m6i.4xlarge class) at $0.768/hour and block storage (EBS gp3) at $0.08/GB-month, over a 730-hour month. Ingest rates come from our peak ingestion benchmark (Arc 17.3M rec/s, Core 3.45M, Enterprise 1.71M), not this storage run's throttled numbers.

We price a realistic pipeline: sustain 10 million records/sec of ingest (a large observability or IoT fleet) and store 1 trillion rows. Nodes are sized from each engine's peak rate, at 16 vCPU per node. Storage at 1 trillion rows is derived from each engine's measured bytes/row, so the terabyte figures track the compacted footprint, not a flat 1000x of the billion-row run.

Nodes to do the job

At 17.3M rec/s, Arc handles 10M/s on one node. Core, at 3.45M/s, needs 3. Enterprise, at 1.71M/s, needs 6. That fan-out is where InfluxDB's cost comes from, and it compounds on the license.

The license is the real cost

Arc is AGPL open source with no license fee. InfluxDB 3 Enterprise is a paid, per-CPU-core license on top of your infrastructure. For the compaction a production deployment needs, you need Enterprise, and that license is where the money goes.

InfluxData does not publish a self-managed list price, but the AWS Marketplace listing does: the Enterprise software license is $0.198 per vCPU-hour in US regions, on top of the EC2 compute, and it is licensed per CPU core. At 6 nodes (96 vCPU), that is about $166,500/year in license alone, before a single dollar of infrastructure.

The full cost picture

The whole thing in one place, for a 10M rec/s pipeline storing 1 trillion rows.

Core is about 2x Arc's cost and can't even compact (its 52,703 files are permanent, see below). Enterprise, the only edition that compacts, is nearly 12x Arc's total cost, and the license alone is about $166,500/year. On storage, Arc uses 1.75x less than Core and 2.15x less than Enterprise: 10 to 15 TB saved per trillion rows. And because Arc writes plain Parquet, you point object storage straight at it with no proprietary-format tax.

Enterprise vs Enterprise, all in

The cleanest apples-to-apples: both engines with a paid, supported license, same workload. Because Arc did this on a single 16-core node, it fits Arc Enterprise's Professional tier ($15,000/year, up to 32 cores) with room to double before the next tier. InfluxDB needs 6 nodes and a metered license.

About $35,000/year versus $235,000/year: roughly $200,000 saved every year, $600,000 over three, for identical work. One Arc node does the ingest that takes InfluxDB six, so InfluxDB pays six times the compute, a metered license that runs hot, and more storage on top. Fewer cores, a flat license, and an open format you own outright.

---

Where the gap comes from

Everything above is driven by three engineering facts. Here they are, for the team that has to run this.

Ingestion: 5x to 10x Faster

For the ingest rates in the cost math above, we deliberately do not use this storage run's numbers. Forcing every row to persist immediately (see the note below) throttles both sides and isn't how you'd tune for throughput. Instead we use our dedicated peak ingestion benchmark, where each engine was tuned for its best sustained rate on the same 14-core / 36 GB machine, with large batches and multiple workers:

Arc is 5x faster than Core and 10x faster than Enterprise at their respective peaks. Enterprise is roughly half Core's speed even single-node, because its clustering coordination and distributed WAL add overhead on every write. Those are the rates the cost table uses.

A note on this storage run's persistence. To measure a fully-settled on-disk footprint, we had to make InfluxDB persist everything to Parquet, and that turned out to be its own adventure. InfluxDB 3 buffers writes in a WAL and only converts them to Parquet during a "snapshot," triggered by accumulating enough WAL files (--wal-snapshot-size, default 600). At the default, a finite bulk load leaves its tail stranded in the WAL: after 8 million rows there were still zero Parquet files on disk. And shutting the server down does not flush the WAL to Parquet, it just writes the WAL buffer and exits. The only setting that reliably persisted the whole dataset was --wal-snapshot-size 1. That is aggressive and slows ingest, which is exactly why we use the peak-tuned rates above for cost, not this run's throttled ones. Arc, by contrast, persists to Parquet continuously and needs no such tuning.

Storage: The 366-File Difference

Arc's headline storage number is 13.73 GB, or 14.74 bytes per row. But the file layout is the real story.

During this storage run (where every write persists immediately), Arc flushes each hourly partition many times, so right after ingest it had roughly 9,000 small Parquet files. Arc's compactor (hourly and daily tiers) then merged them: each day's fragments collapse into a single 38 MB _daily.parquet file. The end state is 366 files, exactly one per day of 2020, and total storage drops from 21.5 GB to 13.7 GB, a 36% reduction from compaction alone.

Core, meanwhile, has no multi-file compactor at all: no compact command, no compaction flags, just automatic gen1 arrangement that never consolidates across files. Its 52,703 tiny files (0.47 MB average) are permanent. That is the natural steady state of InfluxDB 3 Core.

The Enterprise Surprise

Multi-generation compaction is an InfluxDB 3 Enterprise feature, so we activated a trial and ran the same billion rows. Its compactor does run, continuously, thousands of cycles during ingest, and it does slash the file count: 52,703 down to 2,181 files.

But here is the twist: Enterprise's compacted output is ~29.5 GB, larger than Core's un-compacted 24 GB, and more than 2x Arc's 13.7 GB. Enterprise's compactor wins on file count, not on size. For this dataset, its compacted zstd layout used more bytes, not fewer.

A measurement footgun worth flagging. Enterprise keeps both the raw and the compacted copies of the data on disk, and only hard-deletes the superseded originals after a 24-hour grace period. Snapshot the directory right after ingest and you will measure raw plus compacted, about 54 GB, a transient double-count rather than the real footprint. The honest number is the compacted generation (~29.5 GB) that survives garbage collection. If you benchmark InfluxDB 3 Enterprise storage, don't report the number you see at t=0.

In one line

None of this is a trick of tuning; it is architecture. Arc persists to Parquet continuously and compacts into large files, so it needs no WAL babysitting and no second copy of your data during a GC window. Its compaction shrinks the footprint 36% into one file per day. InfluxDB Core can't compact at all; Enterprise compacts the file count but not the bytes, and charges a per-core license for the privilege. Same billion rows, same machine, same Parquet format underneath, and Arc runs it for a fraction of the cost on an open format you fully own.

Reproduce It

The benchmark is a native Go harness that builds Arc from source, downloads the InfluxDB 3 binaries, ingests the billion rows, drains each engine's compaction to completion, and measures the on-disk Parquet. Everything ran without Docker to keep container overhead out of the numbers. If you want to run your own storage comparison, with your own schema, cardinality, and codec choices, that is the honest way to do it.

Want to see the query side? That is the next benchmark: latency versus hardware utilization on the same billion rows. The 366-vs-52,703 file gap is a strong hint about where that one lands.

Talk to usPut these numbers against your own billBring your ingest rate, retention window, and current InfluxDB spend. We'll model your TCO on Arc, size the deployment, and walk through Arc Enterprise licensing. No pitch, just the math on your workload.Open the contact form basekick.netLearn more about Arc EnterpriseAutomatic compaction, tiered retention, query governance, and flat per-tier pricing. Production-ready today, with a 14-day trial and no credit card required.https://basekick.net/enterprise

---

A note on pricing. Infrastructure figures use public AWS on-demand rates ($0.768/node-hour for a 16-vCPU instance, $0.08/GB-month for EBS gp3) and are illustrative, not quotes; your negotiated cloud and reserved-instance rates will differ. The InfluxDB 3 Enterprise license rate ($0.198/vCPU-hour) is the published AWS Marketplace price; a self-managed contract negotiated directly with InfluxData may be priced differently. Arc Enterprise tier pricing is published and flat. We used each engine's measured performance to size the deployment, then applied these public rates; swap in your own and the ratio holds.