The goodness of Postgres without its operational bottlenecks
Postgres and Fauna are both relational databases, supporting serializable transactions, database normalization, foreign keys, indexes, constraints, stored procedures, and other typical relational features. Additionally, Fauna offers modern capabilities such as data temporality, streaming, and multi-tenancy, combined with a NoSQL API and built-in support for GraphQL.
If you like Postgres, especially its transactional properties and battle-hardened reliability, but wish to minimize your operational burden, gain flexibility, and free yourself from routine tasks such as data partitioning, replication, redundancy, etc. you may like Fauna even more!
Fauna combines the operational integrity and relational modeling of Postgres with an interface and architecture that fits better with modern application development in the cloud. Fauna scales transparently, without resource limits and capacity constraints. And its serverless API eliminates the provisioning and administrative tasks that come with Postgres. With Fauna, you can simplify code, reduce costs, and ship faster!
|Fauna Benefit||Comparison with Postgres|
Freedom from ORM complexity
ORMs introduce significant application complexity, and make it difficult to use core Postgres features. Fauna’s document model is a more natural fit for modern applications, does not require ORMs, and still supports transactions, joins, relations, indexes, and views.
Transparent and performant indexing
Query optimization in Postgres can be a dark art, and query plans can change at runtime in surprising ways. In Fauna, indexes are more like transactional views. They are composable and transparent and always make the query plan clear.
Flexible schema design
Migrating a SQL schema can be a pain, especially when you aren’t sure of how your application is going to evolve. Fauna is schemaless, improving developer flexibility without giving up any of the core relational model.
Serverless connection model
We are all familiar with the overhead of persistent Postgres connections and tools like PgBouncer that try to mitigate it. This model doesn’t work in a serverless and web-native world. Fauna uses stateless, secure HTTP connections with no cold start latency, connection management, or proxying problems.
Better transactional isolation
Postgres defaults to read-committed isolation, which can result in correctness errors under concurrency. Even higher levels of isolation only apply to queries to the primary node. Fauna offers strict serializability--the highest possible isolation level--for every query, even in globally distributed deployments.
Modern security model
Postgres has a complex set of security models that interact in surprising ways, and customer-level identity and access control is usually impractical--not to mention vulnerable to SQL injection attacks. Fauna has a web-native security model that is highly composable, secure by default, and integrates with popular cloud identity providers.
Postgres’ primary/secondary replication creates performance bottlenecks, consistency issues, and single points of failure. Fauna’s semi-synchronous replication, inspired by Calvin, manages failures of the underlying infrastructure transparently for both reads and writes and guarantees optimal latency in any environment.
Postgres is a provisioned system, not an elastic one. Capacity planning takes time and often cost and scalability are in conflict. Fauna makes the database available as an API, not a provisioned resource. There are no resource limits and performance is predictable at any scale.
No more operations
Many versions of Postgres exist in self-operated or managed cloud environments. All of them have different capabilities, upgrade cycles, and replication options to manage. Fauna is delivered as an API--always up to date, always backwards compatible, and always available.
Although Postgres offers no way for the application to access record history. Fauna has built-in configurable temporality, letting you build time-travel and undo features, protect yourself from developer error, create audit logs, and capture change data for synchronization with other systems.
Multi-tenancy in Postgres requires extending every table with a tenancy key and does not offer any data or query isolation. Fauna has built-in recursive, secure, dynamically isolated multi-tenancy, making it easy to offer separation and customization to your customers, or to manage and secure usage within your organization.
What's the buzz about?
Our customers love Fauna because it is productive, modern, uncompromising and operations-free.
"Initially, we stored our user data in Postgres, but when we were starting to scale up our user base, it was going to become too expensive to scale and require significant engineering effort. We were going to need to think about how to partition the database and then devote a lot of time to just monitoring it. We choose Fauna because it’s completely managed and that it scales while giving us all the querying power that we need."
Felix Engelhardt, Lead Engineer at EIDU
"Postgres was my go-to database before Fauna. But I was always looking for something better. When I came across Fauna I realized that this was the first database that I have not felt limited by."
Eigil Sagafos, Co-Founder and CTO at Shift X
Getting started with Fauna is easy! Just follow our quick start guide, or browse through our resources to better understand the differences between Fauna and Postgres.