Fauna’s data model integrates the best aspects of document and relational databases. Like other document databases, data is stored in JSON-like documents, allowing for the storage of unstructured data and removing the need for an object-relational mapper (ORM) to translate between objects and tables. Fauna also provides key features of relational databases including strong consistency, first-class support for relationships between documents, and the ability to layer on and enforce schema over time.

Documents in Fauna are organized into collections, similar to tables in relational databases, providing a familiar structure for data organization. Collections can specify document types, which define and enforce the structure of documents they contain. This feature allows developers to start with a flexible schema and gradually introduce more structure as their application matures. Importantly, Fauna supports relationships between documents in different collections, enabling complex data modeling without duplicating data. This approach combines the ease of use of document databases with the powerful data modeling capabilities of relational systems.

Fauna is built on a distributed architecture that offers global data distribution across multiple regions in a region group. It provides strong consistency for all transactions, even across geographic regions, a feature that sets Fauna apart from many other distributed databases. The system maintains high availability and resilience to regional outages, automatically replicating data and using intelligent routing to provide low-latency access across broad geographies.

As a fully managed service, Fauna eliminates the need for database provisioning, capacity planning, sharding, scaling operations, and routine maintenance. Developers interact with Fauna through a single global API endpoint, greatly simplifying integration and reducing operational complexity. This serverless approach allows development teams to focus on building applications rather than managing infrastructure.

Fauna Query Language (FQL) is a TypeScript-inspired language designed specifically for querying and manipulating data in Fauna. It offers a concise, yet expressive syntax for relational queries, supporting complex joins and data transformations. FQL includes optional static typing to catch errors early in development, improving code quality and reducing runtime issues.

One of FQL’s powerful features is the ability to create user-defined functions (UDFs). These allow developers to encapsulate complex business logic directly within the database, promoting code reuse and maintaining a clear separation of concerns.

Here’s an example of an FQL query:

The query shows how FQL can succinctly express complex operations, including lookups, joins, sorting, and data projection.

Fauna Schema Language (FSL) allows developers to define and manage database schemas as code. It enables version control for schema changes, integration with CI/CD pipelines, and progressive schema enforcement as applications evolve. By treating database schema as code, teams can apply the same rigorous review and testing processes to database changes as they do to application code.

Here’s an example of an FSL schema definition:

This schema defines a Customer collection with specific fields, a computed field, a uniqueness constraint, and an index. The *: Any wildcard constraint allows for arbitrary ad hoc fields, providing flexibility while still enforcing structure where needed.

In Fauna, every query is a transaction, ensuring ACID compliance across all operations, even in globally distributed region groups. Fauna’s distributed transaction engine, based on the Calvin protocol, provides strict serializability for all read-write transactions and serializable isolation for read-only transactions. This guarantees real-time consistency across all replicas without relying on clock synchronization, eliminating anomalies common in systems dependent on synchronized clocks.

Fauna’s strong consistency model has been verified by Jepsen, an independent third-party analysis firm, confirming its ability to maintain high levels of consistency even under various failure scenarios. Despite these robust guarantees, Fauna maintains high performance and low latency, even for geographically distributed deployments, thanks to its innovative architecture that separates transaction ordering from execution.

Fauna provides comprehensive security features to protect your data and control access. It offers role-based access control (RBAC) for coarse-grained permissions and attribute-based access control (ABAC) for fine-grained, dynamic access rules. This combination allows for highly flexible and precise control over who can access and modify data.

The system includes built-in user authentication and also supports integration with third-party identity providers, allowing you to use existing authentication systems. All data in Fauna is encrypted at rest and in transit, ensuring protection at all times.

Fauna’s event streaming feature enables real-time application features. Developers can subscribe to changes in collections or specific documents, receiving either atomic push updates or on-demand batch pull updates to power change data capture (CDC). Streaming is particularly useful for maintaining live application states, building collaborative features that require real-time synchronization, and mirroring changes into external systems.

Fauna’s database model makes it easy to create databases for isolated environments, such as staging and production, and build secure multi-tenant applications.

For multi-tenant applications, developers can create isolated child databases for each tenant, applying separate access controls and schema as needed.

The same approach can be applied to isolated environments, enabling separate databases for each environment, ensuring that changes in one environment do not affect others.

This model simplifies administration, ensures clear separation between environments, and guarantees that tenants or environments cannot interfere with each other’s data.

Fauna and MongoDB are both document databases, but Fauna offers a unique combination of document flexibility with relational database features. While MongoDB provides a flexible document model and horizontal scalability, Fauna enhances this with strong consistency guarantees, built-in support for complex relationships, and more powerful querying capabilities through FQL. Fauna’s document-relational model allows for enforcing schema when needed, supporting complex joins, and maintaining ACID compliance across distributed environments. Unlike MongoDB, Fauna provides native multi-region distribution and doesn’t require separate replication setup or sharding configurations.

Compared to key-value stores like DynamoDB, Fauna offers a richer data model and query capabilities while maintaining high performance and scalability. Fauna’s document-relational model allows for more complex data structures and relationships, reducing the need for denormalization often required in DynamoDB. Fauna provides native support for secondary indexes without the limitations found in DynamoDB, such as the ability to index nested fields and arrays. Additionally, Fauna’s query language (FQL) allows for more sophisticated queries and data manipulations within the database, potentially reducing application-side complexity. Both databases offer serverless operations, but Fauna’s multi-region distribution is built-in, simplifying global deployment.

While both Fauna and PostgreSQL are relational databases supporting ACID transactions, their architectures and deployment models differ significantly. PostgreSQL follows a traditional client-server model with a fixed schema, while Fauna offers a flexible document-relational model with optional schema enforcement. Fauna’s serverless, globally distributed architecture contrasts with PostgreSQL’s typical single-region deployment, offering easier scalability and global distribution out of the box. Fauna’s FQL provides a modern, programmable query interface, whereas PostgreSQL uses standard SQL. Both support stored procedures, but Fauna’s User-Defined Functions (UDFs) are written in FQL and executed within the database’s distributed environment. Fauna also offers built-in temporality and multi-tenancy features, which typically require additional setup in PostgreSQL.

Fauna and NewSQL databases like CockroachDB both aim to combine the scalability of NoSQL systems with the strong consistency of traditional relational databases. However, Fauna’s approach differs in its serverless, API-first design. While CockroachDB focuses on providing a distributed SQL database, Fauna offers a document-relational model with its own query language (FQL). Fauna’s built-in multi-tenancy and attribute-based access control provide more granular security options out of the box. Both databases offer global distribution, but Fauna’s serverless nature means users don’t need to manage nodes or worry about data placement strategies. Fauna’s temporal query capabilities and event streaming are also notable features not typically found in NewSQL offerings.

With this combined set of features, Fauna aims to provide a unified solution that meets the diverse needs of modern application development, from rapid prototyping to global-scale production deployments. Its unique approach allows developers to build sophisticated, globally distributed applications without the operational complexity traditionally associated with such systems.