Weil dein Stack heute aus 20 Paketen besteht — und keines weiß vom anderen.
Dein Auth-Provider kennt deine Datenbank nicht. Deine Job-Queue kennt dein Schema nicht. Dein AI-SDK kennt deine Tenants nicht. Jede Zeile Klebecode dazwischen ist ein Bug in Warteposition, ein Deployment, das gleich kaputtgeht, ein Refactor, der dich beißen wird. Voltros Primitives teilen sich Runtime, Subject, Change-Feed, Migrationen. Du bist nicht mehr die Integrationsschicht.
Weniger Stack-Zusammenbau.
Mehr Produkt.
Reaktiv von Haus aus
Abonniere eine Query mit einem Hook. Die Runtime streamt jeden Write zurück über WebSocket — kein Polling, kein Refetch, kein manuelles Cache-Invalidieren. Auto-Optimistic gratis dabei.
Reaktive Queries →Multi-Tenancy als Primitive
Tenant-Isolation lebt im Schema, nicht in deinem Code. Cross-Tenant-Reads + Writes werden von der Runtime blockiert — nicht von Hoffnung. Row-Level Security gratis mit dem Mixin.
Multi-Tenancy →Durable Workflows
Langläufige Operationen überleben Deployments, Retries und Crashes. Gebaut auf @effect/workflow + @effect/cluster — kein Temporal, kein Inngest, keine separate Queue-Infrastruktur.
Durable Workflows →AI als Primitive
Agents, Tools, RAG, Streaming-Completions, Thread-Persistenz — alles erstklassig. Vercel AI SDK gewrappt hinter stabiler @voltro/ai-Surface, damit du Provider tauschen kannst ohne Code anzufassen.
AI-Primitives →Durchgängig typsicher
Effect Schema fließt von deinen Postgres-Tabellen bis zu deinen React-Components. Kein Codegen-Schritt, den du vergessen kannst. Mutation-Errors sind typed; der Client pattern-matcht sie.
Typsicherheit →Schema-DSL mit Mixins
Tabellen komponieren wie CSS-Klassen. audit() ergänzt createdAt + createdBy. tenant() ergänzt Isolation. softDelete() ergänzt schonende Löschungen. Eigene Mixins komponieren sich daneben.
Schema-DSL →Schema-getriebene UI
Der typisierte Descriptor IST das Formular. AutoForm bindet an eine Mutation, DataTable an eine Query — Felder und Spalten aus effect/Schema, Validierung und Live-Auto-Optimistic gratis. Plus Drop-in-Komponenten für Workflow, Presence und AI-Chat.
Schema-getriebene UI →Ein Schema, jedes SQL-Backend
Dieselbe App läuft auf Postgres, MySQL, MariaDB, MSSQL oder SQLite. Ein Query-Builder, ein Migrations-Planer, zur Laufzeit auf jeden Dialekt kompiliert — mit nativem Change-Data-Capture für die Reaktivität. Backend-Wechsel per Env-Var.
Datenbanken →Auth, eingebaut
Passwörter, signierte Cookie-Sessions, Passkeys, MFA, API-Keys und RBAC kommen mit dem Framework — kein Bolt-on. Eigenen IdP mitbringen, wenn nötig: sechs Adapter plus SAML und SCIM.
Auth →Adressiert drei Zielgruppen.
Gemacht für eine: Leute, deren Idee diese Woche live sein soll.
Agenturen & kleine Teams
Schluss damit, dasselbe SaaS-Gerüst bei jedem Kunden neu zu verdrahten.
Den Auth-Billing-Cron-Mail-Stack hast du dieses Jahr schon sechs Mal von Hand zusammengeschraubt. Voltro IST dieser Stack — geformt, getestet, dogfooded. Neue Kunden-App mit funktionierendem Dashboard, Multi-Tenant-DB, durable Jobs und E-Mail in unter einer Stunde aufgesetzt.
Agentur-Playbook ansehenStartups & Solo-Founder
Gebaut, damit du den Teil bauen kannst, der wirklich deiner ist.
Dein Wettbewerbsvorteil ist das Produkt, nicht die Migrationen. Voltro shippt jede Primitive, die eine echte SaaS braucht — und macht dann den Weg frei. Reaktive Listen für die Demo. Multi-Tenant für den ersten zahlenden Kunden. Durable Workflows für die erste Integration. Du zahlst für nichts davon technische Schulden.
Startup-Playbook ansehenEnterprise & regulierte Workloads
Audit-logged, tenant-isoliert, observable — ohne sechsmonatige Integrationsphase.
Gebaut auf Effect-TS-Internals (Microsoft / Block / Discord in Produktion). Multi-Dialekt Postgres-first mit Read-Replicas, vollständige OpenTelemetry-Traces, Row-Level Security via Tenant-Mixin, signierte Sessions, Rate-Limiting, Audit-Log-Plugin. Selber hosten via Helm heute; managed Voltro Cloud (dieselben Primitives) kommt bald.
Enterprise-Playbook ansehenEine reaktive, multi-tenant, typsichere Mutation
in 6 Zeilen.
Kein Klebecode. Kein Codegen-Schritt, den du vergessen hast. Die Mutation-Datei IST der Vertrag — typed Input, typed Output, deklariertes Target-Table für Auto-Optimistic-Patches, runtime-erzwungene 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.Gebaut für die langweiligen Sachen,
damit du die interessanten machen kannst.
Was Leute fragen, bevor sie installieren.
Warum intern Effect-TS?
Muss ich Effect im Anwendungscode benutzen?
Gehört mir meine Datenbank?
Warum Vite + React 19 statt Next.js?
Kann ich das ohne die Cloud betreiben?
Welche Datenbanken werden unterstützt?
Wie hoste ich das in Produktion?
Du kannst morgen eine funktionierende SaaS haben.
Oder du kannst ein Meeting dazu haben.
Ein CLI-Command, ein Postgres, ein Repo. Reaktive Listen, Multi-Tenant-DB, durable Jobs, Auth, Billing — alles verdrahtet. Docs öffnen, Quickstart folgen, Demo vor dem Mittag shippen.