Exploring 8 Futuristic Databases to Watch in 2023

11 min readJun 20


Relational database management systems have dominated the field of database technologies for many years. When SQL first appeared in the 1970s, the use and popularity of RDBMS skyrocketed. Soon enough, MySQL became the go-to database choice for most companies and teams.

However, 2023 has brought a plethora of game-changing databases to the table. While some of these databases continue to be constructed using conventional relational patterns, others provide novel approaches.

In this article, we will explore some of these innovative and futuristic databases and compare their features.


PlanetScale is a serverless MySQL platform based on the Vitess horizontal scaling MySQL technology. Vitess is a scalable open-source database developed by Google to accommodate billions of YouTube users. Handing a scale like that is not child’s play. What’s interesting about PlanetScale is that it’s a branching database, a novel workflow that has emerged only recently but appears to be quite promising. But what is a branching database?

What is a branching database?

A branching database allows you to create different branches from your main database that you can use for different purposes. You can imagine this workflow as something very similar to a version control system like Git where you make changes to a project without breaking the entire codebase.

You can create a copy of your main or production database into a separate database branch. Then, you can experiment in that database branch, make changes and when you’re completely satisfied with them, merge them back to your main database. Thus it’s highly efficient and intuitive to play around and experiment with your database while keeping your production database intact.

PlanetScale’s Branching Workflow

PlanetScale also adds branches to your database so you can test schema changes on an isolated development branch. This branch is separate from the production branch or your main database. This provides an isolated working environment without explicitly creating a staging or testing environment for experimenting with schema changes. You can read more on what branching means and how PlanetScale uses this concept in their documentation page.


PlanetScale automatically creates daily backups and protects direct schema changes on your production branch right out of the box, reducing the possibility of accidentally corrupting the production database.

Non-blocking schema changes are yet another interesting feature it provides. You can create and deploy a request to update your tables without disrupting your users when you want to change your database schema. It is also simple to integrate with third-party tools like Prisma.

Prisma is an open-source database toolkit that provides a type-safe ORM (Object-Relational Mapping) layer for modern web applications. When you want to change your database schema, you can use Prisma’s migration feature to generate the necessary SQL scripts that can be applied to your database in a non-blocking way, without disrupting your users. This way you can integrate your PlanetScale with Prisma to efficiently update your schema whilst your application remains online.


While the team plan at PlanetScale costs $599 per month, there is a free tier included in the pricing plan. You get 1 production and 1 development branch in the free tier with 1 billion reads and 1 million writes per month. You can also opt for their [Scalar plan](https://planetscale.com/pricing) if you need more reads, writes and branches without breaking the bank at $29/month.


Because it is a relatively new service, it does not possess all of the attributes of a standard MySQL database, such as stored procedures, triggers, indexing, and other similar features. Moreover, if you are new to the idea of distributed databases, the learning curve might pose a problem.


YugaByteDB is an open-source Postgres database loaded with all Postgres native features in a cloud-native environment. It allows you to host your database on multiple clouds at the same time thereby giving you more control over your database system and eliminating vendor lock-in. This also enables you to deploy your cloud instance in different regions which in turn provides you with a higher degree of fail tolerance for your database.


YugaByte supports both SQL and NoSQL APIs. This gives developers the flexibility and freedom to choose the type of API that works best with respect to their familiarity and use case. Besides ensuring high performance and scalability, it also provides high availability.


Yugabyte gives you a fully-managed dedicated cluster for $0.25 per hour per core. Further, you can also talk to their sales team directly and figure out their pricing model pertaining to your use case [here](https://www.yugabyte.com/contact/).


Being another distributed database system, it might have a steeper learning curve and some overhead complexity as compared to traditional SQL databases.


Dolt is a unique database that works on the same principle as version control and Git. It allows you to track changes to your data and understand how and when your data changes over time. It’s just like a Git repository where you can push, pull, fork or clone databases. Pretty interesting, right?

Dolt’s Branching Behaviour

Like PlanetScale and Neon Dolt also implements branching behaviour where you can experiment with your data without making breaking changes to your production data. Since it’s built and works like a Git workflow, all the git commands like git log, git add, etc. can be replaced by dolt log, dolt add on the command line when using Dolt.


It supports SQL queries right out of the box, which makes it easy for developers coming from a traditional SQL background to work with retrieving and updating data. Another interesting feature that Dolt offers is collaborative editing. A team using Dolt can have many developers working on the same Dolt database at the same time. Dolt takes care of merging all the changes made to the database automatically.

Pricing and Drawbacks

It’s open-source and completely free. However, due to the limited features such as stored procedures or user-defined functions it may only cater to specific use cases.


Developed by ex-Googlers, CockroachDB is one of the most resilient distributed database systems compatible with SQL and Postgres. It’s built with Go, provides multi-model support for both SQL and NoSQL APIs, supports multi-cloud deployment like YugaByteDB and can handle millions of queries per second.

It has strong community support and also provides a good amount of resources for developers to learn CockroachDB like tutorials, blog posts, etc.


While it has a free version that you can use for small projects in development and test mode, it can be a little expensive, especially when compared to other open-source alternatives. However, its dedicated plan costs a lot less than PlanetScale at $295/month.


Being a distributed database system, it comes with the overhead complexity needed to setup and manage the system along with a steep learning curve. It’s also not the ideal choice for applications with low latency and high throughput due to performance issues.

CloudFlare D1

Let’s now introduce you to a serverless database platform that runs SQLite database on the edge. Cloudflare Durable Objects (D1) is used for building and deploying stateful applications. It uses a different data model than the traditional SQL data model, which looks and works a lot like a document-oriented database like MongoDB.

How is data stored in CloudFlare D1?

Let’s explore an example. We know that in a traditional SQL database, data is stored in tables consisting of rows and columns. Consider a table called “employees” with the following columns as “id”, “name”, “age”, and “department”. Here is what the table might look like:


In contrast, CloudFare D1 stores data in the form of objects like a document database. So to translate the above example, we have an object called “Employee” that has the following properties: “id”, “name”, “age”, and “department”:

Employee {
id: 1,
name: 'Alice',
age: 28,
department: 'Sales'

Hence the above data is stored as an Employee object with a unique identifier.


The great thing about Cloudflare is that it already has its key-value store for workers, but the trade-off is that native transactions do not work. Therefore you can also write stored procedures with JavaScript and run these procedures, which are basically code snippets directly in your database. You can then use them to create transactions or other reusable queries. Moreover, CloudFare D1 being serverless makes it easy to deploy and manage.


Cloudflare D1 is in alpha and is completely free to test, use and experiment with. This is the best time to play around with it and understand if it can be your go-to database choice in the future.


CloudFlare D1 is not production-ready yet. It also has very limited use cases that don’t involve complex data structures or traditional SQL querying. Another problem with the durable objects approach is difficulty in migration, eventually leading to vendor lock-in. All in all, as promising as this database sounds, you can’t use it in your production app at this moment.


Speaking of serverless architecture, Xata brings an interesting relational database based on Postgres and Elastic search. It treats your data as a spreadsheet making it very easy for developers to build applications that require a flexible schema. You can also imagine it as a developer-friendly alternative to AirTable or Notion.


It comes with a full-text search out of the box and can also help you visualize the relationships in real time between your tables using the schema editor it provides.

It also supports branching like Dolt and is primarily used for processing large volumes of data in real-time. It also supports some advanced querying capabilities like aggregations, filters, joins, etc.


Xata’s pricing is based on the rate limiting or number of database hits you can make per second. It has a free plan that gives you 75 requests/second with up to 750,000 records. If you’re a startup or planning to roll out an MVP soon, their free plan should be just enough for you. Their pro plan starts at $8/unit/month.


Some of the main drawbacks with Xata include difficulty in migrating to other platforms in the future and overall complexity that often requires significant expertise to work with.

Surreal DB

Written in Rust, Surreal DB provides a single easy-to-use API for relational, document and graph databases.


When it comes to data modeling it’s extremely flexible, making it an ideal choice for recommendation engines, social networks, etc. In this regard, it’s similar to the popular graph database Neo4J.

It’s also very simple to use with any SQL type query language and also provides the ability to perform real-time queries efficiently.

For instance, here’s an insertion query in SurrealQL that looks almost identical to an SQL insert query:

INSERT INTO company {
name: 'Siddhant',
age: 24,
hobbies: ['technical writing', 'basketball']

Moreover, you can use SurrealQL to directly connect your Surreal DB to your client applications.


Since it’s relatively new, it has limited documentation and community support especially when compared to other databases discussed in the post. It also uses its own query language called SurrealQL to write queries. This may introduce a new learning curve and lack of optimal resources to get the hang of this query language might be a roadblock for your developers in a lot of use cases.


At this moment, SurrealDB doesn’t have any cloud offerings, but you can join their cloud waitlist planned in their roadmap for the future. You can self-host it yourself on local or private servers. While SurrealDB isn’t completely open-source, it’s licensed under the Business Source License which makes it free for all development and production use.

Fauna DB

FaundaDB is one of the most versatile and easy-to-use databases. Created by ex-Twitter engineers, it’s a NoSQL database and follows a document database paradigm similar to MongoDB.


Despite being a NoSQL database, it supports features like native joins, which is the number one missing feature in document databases. It is well-suited for complex relational data like social graphs and has its own custom query language called FQL. It also comes with default support for Graphql API.

It uses a distributed architecture to provide high availability and low latency. It can be an ideal choice for serverless applications or microservices architecture.


It comes with a free plan that gives you 100K reads, 50K writes and 5GB of storage. Quite well suited for a personal project but may not scale for your MVP or a bigger production project. You can upgrade to any of FaunaDB’s plans ranging from $25/month for individuals, $150/month for teams, to $500/month for large organizations.


Similar to SurrealDB, FaunaDB also uses its own query language called FQL which might introduce a learning curve for developers.

For instance, here’s a commonly used query in FQL:


The above query basically retrieves all the documents from a collection called “users” and paginates them by default.

The equivalent query in SQL is:

SELECT * from users

As you can see, both the queries are quite different and have no similarity in their syntax.

Moreover, FaunaDB is also relatively expensive compared to the other databases we’ve discussed in the post.


We’ve discussed some of the most advanced and futuristic databases. Most of these databases use a distributed architecture, which can require additional effort and resources in terms of setting them up, getting the hang of it, and using them to their full-potential. However, their innovative approach and novel workflow suggest that they have valuable applications.

If you’re considering moving away from SQL entirely, choose a database based on factors such as pricing, ease of use, community support, and overall usefulness. If you prefer document databases, FaunaDB is a good option. If you’re interested in branching databases, check out PlanetScale or Dolt. If you need a flexible schema, Xata is an excellent choice. Each of the databases we’ve discussed has its own unique features.

Originally published at https://semaphoreci.com on June 20, 2023.




Supporting developers with insights and tutorials on delivering good software. · https://semaphoreci.com