Data & content management, apps & websites, collaboration, and project management—one unified platform to build, market, and scale.
npx zelavis create my-appBuilt for your stack
One platform, end to end
No stitching third-party SaaS services together. Zelavis gives you auth, data, workloads, and hosting with zero compromise on ownership.
node:22-alpine> Gateway proxy active: localhost:4000 -> isolated:5173> Tenant isolation verified. 4 shards connected.db.forTenant("acme").documents.put({
id: "ord_102",
total: 420.00,
customer: "c_88",
status: "verified"
})cron("*/10 * * * *")POST /webhooks/stripe-checkoutworker.queue("reports", { concurrency: 4 })Apps
Create isolated projects with their runtime, version, services, and data boundary already locked. Every project runs in its own process envelope without touching the parent platform.
From app scaffolding to multi-model database design, auth rules, and background workloads—command Zelavis through native AI chat. Backed by deterministic contracts and generation leases so your AI never breaks production.
{
"project": "northstar",
"recipe": {
"name": "@zelavis/app",
"version": "1.0.4",
"locked": true
},
"runtime": {
"driver": "node-process",
"pid": 14920,
"envelope": "isolated"
},
"topology": {
"physical_shards": 4,
"virtual_ranges": 64,
"router": "hash(tenant_id)"
},
"gateway": {
"route": "/projects/northstar/*",
"auth": "crypto-token"
}
}The Assistant builds against typed Platform manifests. If an AI suggests an invalid field type or broken syntax, the platform contract compiler rejects it before it ever hits disk.
A project knows its parent, but never becomes it. Agent operations execute strictly inside the project’s sandboxed boundary, protecting the parent control plane and neighboring tenants.
Every change commanded conversationally appends to the deterministic event stream. View complete audit logs, replay state transitions, or roll back changes with one click.
Powered by an open responder contract. Use Anthropic Claude, OpenAI, or run completely offline with local Ollama models. Your data and credentials never leave your infrastructure.
Data without the seams
The event log is the single source of truth. Document, column, measure, and graph lenses stay close enough to intersect without moving data between disparate database engines.
{ id: "ord_102", customer: "c_88", total: 420.00, items: 2 }Click any lens below to view how the same write is projected without data duplication:
// Projected Document Lens
{
"id": "ord_102",
"tenant_id": "acme",
"customer": "c_88",
"total": 420.00,
"items": [{ "sku": "ZEL-10", "qty": 2, "unitPrice": 210.00 }],
"_version": 1,
"_cursor": "0000000000000001"
}Fewer seams. Clearer ownership.
Zelavis gives every project one boundary for its runtime, data, services, version, and lifecycle—without giving up the option to replace the physical engines underneath.
“The platform shell is a client of Zelavis—not the place where Zelavis happens.”
Every dashboard action maps to a stable endpoint and capability, so the exact same system remains open to coding agents, CLIs, automation scripts, and your own custom frontend.
Better together
The control plane and project runtimes work as one cohesive product without sharing one failure domain.
GET/POST /api/v1/projects/:id/*Every official Zelavis App routes stable virtual ranges across physical shards—even when they all live on one node. Scaling out simply redistributes shard placements rather than changing your application model.
Run anywhere
Small single-node installations and larger distributed fleets use the exact same sharded topology. Scaling out changes shard placements and replicas—not your application code or data model.
Explicit authority
Customer projects receive scoped runtime envelopes and services while the Platform Fabric retains node, placement, generation, and fleet authority. No child process can escalate privileges or compromise other tenants.
Extensible by design
Third-party and community packages extend validated, namespaced capabilities. Trusted core services define the schemas and privileged boundaries, preventing unauthorized runtime side-effects.
Typed Capability BrokerYours, all the way down
Keep the exact same developer and application model across your local workstation, a private VPS, and a multi-region distributed fleet.
Build with the whole platform
Every primitive is built to be independent, composable, and replaceable whenever you outgrow default conventions.
Long-running process orchestrator, project registry, server management, System Store, and Project Gateway.
Write once through documents API; project through document, column, measure, and graph lenses with swappable key-value storage.
Contracts, plugins, background workloads, endpoint-backed capabilities, and headless frontends loaded from static manifests.
Clear answers
Everything you need to know about self-hosting, architecture, and technology choices.
Zelavis combines the platform capabilities engineering teams usually stitch together from separate tools: backend-as-a-service (auth, database, real-time), CMS (schemas, entries, media), hosting control panels (domains, deployments, logs), and functions/workloads platforms. You can run the entire platform unified or embed specific subpaths.
Yes. Self-hosting is a foundational architectural requirement, not an afterthought or enterprise-only export. Zelavis is designed to host applications directly on your own VPS, bare-metal servers, or private cloud, with managed Zelavis Cloud offered as a seamless option.
No. The database storage engine operates over an ordered key-value boundary. While SQLite is the zero-config default, libSQL, RocksDB, and LMDB drivers are built in and operate behind the identical logical database API and multi-model projections.
Yes. Every official Zelavis App is physically and locally sharded from the moment of creation. On a single server, the virtual shard ranges simply colocate on one machine. When you scale horizontally, the platform moves shard placements rather than forcing an architectural rewrite.
The core runtime, Node process isolation, multi-model document/column/measure/graph projections, authentication foundations, background workloads, official @zelavis/ui dashboard, and native server hosting are implemented. Real-time multiplayer collaboration and team issue planning are committed roadmap milestones.