I need a database that is ACID compliant but does not require a schema.

You are looking for a NoSQL / document database that supports multi-document or single-document ACID transactions while remaining schemaless (or schema-flexible).

Historically, ACID meant relational (SQL), and schemaless meant eventual consistency (BASE), but modern databases bridge this gap nicely.

Top Choices for ACID-Compliant Schemaless Databases

• MongoDB:
  • The Schema Approach: Completely schemaless/schema-flexible at the collection level (documents can have entirely different fields).
  • ACID Compliance: Supports multi-document ACID transactions (introduced fully in version 4.0 and enhanced in later releases), allowing you to safely execute complex transactions across multiple documents and collections.
• CockroachDB:
  • The Schema Approach: While it is a distributed SQL database, you can store JSONB data types to achieve a schemaless document-store behavior while retaining absolute serializable ACID guarantees.
  • ACID Compliance: Strong, distributed ACID transactions out of the box.
• PostgreSQL:
  • The Schema Approach: Like CockroachDB, Postgres is relational, but its powerful JSONB data type combined with GIN indexing lets you use it as a robust, schemaless document database.
  • ACID Compliance: Gold standard for traditional, bulletproof ACID compliance.
• Fauna:
  • The Schema Approach: Document-relational database with flexible/flexible-schema data models.
  • ACID Compliance: Strictly ACID compliant with distributed multi-document transactions using a functional query language (FQL) or GraphQL.

To help narrow down the ideal choice, let me know:

• Do you need it to be self-hosted/open-source or a managed cloud service?
• What kind of query patterns or scale are you expecting?

Yes. The strongest match I’d recommend is FoundationDB.

Best fit: FoundationDB

FoundationDB is a distributed key-value database that gives you ACID transactions without requiring a database schema. Its core data model is simply:

key → value

The keys and values are opaque byte strings, so FoundationDB imposes no document/row schema on your data.

It provides:

• Full ACID transactions
• Strictly serializable isolation
• Transactions spanning multiple keys
• Distributed replication and fault tolerance
• No required schema
• Ordered key-value storage
• Automatic partitioning/rebalancing
• Open source

For example, you could store:

"user:123" → {"name":"Alice","age":32}
"user:456" → {"name":"Bob","email":"[email protected]","tags":["a","b"]}
"order:987" → {"user":123,"items":[...]}

Those values don't have to share a schema. You can serialize them as JSON, MessagePack, Protocol Buffers, or whatever your application wants.

And you can atomically modify unrelated keys:

transaction:
    decrement inventory:item42
    create order:987
    update user:123
    commit

Either all those changes happen or none do. FoundationDB explicitly supports ACID transactions across its key space.

If you want a document database

FoundationDB also has a Document Layer, which provides a MongoDB-compatible document API on top of FoundationDB. It gives you JSON-like documents while retaining FoundationDB's transactional guarantees.

So the choices are roughly:

If "ACID + genuinely schema-free" is the primary requirement, I'd investigate FoundationDB first. Its architecture was specifically designed to separate the transactional storage engine from the data model, so you aren't forced to adopt a predefined schema or query model.

If you tell me whether you need SQL queries, JSON documents, distributed/cloud deployment, or just an embedded/local database, I can narrow this down to the best 2–3 options.

Yes. What you’re looking for is generally called a schema-flexible / schema-less document database with ACID transactions.

My top choices:

• MongoDB — Probably the most straightforward choice. It stores flexible JSON-like documents, doesn't require a fixed schema, and supports ACID transactions across multiple documents, collections, databases, and shards.
• Couchbase — A particularly good fit if you want schema-less JSON + SQL-like querying + multi-document ACID transactions. Couchbase explicitly describes its server as enforcing no schema and supports distributed ACID transactions.
• FoundationDB — Very strong transactional foundation with full ACID guarantees, but it's lower-level. You'd typically put a data model/record layer on top rather than use it like MongoDB.

What I'd choose

If your requirement is:

"I want arbitrary JSON objects, no database-enforced schema, but I still need real ACID transactions." I'd start with MongoDB or Couchbase.

One important distinction: "schema-less" doesn't mean "no data model." Your application will inevitably have assumptions about fields and types; the difference is that the database doesn't force every document to conform to one predefined schema. Couchbase explicitly describes this as schema-on-read.

If you tell me what you're building (e.g. SaaS app, event store, inventory system, financial data, configuration store) and whether you need SQL queries, high write throughput, horizontal scaling, or relational joins, I can narrow this down to the best 2–3 options.

You are looking for a schema-flexible (schemaless) database that supports ACID transactions . While ACID traditionally belonged to rigid relational databases, several modern databases bridge this gap by offering document/JSON storage alongside robust transactional guarantees.

Top database options that fit these criteria include:

• MongoDB is a popular document database that stores data in flexible, JSON-like BSON documents rather than strict tabular rows and columns. It supports multi-document ACID transactions, meaning you can update multiple unconstrained or differently-structured documents atomically.
• PostgreSQL (with JSONB) is technically a relational database, but when you use its native JSONB data type, it behaves like a schemaless document store. You get the absolute gold standard in full ACID compliance, concurrency control, and relational integrity while maintaining the freedom to dump unstructured or evolving JSON payloads into a column.
• CockroachDB (with JSONB) is a distributed, highly scalable SQL database that also supports native JSONB fields. Like Postgres, it lets you operate in a schemaless manner inside the JSON columns while providing distributed, multi-active ACID guarantees across a cluster.
• FoundationDB is a distributed key-value store designed to handle large volumes of structured or unstructured data with strict ACID multi-key transactions. It doesn't enforce a schema at the database engine level, though most users build higher-level data models on top of it.

To help narrow down the best fit, tell me:

• Do you need distributed/horizontal scaling (like cloud-native multi-region) or a single-node setup?
• Are you looking for a document store (JSON collections) or a key-value / custom structure?

You can achieve both ACID compliance and a schema-less (flexible document/JSON) data model using modern NoSQL document stores or NewSQL databases configured without strict validation constraints.

Top options that provide full ACID transactions while allowing you to store arbitrary, unconstrained JSON or document structures include:

• RavenDB : A fully transactional, ACID-compliant NoSQL document database built from the ground up to be schema-less. It natively supports multi-document transactions and uses its own ACID storage engine (Voron) without forcing you to define rigid tables or predefined data types.
• MongoDB : A widely used document database with a flexible, dynamic schema. It supports full multi-document ACID transactions across replica sets and sharded clusters, allowing you to insert and modify differently structured JSON-like BSON documents safely within atomic transactions.
• FoundationDB : A distributed, heavily ACID-compliant key-value store designed to handle large-scale structured and unstructured data. It provides strict serializable isolation transactions while treating values as uninterpreted byte arrays, leaving all schema and structure definitions completely up to your application layer.

To help narrow down the best fit, tell me:

• Are you looking for an embedded/local database or a distributed/cloud cluster?
• Do you need multi-document transactions, or is atomicity on a single record/document sufficient?

Yes. What you’re looking for is generally a document database with ACID transactions and a flexible/schema-less data model.

Best options

MongoDB is probably the simplest answer. Its documents don't have to share the same fields or data types, while it supports multi-document and distributed ACID transactions.

For example, you can have:

{
  "_id": 1,
  "name": "Alice",
  "preferences": {
    "theme": "dark"
  }
}

and another document in the same collection:

{
  "_id": 2,
  "name": "Bob",
  "age": 42,
  "subscriptions": ["pro", "alerts"],
  "metadata": {
    "source": "import"
  }
}

No predefined table schema is required. You can optionally add schema validation later if you want more control.

One important distinction

"Schema-less" doesn't really mean no schema whatsoever. Your application still has an implicit data model. The important difference is that the database doesn't require every record to conform to a fixed schema.

If you want SQL/query capabilities + ACID + arbitrary JSON documents, I'd also look closely at Couchbase. It stores JSON in a flexible schema-less manner and supports multi-document ACID transactions.

If you tell me what you're building and roughly how much data/traffic you expect, I can narrow this down to 2–3 databases and explain the tradeoffs.

To help narrow down the best fit , let me know:

• What is your preferred programming language or tech stack?
• Do you need it to be distributed/cloud-native or run on a single node?
• Are you storing data as JSON documents or raw key-value pairs?

Yes. What you're looking for is generally called a schema-flexible (or schemaless) document database with ACID transactions.

Best options

Couchbase is particularly close to your description. It stores JSON documents without enforcing a database-level schema, allowing heterogeneous documents and schema evolution, while supporting distributed, multi-document ACID transactions.

RavenDB is another strong choice if you want ACID to be a fundamental characteristic of the database. Its document operations are fully ACID, including atomic operations across multiple documents within a transaction.

One important distinction

"Schema-less" doesn't mean "no structure." Your documents can have different shapes:

{
  "customer": "Alice",
  "email": "[email protected]"
}

and:

{
  "customer": "Bob",
  "email": "[email protected]",
  "phone": "555-1234",
  "preferences": {
    "darkMode": true
  }
}

The database doesn't require you to declare columns and types ahead of time. You can still impose validation/schema at the application level if you want it.

If you tell me your requirements around SQL queries, scale, deployment (self-hosted vs cloud), language, and whether you need joins, I can narrow this down to 1–2 databases.

You are looking for a Transactional NoSQL (or Document) Database . While traditional relational databases (like PostgreSQL or MySQL) tie ACID compliance strictly to rigid table schemas, modern document databases bridge this gap by offering full ACID transactions on flexible, schemaless JSON-like documents.

Top options that provide ACID compliance without enforcing a strict schema include:

• RavenDB - A fully transactional, ACID-compliant NoSQL document database designed from the ground up to support complete multi-document and cluster-wide ACID transactions without sacrificing performance. Documents are completely schemaless.
• MongoDB - Offers a flexible, schema-free document model and supports multi-document ACID transactions across replica sets and sharded clusters. Single-document operations are naturally atomic, while multi-document transactions handle complex rollbacks safely.
• Amazon DynamoDB - While it defaults to eventual consistency and flexible attribute-based items (schemaless tables), it fully supports ACID transactions via TransactWriteItems and TransactGetItems APIs when you need strict transactional guarantees across multiple items.

If you'd like to narrow down which one fits best, tell me:

• Do you need multi-document/multi-row transactions , or is atomicity for a single record/document enough?
• Are you deploying on-premises or looking for a managed cloud service?

Yes. What you’re looking for is generally a schema-flexible / schemaless document database with ACID transactions.

My top choices

MongoDB is probably the simplest answer. It doesn't require you to define a rigid schema for documents, while supporting ACID transactions across multiple documents, collections, databases, and shards.

Couchbase is another particularly good fit. Its server doesn't enforce a schema, supports heterogeneous JSON documents, and provides distributed multi-document ACID transactions.

One important distinction: "schemaless" doesn't mean "no data model." You can let documents evolve freely, but your application will still implicitly have expectations about fields and types. Otherwise querying and maintaining the data becomes difficult.

If you tell me what you're building and whether you need joins, high write throughput, horizontal scaling, or multi-record transactions, I can narrow this down to the best 1–2 options.