The confidential backend

Your app's whole backend, like Firebase. Except nobody can read your data, not even us.

Auth, database, functions, realtime, storage and hosting in one deploy, running in hardware your users can verify.

Same dataWhat we can see
The same customer records seen by an operator: readable on a usual cloud server, redacted on a sealed Calimero node On a usual cloud server, an admin can read every record: emails, amounts, files. On a sealed Calimero node the same records are unreadable to everyone, including Calimero; the operator sees only health, CPU and memory. USUAL CLOUD SERVER CALIMERO · SEALED NODE alice@acme.com $12,400 bob@acme.com $8,950 payroll-q3.csv 214 KB contract.pdf signed ✗ ADMINS CAN READ IT ALL ✓ NOBODY CAN, INCLUDING US what an operator sees health ✓ · cpu 23% · mem 41%

Backed by

  • Khosla Ventures
  • NEAR
  • GSR Ventures
  • FJ Labs
  • Eniac
  • Hypersphere
  • Lyrik
  • Daedalus
  • Warburg Serres
  • Metaweb Ventures

The backend

Everything a backend needs, sealed.

Each piece runs inside the same attested nodes as your app, ships in the same signed package and goes live in the same deploy. There is no second service to trust with your data.

One signed package runs the whole backend on attested nodes A package signed by you, holding the app logic compiled to WebAssembly and its frontend, is deployed once to the app's cluster. Each of its three nodes runs in Intel TDX and serves auth, database, functions, realtime, files, search and hosting; the nodes stay in step through one replicated Raft log. Typed clients in TypeScript, Python, Swift and Kotlin reach the cluster over the sealed channel. .MPK PACKAGE Signed by you app logic · Rust → WASM frontend ABI · typed methods deploy once YOUR APP'S CLUSTER · EVERY NODE ATTESTED Node 1TDX Node 2TDX Node 3TDX Auth Database Functions Realtime Files Search Hosting · your frontend your app's code inside Auth Database Functions Realtime Files Search Hosting · your frontend your app's code inside Auth Database Functions Realtime Files Search Hosting · your frontend your app's code inside one replicated log (Raft) keeps every node in step Typed clients TS · Python · Swift · Kotlin sealed channel, after attesting
  • Auth

    Passkeys and keys

    Passkey sign-in for people, sessions, and scoped API keys for machines and agents.

    How keys are checked
  • Database

    Replicated app state

    Maps, sets, tables with indexes and rich text, replicated across attested nodes.

    Confidential Database
  • Functions

    Your code, sealed

    App methods written in Rust, plus compute jobs, timers and pipelines.

    Confidential Functions
  • Realtime

    Live events

    Live events and presence for everyone using your app.

    Event Bus
  • Storage

    Files and blobs

    Sealed file and blob storage beside your app's state.

  • Search

    Full-text search

    Full-text search over your app's data, without the data leaving the sealed nodes.

    Search & Retrieval
  • Hosting

    Your frontend, verified

    Your frontend is signed with the app and served from the same verified nodes.

    How it works
  • Typed clients

    Generated from your app

    TypeScript, Python, Swift and Kotlin clients generated from your app.

    Developers

Proof

Every answer comes with proof.

Every call to a Calimero app goes through the same three steps, so the proof doesn't depend on who runs the machines.

How a call is verified, enforced and proved Three lanes: your app or browser, a Calimero node in Intel TDX, and the key service. Verify: the client sends a fresh nonce, the node answers with its hardware quote, and the client checks it against the signed release. Enforce: the node sends its quote to the key service, which checks the image and only then releases the disk key. Prove: the client sends a sealed request and gets the answer back with a signed receipt it can check offline. Your app or browser mero-js · Python · Rust Calimero node Intel TDX · read-only image Key service releases disk keys 01 VERIFY fresh nonce hardware quote, bound to the nonce ✓ matches signed release 02 ENFORCE quote, at boot ✓ image matches disk key, only then no SSH · no shell 03 PROVE sealed request answer + signed receipt ✓ checks offline, later
  1. 01

    Verify.

    Every client checks the node's hardware attestation against a signed release before it sends a byte, then talks to it over a sealed channel to a key the hardware vouches for.

  2. 02

    Enforce.

    Disk keys are released only to nodes whose attestation matches the signed, read-only image: no SSH, no rescue shell. Inside, only the approved code touches your data.

  3. 03

    Prove.

    Every answer comes with a receipt signed by an attested key, so you, an auditor or a regulator can check it offline, at any time.

Each answer carries the node's signature over the app, the log index and a hash of the result, made with a key the node's hardware attestation vouches for. Keep it, hand it to an auditor, check it a year from now.

See the check: 12 lines of Python
import json, struct
from cryptography.hazmat.primitives.asymmetric import ed25519

r = json.load(open("view.json"))["receipt"]
u64 = lambda n: struct.pack(">Q", n)
msg = (b"calimero.receipt.v1\0" + r["app"].encode() + b"\0"
       + u64(r["index"]) + r["resultHash"].encode()
       + b"\0" + u64(r["node"]))
key = ed25519.Ed25519PublicKey.from_public_bytes(
    bytes.fromhex(r["key"]))
key.verify(bytes.fromhex(r["signature"]), msg)  # raises if altered
print("signature ok")  # signature ok

Run on the receipt shown here; change any field and it raises InvalidSignature. The key must be one that meroctl attest app lists for the app.

Signed receipt

my-kv · get("hello") · node 1 of 3

result
"world"
log index
3
result hash
09bf524d…77658237cc
node key
cf1c8afc…7df640fba6
key attested
yes · node 1
signature
valid

A real receipt from meroctl 1.0.0-rc.30 on a local three-node cluster with mock attestation. Calimero Cloud nodes run on Intel TDX.

Build

Write it in Rust, ship it in one package.

You write the app's state and methods. Replication, auth, storage and the sealed channel come with the platform.

  1. Start: meroctl app new gives you the KV Store reference app, contract and frontend.
  2. Run: meroctl local dev starts a local cluster, builds, uploads and rebuilds on save.
  3. Ship: meroctl app pack and meroctl app publish sign your package and publish it to Calimero Cloud.
apps/kv-store/logic/src/lib.rsView code ↗
use calimero_sdk::prelude::*;

#[app::state(version = 1)]
pub struct KvStore {
    items: UnorderedMap<String, String>,
}

#[app::event]
pub enum Event {
    Inserted { key: String, value: String },
    Updated { key: String, value: String },
}

#[app::logic]
impl KvStore {
    #[app::init]
    pub fn init() -> app::Result<Self> {
        Ok(Self::load())
    }

    pub fn set(&mut self, key: String, value: String)
        -> app::Result<()> {
        let event = match self.items.insert(&key, &value)? {
            Some(_) => Event::Updated { key, value },
            None => Event::Inserted { key, value },
        };
        env::emit(event, Audience::All)?;
        Ok(())
    }

    #[app::view]
    pub fn get(&self, key: String)
        -> app::Result<Option<String>> {
        Ok(self.items.get(&key)?)
    }
}

Replicated across attested nodes. No server code.

Where it runs

Start free. Move when you need to.

The same signed app runs on shared clusters, a dedicated cluster or your own Intel TDX hosts.

Shared

$0 to start

Request-based, on Calimero's shared clusters. Pay for usage beyond a monthly free allowance. No monthly minimum.

  • 1M mutations and 5M views free each month
  • 180,000 vCPU-seconds and 360,000 GiB-seconds free
  • 100,000 outbound requests free
  • 1 GB of app state and 5 GB of blobs free

Then $1.00 per million mutations and $0.20 per million views.

Start free

Dedicated

$1,200/month

A cluster for your apps only, provisioned and run by Calimero. No per-request, CPU or memory fees.

  • 3 nodes: 4 vCPU, 16 GB, 100 GB disk each
  • Extra nodes $0.55 per node-hour, billed per second
  • Usage on it is not metered
Ask for a dedicated cluster

Self-hosted

Talk to us

The same attested nodes on your own Intel TDX hosts, for data that has to stay on your premises.

  • The same signed build as on Calimero Cloud
  • Clients verify your nodes before they send anything
Book a walkthrough

Prices are in US dollars. The free allowance is per developer account. Full pricing and every meter.

Open source

The runtime is open source.

The node, the SDK and the protocol are on GitHub, with a full protocol reference you could reimplement a node from.

Ship the backend nobody can read.

Start free on a shared cluster, with no monthly minimum.