For less structured data, FaunaDB transparently supports document-style interactions. Create, modify, and delete richly nested records, and build indexes and views across them. Records in the same table can contain different fields, and records in different tables can contain the same fields—and even be merged into the same index.
For applications that require traditional, structured data, FaunaDB supports fully relational modeling. Joins, foreign keys, unique indexes, and other critical correctness features are supported (albeit without a SQL query interface at the moment). ACID compliance guarantees that transactions—even across multiple servers and multiple keys—will be strongly consistent.
FaunaDB has native support for distributed graphs and graph functions. It excels at storing highly clustered graphs with billions of nodes and edges and serving workloads that are impossible in other systems. Relationships can be recursive and polymorphic, can be modified and decorated at any time, and can be modeled with or without foreign keys and join tables—you choose what's best for your application.
FaunaDB lets you convert any query into a change feed: a view of how that query's results have changed within a time window. Combine change feeds with graph data and you can trivially serve complex activity feeds at scale. Historical snapshot queries support auditing, forensics, and provenance analysis, and can show the state of any data at any point in the past.
It illustrates multiple model data access patterns (graph, multi-level joins, indexes, and temporality) - all within the same query.
Expressions in other languages are equally simple. This is just a small taste of the power of FaunaDB.
FaunaDB's core engine is architected to deliver strong consistency across globally replicated data, in real-time, at scale, without introducing latency (but we still have to deal with the speed of light). All replicas are r/w, so your apps can be assured of fast local access. Wicked simple cluster operations let you easily adjust capacity on-demand.
Our patent-pending transaction protocol ensures strong distributed consistency that lets you implement applications quickly and correctly. When an application writes to FaunaDB, the cluster uses layered coordination protocols to agree on the state change before the effects are applied, isolating the transaction and preventing partial failure. The result is strongly consistent, multi-key transactions and indexes—even across datacenters—with no visible impact on latency.
FaunaDB scales linearly. It supports both horizontal and vertical scalability, enabling you to add capacity on the fly by provisioning commodity machines in your datacenter, or by adding virtual machines to your cloud.
FaunaDB is masterless, self-coordinating, and has no service dependencies or single points of failure. A FaunaDB cluster replicates your data on the fly—across multiple physical data centers and public clouds so you never experience data loss.
FaunaDB preserves the history of every piece of data. Whenever data is updated or deleted, the existing values are preserved—not overwritten. This is useful for incremental backups and auditing but also makes it easy to model rich change feeds. Temporal queries are scalable and fast. Configurable retention policies ensure that your data meets storage and compliance requirements.
FaunaDB delivers consistent, high performance. Modern techniques like speculative request dispatch, predicate pushdown, and total query parallelization are combined with a low-latency storage engine. But it's not just fast, it's predictable: query plans are deterministic, optimizations are local, and query performance scales with query complexity, not with the total size of your dataset.
FaunaDB is implemented in Scala and Java and runs on any modern operating system, including Linux, Windows, BSD, and OS X. It scales down to your laptop and up to your largest server, and runs in any virtualized or container environment. You can operate FaunaDB with standard JVM tools—or use our cloud and don't operate anything at all.
FaunaDB's operational profile maintains high availability and simplicity at any scale.
FaunaDB ensures that resources are dynamically provisioned across teams, projects, applications, and workloads as demand spikes and subsides. Say goodbye to nerve-wracking product launches and upside risk. When resources are truly exhausted, scale your cluster in minutes, and optimize when things settle down.
FaunaDB offers built-in multi-tenancy to simplify your shared services environments. Databases can be nested, making it simple to delegate administration to other departments and teams. It also lets you dynamically assign priority to projects, apps, and workloads—like an operating system—and assigns resources moment-to-moment based on those priorities. Your hardware runs at higher levels of utilization, TCO is vastly reduced, and workloads with competing performance profiles—like analytics and user-facing queries—run safely against the same datasets.
FaunaDB delivers enterprise-grade security by offering key-based access from the get-go. You simply cannot create an unsecured database within FaunaDB and the security model is applied to every query in the API. It also isolates datasets among tenant databases. If you choose, FaunaDB’s security model can allow untrusted clients like mobile apps and IoT devices to connect directly to the database—no middleware needed. In-flight queries are protected by encrypted networking and authentication wherever FaunaDB is deployed.
FaunaDB plays well in enterprise IT organizations. It works with all standard orchestration tools—including container schedulers—and speaks HTTPS on the wire. FaunaDB supports a fully relational data model, so existing datasets can be imported without denormalization. Change feed queries let you synchronize data in FaunaDB with analytics engines and column stores in real time, or use it like a message bus.
FaunaDB is fanatical about minimizing potential data loss in the event of a catastrophe. The temporal data model makes transaction history clear—including schema history—and transparently supports incremental, logical backups. Filesystem backups are supported as well. Under normal operating conditions, FaunaDB is self-healing. In disaster scenarios, such as the loss of the majority of datacenters, operators can use FaunaDB’s built-in tools to quickly recover to entirely new infrastructure and get your business back online.
On-premises, in the cloud, or database-as-a-service —Fauna offers pricing options that allow you to scale.