Cheap DynamoDB Alternatives in 2026: Cloudflare KV, D1, Upstash, BaseKV

DynamoDB is the default key-value store on AWS. Serverless, fast, integrates with everything. After the November 2024 50% reduction in on-demand pricing, it is also cheaper than most people realise — $1.25 per million writes and $0.25 per million reads in 2026. So the real question is not "is DynamoDB expensive?" — it is "does my workload actually fit the on-demand pricing model, and what are the cheap alternatives when it doesn't?"

This guide walks the 2026 numbers, where DynamoDB still bites, and the four credible cheap alternatives.

DynamoDB On-Demand: 2026 Pricing Reality

After the Nov-2024 50% on-demand cut, the base unit prices look benign:

| Unit | Price | What it covers | |---|---|---| | Write Request Unit (WRU) | $1.25 / 1M | One write up to 1 KB | | Read Request Unit (RRU) | $0.25 / 1M (eventually consistent) | One read up to 4 KB | | Strongly consistent read | $0.50 / 1M | 2x the eventually-consistent rate | | Transactional read/write | 2x the base rate | ACID guarantees cost double |

AWS now recommends on-demand as the default — for most workloads it actually beats provisioned capacity.

So when does DynamoDB still get expensive?

1. The Scan trap. A Scan reads every item in the table. One bad line of code that runs Scan instead of Query can cost hundreds of dollars in a single afternoon. This is the failure mode that drives most "surprise DynamoDB bill" stories.
2. Item-size inflation. Pricing is metered per 1 KB write / 4 KB read. A 4 KB JSON document costs 4x the WRU of a 1 KB document. Nested attributes, base64 blobs, redundant metadata — they all multiply the bill.
3. GSI multiplication. Each Global Secondary Index re-writes its own copy of every item that matches its key. Two GSIs ⇒ 3x the write cost (base + 2 indexes). The GSI bill is often invisible until you trace it.
4. Hot partitions. If 90% of traffic hits 1% of partition keys, DynamoDB charges adaptive-capacity throughput against you anyway — and on-demand can throttle when the partition saturates.
5. DDOS scenarios. On-demand has no built-in spending cap. A DDOS or a runaway lambda can run up four-digit bills before billing alerts fire. This is the #1 concern raised by AWS startup founders on r/aws ("Worry about surprise bills" is a recurring thread title).

When to Look for a Cheap Alternative

You should consider an alternative when:

• Your data access is chatty. Many small reads/writes per user per minute. Per-request billing punishes chatty apps.
• You don't need infinite scale. Sub-10K req/s workloads are paying for architecture they will never use.
• You hate the API. { "S": "some string" }, attribute-update verbosity, the lack of native LIKE / aggregate queries — DynamoDB's API friction is real.
• You value portability. Moving away from DynamoDB is a rewrite. Moving away from a standard key-value store is a config change.
• You need predictable monthly cost. Per-request billing means a viral hit can 10x your bill overnight; flat-tier KV stores don't have that failure mode.

Four Credible Cheap Alternatives (2026)

1. Cloudflare Workers KV

The free tier is generous (100K reads/day, 1K writes/day). Beyond that, $0.50 per million reads and $5.00 per million writes — writes are 4x DynamoDB's price.

Sweet spot: Edge-cached, eventually-consistent configuration and feature-flag data. Read-heavy workloads in Workers.

Gotchas: Eventual consistency (writes propagate over up to 60 seconds globally), 25 MB value limit, no secondary indexes, no transactions. Workers KV is the wrong tool for anything that needs read-after-write.

2. Cloudflare D1 (SQLite at the edge)

Free tier covers 100K reads + 100K writes per day. Beyond that, $0.001 per 1K rows read and $1.00 per 1M rows written. SQLite semantics — real transactions, JOINs, indexes. Backed by Storage Relay Service in 2026 so reads are read-your-writes consistent within a region.

Sweet spot: Side-project SaaS, multi-tenant apps where each tenant database stays small (under 10 GB per DB).

Gotchas: 10 GB per database hard ceiling (in 2026), SQLite write concurrency limits, multi-region writes still require careful design.

3. Upstash (Redis / Vector)

Serverless Redis with per-request billing. Pricing: $0.20 per 100K requests on the pay-as-you-go tier, $0 for the free tier (10K requests/day, 256 MB).

Sweet spot: Session cache, rate limiting, queue work — anything that fits Redis data structures and benefits from serverless cold-start tolerance.

Gotchas: RAM-priced — cold data sitting in Redis pays full RAM cost. The "free tier" of 256 MB fills quickly with any persistent dataset. Connection limits matter on the pay-as-you-go tier.

4. Disk-Backed KV Stores (BaseKV, KeyDB on disk, RocksDB-as-a-service)

The category that fits the "cheap" requirement most cleanly. The economics: high-density NVMe SSD is roughly 10x to 50x cheaper per GB than RAM, so any dataset where the working set fits in RAM but the long tail does not benefits from disk-first storage.

Sweet spot:

• Game-server backends (player profiles, save data, sparse access).
• Side-project SaaS where cost predictability beats every other dimension.
• Discord bots, IoT telemetry, log indexes, anything chatty + cheap.
• Workloads that were on Redis but where 99% of the data is cold.

Gotchas:

• Per-request latency is 2–10x higher than pure-RAM Redis (still sub-ms on warm cache, sub-10ms cold).
• For genuine 100K+ req/s with sub-ms p99 requirements, in-memory Redis or DynamoDB DAX is still the right answer.

BaseKV sits in this category. The pricing is tiered flat-rate: you know your monthly bill before the month starts. The Redis protocol means existing ioredis / redis-py / redis-rs clients work out of the box. JSON/CSV exports are not paywalled.

Cost Comparison: 50M reads + 5M writes per month

A worked example, using 2026 list prices, for an app doing 50M reads and 5M writes per month with average 1 KB items:

| Provider | Cost | Notes | |---|---|---| | DynamoDB on-demand | $12.50 reads + $6.25 writes = ~$18.75 | Plus storage (~$0.25/GB), GSI multipliers, scan risk | | Cloudflare Workers KV | $25 reads + $25 writes = ~$50 | But $0 reads under 100K/day free tier | | Cloudflare D1 | $50 reads + $5 writes = ~$55 | Per-row pricing punishes high-read | | Upstash Redis | 55M requests × $0.20/100K = ~$110 | RAM cost included | | BaseKV (Hobby tier) | ~$15/month flat | All-inclusive |

At 50M / 5M monthly DynamoDB is already competitive on raw price. The case for the alternatives is in the failure modes DynamoDB doesn't cover: cost predictability (no scan surprise), simpler API, no GSI multiplication, no per-request anxiety.

Five Patterns Where the Cheap Alternative Wins

1. Side-project SaaS where cost certainty matters more than raw scale. Flat-tier wins.
2. Edge functions doing read-heavy lookups against small, eventually-consistent data. Cloudflare KV's edge cache beats DynamoDB's regional latency.
3. Discord bots, game-server backends, IoT telemetry — chatty, sparse-access, low absolute scale. Disk-backed KV wins on cost per byte.
4. Local-first apps with cloud sync. Cloudflare D1's SQLite semantics map naturally to local SQLite clients.
5. Cache/session/rate-limit layers where Redis is the natural fit — Upstash if you're serverless, BaseKV if you want a flat-tier serverful equivalent.

Five Patterns Where DynamoDB Still Wins in 2026

Worth being honest about: DynamoDB is the right answer when —

1. You need single-digit-ms p99 reads at 100K+ req/s. Add DAX for sub-ms.
2. You need DynamoDB Streams + Lambda triggers. The CDC ecosystem is uniquely well-integrated on AWS.
3. You need global tables (multi-region active-active). No-one else does this as cleanly.
4. You're already deep in AWS — Cognito, Lambda, API Gateway, AppSync. Cross-cloud egress and identity friction kill the alternatives' savings.
5. You need IAM-policy-level access control on the database. Cloudflare and Upstash don't have anything close to DynamoDB's IAM granularity.

Conclusion

The 2026 "cheap DynamoDB alternative" question is more nuanced than it was in 2024. DynamoDB itself got cheaper. The right alternative depends on which DynamoDB pain point hurts most:

• Hate the API? Any KV with the Redis protocol (BaseKV, Upstash) gives you ergonomics.
• Hate per-request billing anxiety? Disk-backed flat-tier (BaseKV) or D1's structured per-row model.
• Need edge reads? Workers KV or D1.
• Need session cache? Upstash for serverless, BaseKV for steady-state.
• Just want to get out of AWS? Pick the one that matches your runtime; portability is the underrated feature.

BaseKV is built specifically for the "cost predictability + Redis protocol + disk persistence" cell of this matrix. If that's where your workload lives, we're a one-config-change migration.

Related reading

• Key-value store vs Redis — what Redis actually is, when it's overkill
• DynamoDB on-demand pricing explained — the deeper pricing-model walkthrough
• Cloudflare Workers KV alternative — the eventual-consistency tradeoff explained
• KV storage for game-server backends — the chatty-game-state pattern