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

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.

Yes. What you’re looking for is usually called a schema-flexible or schemaless document database with ACID transactions.

Good options

My default recommendation: MongoDB. It lets different documents have different fields without requiring a fixed table schema, while supporting ACID transactions across multiple documents.

If you want strict ACID + genuinely schema-free JSON, Couchbase is particularly explicit about this combination: it supports flexible JSON documents without enforcing uniform document structure and provides multi-document ACID transactions.

One important distinction: “schemaless” doesn't mean “structure doesn't matter.” You can let the database accept arbitrary documents while your application maintains whatever conventions or validation it needs.

If you tell me your workload (e.g. event data, user profiles, financial transactions, configuration, IoT, etc.) and whether you need SQL/joins, I can narrow this down to the best 1–2 choices.

Yes, you can have both. While traditional wisdom stated that you had to choose between rigid ACID relational databases and flexible schemaless NoSQL systems, modern database engineering has bridged this gap.

Several modern document and multi-model databases are fully ACID-compliant while operating without a rigid upfront schema.

Top Database Options

• MongoDB — Offers fully-compliant, multi-document ACID transactions . It is a document database (schemaless JSON/BSON storage) that allows you to store arbitrary data structures while wrapping complex, multi-collection or multi-document changes in safe transactional boundaries.
• RavenDB — Built from the ground up as a transactional, schemaless NoSQL document database . Unlike systems that patched transactions on later, RavenDB provides full ACID guarantees across aggregates and distributed clusters natively without sacrificing document flexibility.
• Couchbase — A distributed NoSQL document store that provides multi-document ACID transactions . It handles flexible JSON documents while supporting atomic writes and automatic rollbacks.
• Neo4j — If your data fits a graph structure rather than documents, Neo4j is a schema-optional graph database that is fully ACID-compliant . Nodes and relationships can have dynamic properties added on the fly without a predefined schema.

To help narrow down the best fit, could you share:

• What kind of data structure you are storing (documents, graphs, or key-value)?
• What your scale and deployment looks like (single server vs. distributed cluster)?

You can achieve both ACID compliance and a schemaless (or schema-flexible) data model. While traditional relational databases tied ACID tightly to strict tabular schemas, modern document stores and NoSQL options support multi-document ACID transactions without requiring predefined schemas.

Top database options matching this requirement include:

• MongoDB : Provides full multi-document ACID transactions. It is inherently schemaless at the collection level, allowing you to store arbitrary JSON/BSON documents with varying structures while still wrapping operations in atomic, isolated, and durable transactions.
• RavenDB : A fully ACID-compliant document database designed from the ground up to be schemaless. It supports ACID transactions across multiple aggregates and documents natively without needing rigid tables or migrations.
• FoundationDB : A distributed key-value store with powerful, strict ACID transaction capabilities. It doesn’t enforce any schema on your values (which are typically stored as arbitrary byte arrays or structured formats like JSON), leaving the interpretation entirely to your application layer while guaranteeing serializable isolation.
• Amazon DynamoDB : Supports native, full ACID transactions across items within and across tables. While it requires a defined primary key, the rest of the attributes for each item can be completely dynamic and unstructured.

To help narrow down the best fit, could you share:

• The scale and deployment type (single-node vs. distributed/cloud)?
• The complexity of your transactions (e.g., single item vs. multi-document updates)?

Yes. What you are looking for is usually called a schemaless (or schema-flexible) database with ACID transactions. Several databases fit that description.

genui{"data_networks_databases_learning_block":{"type_id":"BLOCKCHAIN_HASH_CHAIN"}}

Good options:

A few considerations:

• If you mean “I want to store arbitrary JSON documents and occasionally transact across them” → MongoDB or Couchbase are likely the closest matches.
• If you need strong relational queries, joins, constraints, and analytics → PostgreSQL with JSONB is often a better architecture, even though the table itself has a schema.
• If you need offline sync / replication → CouchDB is worth evaluating.

One important distinction: ACID and schema flexibility are separate features. A database can have no enforced schema while still guaranteeing atomic, consistent, isolated, and durable transactions.

If you tell me your use case (e.g., SaaS app, IoT, financial records, logs, CMS, user profiles), I can narrow this down.