Because the stack you ship is already 20 packages — and none of them know about each other.
Your auth provider doesn't know your database. Your background-job queue doesn't know your schema. Your AI SDK doesn't know your tenants. Every line of glue you write between them is a bug waiting to happen, a deploy waiting to break, and a refactor waiting to bite. Voltro's primitives all share the same runtime, the same Subject, the same change-feed, the same migrations. You stop being the integration layer.
Less stack assembly.
More product.
Reactive by default
Subscribe to a query with one hook. The runtime streams every write back over WebSocket — no polling, no refetch, no manual cache busting. Auto-optimistic for free.
Reactive queries →Multi-tenant primitive
Tenant isolation is part of the schema, not your code. Cross-tenant reads + writes are blocked by the runtime — not by hope. Row-level security comes free with the mixin.
Multi-tenancy →Durable workflows
Long-running operations survive deploys, retries, and crashes. Built on @effect/workflow + @effect/cluster — no Temporal, no Inngest, no separate queue infrastructure.
Durable workflows →AI as a primitive
Agents, tools, RAG, streaming completions, thread persistence — all first-class. Vercel AI SDK wrapped behind a stable @voltro/ai surface so you swap providers without touching code.
AI primitives →Type-safe end-to-end
Effect Schema flows from your Postgres tables to your React components. No codegen step you have to remember. Mutation errors are typed; the client pattern-matches them.
Type safety →Schema DSL with mixins
Tables compose like CSS classes. audit() adds createdAt + createdBy. tenant() adds isolation. softDelete() adds graceful deletes. Your own mixins compose alongside them.
Schema DSL →Schema-driven UI
The typed descriptor IS the form. AutoForm binds to a mutation, DataTable to a query — fields and columns from effect/Schema, validation and live auto-optimistic updates for free. Plus drop-in workflow, presence, and AI-chat components.
Schema-driven UI →One schema, every SQL backend
The same app runs on Postgres, MySQL, MariaDB, MSSQL, or SQLite. One query builder, one migration planner, compiled to each dialect at runtime — with native change-data-capture driving reactivity. Switch backends with one env var.
Databases →Auth, built in
Passwords, signed-cookie sessions, passkeys, MFA, API keys and RBAC ship with the framework — not a bolt-on. Bring your own IdP when you need to: six adapters plus SAML and SCIM.
Auth →Pitched at three audiences.
Made for one: people who want their idea live this week.
Agencies & small teams
Stop re-wiring the same SaaS skeleton on every client project.
You've built the auth-billing-cron-email stack from scratch six times this year. Voltro is that stack, shaped, tested, and dogfooded. Spin up a new client app with a working dashboard, multi-tenant DB, durable jobs, and email in under an hour.
See the agency playbookStartups & solo founders
Built so you can build the part that's actually yours.
Your competitive edge is the product, not the migrations. Voltro ships every primitive a real SaaS needs — and gets out of the way. Reactive lists for the demo. Multi-tenant for the first paying customer. Durable workflows for the first integration. You don't pay tech debt for any of it.
See the startup playbookEnterprise & regulated workloads
Audit-logged, tenant-isolated, observable — without a six-month integration phase.
Built on Effect-TS internals (Microsoft / Block / Discord production). Multi-dialect Postgres-first with read replicas, full OpenTelemetry traces, row-level security via tenant mixin, signed sessions, rate-limiting, audit-log plugin. Self-host on Helm today; managed Voltro Cloud (same primitives) is coming soon.
See the enterprise playbookA reactive, multi-tenant, type-safe mutation
in 6 lines.
No glue. No codegen step you forgot to run. The mutation file IS the contract — typed input, typed output, declared target table for auto-optimistic patches, runtime-enforced tenant scope.
// Express + Postgres + Redis pub/sub + manual
// tenant guard + types on every step.
app.post('/posts', requireAuth, async (req, res) => {
if (!req.user.tenantId) return res.status(401).end()
const row = await db.query(
'insert into posts (tenant_id, body) values ($1, $2) returning *',
[req.user.tenantId, req.body.body],
)
await redis.publish(
`posts:${req.user.tenantId}`,
JSON.stringify(row.rows[0]),
)
res.json(row.rows[0])
})
// Then on the client:
useEffect(() => {
const ws = new WebSocket(...)
ws.onmessage = (ev) => setPosts(p => [JSON.parse(ev.data), ...p])
return () => ws.close()
}, [])
const create = (body) =>
fetch('/posts', { method: 'POST', body }).then(r => r.json())// One mutation file. Tenant guard, pub/sub,
// types, optimistic patches — all framework-managed.
export const createPost = defineMutation({
name: 'posts.create',
target: { table: 'posts', op: 'insert' },
input: Schema.Struct({ body: Schema.String }),
output: Post,
})
// posts.create.mutation.server.ts
export default async (input, ctx) =>
ctx.store.insert('posts', { body: input.body })
// On the client:
const { data: posts } = useSubscription('app', 'posts.list')
const create = useMutation('app', 'posts.create')
// Reactive list updates. Optimistic patch on every create.
// No glue. No codegen. No useEffect.Built for the boring stuff
so you can do the interesting parts.
What people ask before they install.
Why Effect-TS internally?
Do I have to use Effect in my application code?
Do I own the data?
Why Vite + React 19 instead of Next.js?
Can I run it without the cloud?
Which databases are supported?
How do I host it in production?
You can have a working SaaS by tomorrow.
Or you can have a meeting about it.
One CLI command, one Postgres, one repo. Reactive lists, multi-tenant DB, durable jobs, auth, billing — all wired. Open the docs, follow the quickstart, ship the demo before lunch.