StatelyDB is not just another database; it is an intelligent data platform designed to solve the most difficult challenges of building and scaling modern applications: data evolution, developer productivity, and multi-cloud flexibility. We do this by providing a series of powerful, abstract layers on top of the world's most proven, scalable storage engines.
This layered architecture is the key to our ability to provide a simple, elegant developer experience without sacrificing the raw power and reliability of underlying databases like Amazon DynamoDB. It allows you to build for today with the confidence that your data infrastructure can evolve to meet the unknown demands of tomorrow.
At its foundation, StatelyDB leverages battle-tested, hyperscale storage engines. Our first and primary storage engine is Amazon DynamoDB, chosen for its near-infinite scalability, consistent performance, and zero-ops management model. We also support MongoDB and Google Firestore, with more to come.
This approach gives you the best of both worlds:
You inherit the durability, availability, and battle-hardened reliability of platforms built to handle the world's largest workloads. We do not reinvent the wheel for storing bytes on disk; we build on the best.
You inherit the durability, availability, and battle-hardened reliability of platforms built to handle the world's largest workloads. We do not reinvent the wheel for storing bytes on disk; we build on the best.
By abstracting the storage layer, StatelyDB gives you the freedom to choose the cloud and storage engine that best fits your needs for cost, performance, or strategic reasons, all without changing your application code.
By abstracting the storage layer, StatelyDB gives you the freedom to choose the cloud and storage engine that best fits your needs for cost, performance, or strategic reasons, all without changing your application code.
With our Bring Your Own Cloud (BYOC) model, the storage engine runs in your own cloud account, allowing you to take full advantage of your existing enterprise discounts and committed spend.
With our Bring Your Own Cloud (BYOC) model, the storage engine runs in your own cloud account, allowing you to take full advantage of your existing enterprise discounts and committed spend.
The storage engine is the powerful but unrefined foundation. On its own, as we detail in "Data modeling in DynamoDB is awkward," it is powerful but difficult to use effectively. The real magic begins in the layer above.
At its foundation, StatelyDB leverages battle-tested, hyperscale storage engines. Our first and primary storage engine is Amazon DynamoDB, chosen for its near-infinite scalability, consistent performance, and zero-ops management model. We also support MongoDB and Google Firestore, with more to come.
This approach gives you the best of both worlds:
You inherit the durability, availability, and battle-hardened reliability of platforms built to handle the world's largest workloads. We do not reinvent the wheel for storing bytes on disk; we build on the best.
By abstracting the storage layer, StatelyDB gives you the freedom to choose the cloud and storage engine that best fits your needs for cost, performance, or strategic reasons, all without changing your application code.
With our Bring Your Own Cloud (BYOC) model, the storage engine runs in your own cloud account, allowing you to take full advantage of your existing enterprise discounts and committed spend.
At its foundation, StatelyDB leverages battle-tested, hyperscale storage engines. Our first and primary storage engine is Amazon DynamoDB, chosen for its near-infinite scalability, consistent performance, and zero-ops management model. We also support MongoDB and Google Firestore, with more to come.
This approach gives you the best of both worlds:
The storage engine is the powerful but unrefined foundation. On its own, as we detail in "Data modeling in DynamoDB is awkward," it is powerful but difficult to use effectively. The real magic begins in the layer above.
The Elastic Schema™ engine is the intelligent heart of StatelyDB. This is where we transform a raw key-value or document store into a sophisticated, version-aware database that understands the shape and history of your data.
This engine is responsible for three critical functions:
When you define your data model using our simple TypeScript DSL, the Elastic Schema engine stores that definition. Every time you make a change, it creates a new, numbered version of the schema. It does not perform a risky, "big-bang" migration. Instead, it maintains a complete history of every version of your data model.
When you define your data model using our simple TypeScript DSL, the Elastic Schema engine stores that definition. Every time you make a change, it creates a new, numbered version of the schema. It does not perform a risky, "big-bang" migration. Instead, it maintains a complete history of every version of your data model.
The engine understands how to translate data between the format physically stored on disk and the format expected by any version of your application. When a v1 client requests a record written by a v3 client, the Elastic Schema engine automatically and transparently transforms the data to match the v1 schema on the way out. This makes backwards and forwards compatibility automatic.
The engine understands how to translate data between the format physically stored on disk and the format expected by any version of your application. When a v1 client requests a record written by a v3 client, the Elastic Schema engine automatically and transparently transforms the data to match the v1 schema on the way out. This makes backwards and forwards compatibility automatic.
The engine translates the simple, logical key paths you define in your schema (e.g., /user-:userId/order-:orderId) into the optimized, and often complex, physical storage keys required by the underlying engine (like DynamoDB's single-table design partition and sort keys).
The engine translates the simple, logical key paths you define in your schema (e.g., /user-:userId/order-:orderId) into the optimized, and often complex, physical storage keys required by the underlying engine (like DynamoDB's single-table design partition and sort keys).
This layer effectively decouples your application's logical data model from the physical storage implementation, giving you the freedom to evolve your product without fear.
The Elastic Schema™ engine is the intelligent heart of StatelyDB. This is where we transform a raw key-value or document store into a sophisticated, version-aware database that understands the shape and history of your data.
This engine is responsible for three critical functions:
When you define your data model using our simple TypeScript DSL, the Elastic Schema engine stores that definition. Every time you make a change, it creates a new, numbered version of the schema. It does not perform a risky, "big-bang" migration. Instead, it maintains a complete history of every version of your data model.
The engine understands how to translate data between the format physically stored on disk and the format expected by any version of your application. When a v1 client requests a record written by a v3 client, the Elastic Schema engine automatically and transparently transforms the data to match the v1 schema on the way out. This makes backwards and forwards compatibility automatic.
The engine translates the simple, logical key paths you define in your schema (e.g., /user-:userId/order-:orderId) into the optimized, and often complex, physical storage keys required by the underlying engine (like DynamoDB's single-table design partition and sort keys).
The Elastic Schema™ engine is the intelligent heart of StatelyDB. This is where we transform a raw key-value or document store into a sophisticated, version-aware database that understands the shape and history of your data.
This engine is responsible for three critical functions:
This layer effectively decouples your application's logical data model from the physical storage implementation, giving you the freedom to evolve your product without fear.
The top layer is what your developers interact with every day. The Elastic Schema engine exposes a simple, consistent, and powerful API for all data operations: Put, Get, List, Delete, and Sync. This API is the same regardless of which storage engine you are using underneath.
The true productivity gain comes from our code generation tooling. The stately schema generate command connects to the API layer and creates a native, type-safe SDK for your chosen programming language (Go, TypeScript, Python, etc.).
This means developers are not working with untyped JSON blobs or writing complex query builder code. They are working with native objects that represent the data models they defined in the schema.
Consider creating a user in raw DynamoDB versus StatelyDB:
**Raw DynamoDB (Go):**
userAV, err := attributevalue.MarshalMap(user)
if err != nil {
return fmt.Errorf("failed to marshal user: %w", err)
}
userAV["PK"] = &types.AttributeValueMemberS{
Value: fmt.Sprintf("USER#%s", user.ID.String()),
}
userAV["SK"] = &types.AttributeValueMemberS{
Value: "METADATA",
}
// ... more complex mapping and put item call**StatelyDB (Go):**
user, err := client.Put(ctx, &schema.User{
DisplayName: "Stately Support",
Email: "support@stately.cloud",
})
// ... handle error
The top layer is what your developers interact with every day. The Elastic Schema engine exposes a simple, consistent, and powerful API for all data operations: Put, Get, List, Delete, and Sync. This API is the same regardless of which storage engine you are using underneath.
The true productivity gain comes from our code generation tooling. The stately schema generate command connects to the API layer and creates a native, type-safe SDK for your chosen programming language (Go, TypeScript, Python, etc.).
This means developers are not working with untyped JSON blobs or writing complex query builder code. They are working with native objects that represent the data models they defined in the schema.
The top layer is what your developers interact with every day. The Elastic Schema engine exposes a simple, consistent, and powerful API for all data operations: Put, Get, List, Delete, and Sync. This API is the same regardless of which storage engine you are using underneath.
The true productivity gain comes from our code generation tooling. The stately schema generate command connects to the API layer and creates a native, type-safe SDK for your chosen programming language (Go, TypeScript, Python, etc.).
This means developers are not working with untyped JSON blobs or writing complex query builder code. They are working with native objects that represent the data models they defined in the schema.
Consider creating a user in raw DynamoDB versus StatelyDB:
**Raw DynamoDB (Go):**
userAV, err := attributevalue.MarshalMap(user)
if err != nil {
return fmt.Errorf("failed to marshal user: %w", err)
}
userAV["PK"] = &types.AttributeValueMemberS{
Value: fmt.Sprintf("USER#%s", user.ID.String()),
}
userAV["SK"] = &types.AttributeValueMemberS{
Value: "METADATA",
}
// ... more complex mapping and put item call**StatelyDB (Go):**
user, err := client.Put(ctx, &schema.User{
DisplayName: "Stately Support",
Email: "support@stately.cloud",
})
// ... handle error
This layered architecture enables unparalleled deployment flexibility. You can choose the model that fits your needs today and switch tomorrow without rewriting your application.
This layered architecture enables unparalleled deployment flexibility. You can choose the model that fits your needs today and switch tomorrow without rewriting your application.
This layered architecture enables unparalleled deployment flexibility. You can choose the model that fits your needs today and switch tomorrow without rewriting your application.
This unique, layered approach provides a powerful set of benefits that are impossible to achieve with a monolithic database.
The combination of a simple, unified API and type-safe SDKs allows your team to move faster. Developers spend their time building features, not wrestling with database complexity or writing boilerplate data access logic.
The combination of a simple, unified API and type-safe SDKs allows your team to move faster. Developers spend their time building features, not wrestling with database complexity or writing boilerplate data access logic.
The Elastic Schema™ engine makes breaking changes literally impossible. You can evolve your data model, deploy new application versions, and roll them back with complete confidence, knowing that your data layer is always compatible.
The Elastic Schema™ engine makes breaking changes literally impossible. You can evolve your data model, deploy new application versions, and roll them back with complete confidence, knowing that your data layer is always compatible.
By abstracting the storage engine, we eliminate vendor lock-in. You are free to choose the best cloud provider and database technology for your needs, and you can change your mind later without a costly migration project. This gives you long-term control over your architecture and your budget.
By abstracting the storage engine, we eliminate vendor lock-in. You are free to choose the best cloud provider and database technology for your needs, and you can change your mind later without a costly migration project. This gives you long-term control over your architecture and your budget.
This architecture is built for a future of agentic software development. The safety and parallelism enabled by Elastic Schema are essential for AI agents that need to experiment and evolve data models autonomously at a massive scale.
This architecture is built for a future of agentic software development. The safety and parallelism enabled by Elastic Schema are essential for AI agents that need to experiment and evolve data models autonomously at a massive scale.
This unique, layered approach provides a powerful set of benefits that are impossible to achieve with a monolithic database.
The combination of a simple, unified API and type-safe SDKs allows your team to move faster. Developers spend their time building features, not wrestling with database complexity or writing boilerplate data access logic.
The Elastic Schema™ engine makes breaking changes literally impossible. You can evolve your data model, deploy new application versions, and roll them back with complete confidence, knowing that your data layer is always compatible.
By abstracting the storage engine, we eliminate vendor lock-in. You are free to choose the best cloud provider and database technology for your needs, and you can change your mind later without a costly migration project. This gives you long-term control over your architecture and your budget.
This architecture is built for a future of agentic software development. The safety and parallelism enabled by Elastic Schema are essential for AI agents that need to experiment and evolve data models autonomously at a massive scale.
This unique, layered approach provides a powerful set of benefits that are impossible to achieve with a monolithic database.
This layered architecture enables unparalleled deployment flexibility. You can choose the model that fits your needs today and switch tomorrow without rewriting your application.
For maximum speed and simplicity, StatelyDB can host the API and Elastic Schema layers on your behalf.
We manage the infrastructure, you connect your application to our secure endpoint, and you can choose which cloud, region, and storage engine you want to use. It is a fully-managed, zero-ops experience.
For organizations with strict data sovereignty and security requirements, you can run the StatelyDB data plane as a lightweight sidecar container inside your own cloud environment.
Your application talks to the local data plane, which connects to your own storage engine (e.g., a DynamoDB table in your AWS account). Your data never leaves your security perimeter. In this model, Stately Cloud provides a hosted control plane to manage schema configuration, but has zero access to your data.