build fast, flexible, secure backends in minutes

format a reminder email with WebAssembly and send it with Mailchimp

log Stripe transactions to the database and save the Deno-formatted receipt in S3

It all starts with Clay

Claytip backends are written in Clay — a type-safe, declarative language that makes it easy to model your application. Once your model is set up, just build it with the Clay CLI and you have a production-ready GraphQL and REST server that can be exposed directly to clients. And with familiar APIs that simplify complex database concepts, you’ll be up and running in no time.

Just a text file

Clay files are regular text files that can be opened in your favorite text editor and are easily diffable by Git. There’s no need for a special tool for code review. Everything works with your regular flow.

The Clay language comes with all the features you'd expect: modules and imports, rich expressions, and precise types. No matter what language you're coming from, you'll feel right at home.

A solid core

Claytip automatically scales from serverless deployment to edge servers with intelligent scheduling and optimized query paths.

Claytip backends compile down to efficient and scalable Rust that’s ready to deploy anywhere. No need to worry about buffer overflow bugs or heavy memory usage, Claytip has it covered.

Bring your own DB

Claytip backends can run against existing, live databases so that you don't have to start from scratch.

If you're starting afresh, Claytip automatically maintains a human-readable schema that's compatible with your favorite data tools. Claytip even generates constraints that automatically clean up left over data.

Tooling designed for humans

The Clay CLI is always ready to help with detailed diagnostics that point out what went wrong with the context needed to fix it.

Clay even comes with editor integrations so you get warnings and errors right in your favorite IDE.

Toss in some services

Third-party APIs are first-class citizens in Claytip. Just like models, services have their own type-safe interfaces that make sure you're safely passing data between the database and APIs. Plus, Claytip makes it easy to hook into data events for auditing, sending emails, and more.

Baked into the language

Adding services is as simple as defining an interface in a Clay file and connecting to an implementation.

Just like models, services can have their own authorization rules, can connect to other models in the database, and can be exposed in the GraphQL layer.

JS and TS built right in

Claytip comes with a built-in execution system for JavaScript and TypeScript services, powered by the open-source Deno engine.

Need to use a custom algorithm for password hashing or talk to an API? Just write some JS and import it as a service in your Clay files.

Add your security model

Claytip backends are secure by design — no need to worry about SQL injection — and private by default — so nobody sees data they're not supposed to. Claytip security is baked into the language with authorization rules, ranging from broad rules across models to fine-grained rules for specific actions.

Secure to the core

All data in your models is private by default. To make data available to the right users, simply add authorization rules that specify who should have access.

Rules have a rich expression language that scales from simple role checks to complex queries like checking if a document has been shared. And context models let you flexibly store session data without bloating your API.

Efficiently private

Authorization rules are automatically compiled down to efficient SQL that is sent directly to the database. So queries have lower latency and send minimal data across the wire.

Authentication built in

Claytip comes ready with logic for common authentication patterns like using OAuth to issue JWT tokens. So you can get started right away without digging through docs.

And ship it to production

Once you're ready to ship your backend, use the Claytip CLI to compile your app down to a optimized, memory-efficient native binary that carries just the code needed to serve your API.

Blazing fast

Production Claytip servers are built with Rust so they use minimal memory and scale to high request rates.

At build time, the Clay CLI automatically generates an optimized binary representation of your data model that the server can efficiently process.

Serverless-ready

Claytip is perfect for serverless, with tiny binary sizes and optimized logic for the most popular platforms.

Clay backends are meticulously optimized and start in less than a millisecond, so you wont't pay any costs for boot-up time.