ScalixNova

Serverless PostgreSQL with database branching, point-in-time recovery, scale-to-zero, and a query firewall

Overview

ScalixNova is a serverless PostgreSQL engine built from the ground up. It separates compute from storage, enabling database branching, point-in-time recovery, scale-to-zero, and zero-downtime scaling. It's wire-compatible with PostgreSQL, so you connect with the driver and tools you already use.

Isolation & tenancy

Every ScalixNova database is isolated per tenant. There are two tiers:

Tier	Isolation	Best for	Availability
Shared (default)	Each database gets its own PostgreSQL role (`NOSUPERUSER`), its own database, SCRAM authentication, a SQL firewall, and TLS — running on shared compute.	Most workloads — highest density, lowest cost.	Generally available
Dedicated	The database runs in its own hardware-isolated microVM (dedicated kernel, isolated CPU/memory/network). Hardware-level isolation.	Regulated data, noisy-neighbour-sensitive, and sovereign-cloud workloads.	On the roadmap — contact the team for early access

A "sandbox" is not a database tier. In Scalix, a sandbox is a compute microVM for running code. Databases are Shared or Dedicated — never "sandboxes".

PostgreSQL versions

Choose the PostgreSQL major version when you create a database — 16 (default), 17, or 18:

bash

curl -X POST https://api.scalix.world/v1/databases \
  -H "Authorization: Bearer $SCALIX_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "name": "prod", "pg_version": "18" }'

Omit pg_version to get the default. Unsupported values return a 400 that lists the supported set. See the version support policy for support timelines.
The version is fixed for the life of the database. Branches and point-in-time restores always run the same major as the database they came from.
All pre-installed extensions (pgvector, pg_trgm, uuid-ossp, and the contrib set) are available on every supported version.
The Dedicated tier currently runs PostgreSQL 16 only.
In-place major upgrades aren't offered yet — to move majors, create a new database on the target version and migrate with pg_dump or logical replication.

Quick Start

Query your database via the CLI:

bash

scalix-cloud db query "SELECT NOW()"
scalix-cloud db tables

Or via the SDK (available today):

typescript

import { executeSql } from "@scalix-world/sdk";
 
const opts = {
  headers: { Authorization: `Bearer ${process.env.SCALIX_API_KEY}` },
};
 
const { data, error } = await executeSql({
  ...opts,
  body: { query: "SELECT NOW()" },
});

Connect with any Postgres client

ScalixNova speaks the native PostgreSQL wire protocol — connect with psql, node-postgres, psycopg, Prisma, Drizzle, or any standard driver using the connection string from your console or the API. TLS is required; there's no proprietary driver to install.

See Connecting for connection strings and per-driver examples.

Features

Branching

Create a full, isolated copy of your database, restored from its durable backup to a point in time you choose. Restore time scales with database size:

bash

curl -X POST https://api.scalix.world/api/v1/tenants/$TENANT_ID/timelines/$TIMELINE_ID/branch \
  -H "Authorization: Bearer $SCALIX_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{}'

Branching is LSN-based: pass branch_lsn in the body to branch at a specific LSN, or omit it to branch at the latest LSN. To recover to a wall-clock timestamp instead, use the separate PITR restore operation (POST /api/v1/tenants/{tenant_id}/pitr/restore).

Each branch is restored from the parent's durable backups and served by its own compute worker — fully isolated from the parent. Use branches for:

Feature development with production data
CI/CD test isolation
Schema migration testing

Point-in-Time Recovery

Restore to any archived point within the retention window (default 7 days). WAL is archived on a five-minute bound while the database is active, so the most recent restorable point is typically within five minutes of your latest write — see Backups. These are two distinct operations: restore by timestamp (or to the latest recoverable point) with the PITR restore endpoint (POST /api/v1/tenants/{tenant_id}/pitr/restore), or branch the timeline at a specific LSN (branch_lsn) for isolated recovery.

Scale to Zero

Compute suspends when your database is idle — you pay nothing while it sleeps — and resumes in milliseconds on the next query. No replicas to keep warm, no idle bill.

Query Firewall

The query firewall inspects and controls SQL execution:

Block DDL operations for read-only keys
Enforce query timeouts
Restrict table access per API key

Connection Pooling

Built-in connection pooling at the gateway layer. No need for PgBouncer or external poolers.

Architecture

ScalixNova separates compute from durable storage. Because storage is decoupled from the database engine, you get isolated branching, point-in-time recovery, and zero-downtime scaling — without managing replicas, snapshots, or backup jobs yourself.