Serverless SQL Database

Our distributed SQL database is built for the edge, offering global low-latency queries without the complexity of traditional database management.

SQL at the Edge

Traditional databases force you to choose between global distribution and SQL capabilities. Our serverless database eliminates this compromise, offering the familiarity and power of SQL with the performance of a globally distributed database.

By executing queries at the edge—close to your users—we dramatically reduce latency while maintaining strong consistency guarantees. This architecture enables a new class of applications that require both low latency and relational data capabilities.

With zero infrastructure to manage, automatic scaling, and built-in high availability, you can focus on building your application rather than managing database infrastructure.

Key Database Features

1 Serverless Architecture

No servers to provision, patch, or maintain. The database automatically scales with your workload and you only pay for what you use.

2 SQLite Compatibility

Full compatibility with SQLite, allowing you to use familiar SQL syntax and tools while benefiting from edge distribution.

3 Edge Execution

Queries execute at the edge location closest to the user, reducing latency and improving application responsiveness.

4 Automatic Backups

Scheduled backups are created automatically, with point-in-time recovery options to protect your data.

5 Prepared Statements

Support for prepared statements improves security and performance for frequently executed queries.

6 Batch Operations

Execute multiple operations in a single request to reduce latency and improve throughput.

Simple to UseJavaScript
Python
Go

                    // Example: Creating a table and querying data
export async function handleRequest(request, env) {
  // Access the database
  const db = env.DB;

  // Create a table (if it doesn't exist)
  await db.exec(`
    CREATE TABLE IF NOT EXISTS users (
      id INTEGER PRIMARY KEY AUTOINCREMENT,
      name TEXT NOT NULL,
      email TEXT UNIQUE,
      created_at TEXT DEFAULT CURRENT_TIMESTAMP
    )
  `);

  // Insert a user
  const stmt = db.prepare(
    `INSERT INTO users (name, email) VALUES (?, ?)`
  );
  await stmt.bind("John Doe", "john@example.com").run();

  // Query users
  const users = await db.prepare(
    `SELECT * FROM users ORDER BY created_at DESC LIMIT 10`
  ).all();

  // Return the results
  return new Response(JSON.stringify(users), {
    headers: { "Content-Type": "application/json" }
  });
}
                

How Our Database Compares

Feature	Traditional SQL	NoSQL	Our Edge SQL
SQL Support	✓	✗	✓
Global Distribution	Complex	✓	✓
Edge Execution	✗	Limited	✓
Server Management	Manual	Varies	None (Serverless)
Scaling	Manual	Semi-automatic	Automatic
Pricing Model	Instance-based	Throughput-based	Usage-based
Latency	High	Medium	Low

Performance Impact

Applications using our edge database typically see:

50-200ms reduction in query latency
Consistent performance across global regions
Elimination of connection overhead
Reduced backend complexity
Lower operational costs

These performance improvements translate to faster page loads, improved user experience, and higher conversion rates for your applications.

Seamless Integration

Our database integrates seamlessly with the rest of our technology stack, providing a unified experience across all your cloud services.

Key integrations include:

Direct access from edge functions without network hops
Built-in authentication and authorization
Event-driven workflows triggered by database changes
Automatic schema migrations during deployments
Integrated monitoring and logging

These integrations eliminate the complexity of managing multiple services and provide a cohesive development experience.