Your backend should
understand your product.
A backend isn't just a database, some APIs, a few cloud services, and a pile of glue code. It's the actual things your product is built around: customers, orders, invoices, teams, subscriptions, workflows, permissions, events, and agents. Define them directly, and Vadyl turns them into data, APIs, logic, rules, migrations, integrations, observability, and operations that all stay connected to the same product model. When your product changes, the backend changes with it.
Current named customer
Define the things in your product.
Vadyl runs the rest.
A backend isn't a database, some APIs, a few cloud services, and glue code. It's the actual things your product is built around — customers, orders, invoices, teams, subscriptions, workflows, permissions, events, agents — and everything connected to them. Vadyl draws the line. You define the product model. The platform turns it into a running backend, all wired to the same definition.
The things in your product.
Customers, orders, teams, subscriptions, permissions, workflows, events, agents. The semantic shape of what you're building. One source of truth — every other layer is derived from this.
When you change the product model, every other layer follows.
Everything connected to it.
Data, APIs, logic, rules, migrations, integrations, observability, operations — all generated and kept coherent with the product model. Not stitched together. Not regenerated by hand. Connected by construction.
When the product changes, the backend changes with it.
Underneath, infrastructure is the swappable substrate — Postgres or Mongo, S3 or Azure Blob, CloudFront or Cloudflare, ECS or Kubernetes, OIDC or SAML, Anthropic or OpenAI. Vadyl branches on declared capabilities so your product model never branches on vendor. Change databases, clouds, identity providers, or runtime substrates — your product stays the same.
Your product gets the platform's invariants.
Once your product is defined, Vadyl wires it to the same operating plane the platform itself uses. Branching, sandboxes, audited deploys, canonical events, cross-provider rollback, agents bound to your model, observability and explainability for every decision — your product inherits all of it. Not a checklist of features to bolt on. Properties of being a Vadyl project at all.
Branchable everything, end-to-end
Schema, code, providers, federation, surfaces, agents — every typed manifest domain in the same DAG. Sandbox a change in a real isolated database. Three-way merge with semantic conflict detection.
Seven canonical execution surfaces
Core handlers, durable workflows, scheduled jobs, webhook receivers, event consumers, edge logic, management handlers — all wired, all governed, all capability-bounded by construction.
Scale every surface by intent
API ingress, handlers, consumers, jobs, webhooks, and realtime gateways carry canonical scale policy: manual count, autoscale rules, load balancing, resource class, CPU, memory, storage, and accelerators.
Compensation across every provider
Step 4 fails — Vadyl rolls back step 1, 2, and 3 across Postgres, Mongo, Stripe, SendGrid. No manual rollback scripts. Capability-driven 2PC where supported, saga LIFO everywhere else.
REST, GraphQL, gRPC, MCP, SDKs
Compiled from one canonical descriptor graph. Five SDK languages today — TypeScript, Python, C#, Go, Rust. The contract is the source of truth; every client tracks it.
Events that cannot drift from data
Mutations reserve event intent in the same lifecycle. Realtime, webhooks, automation triggers, and agent reactions consume the canonical PlatformEvent stream - projections, not parallel pipelines.
Agents that cannot lie
Same canonical state. Same access enforcement. Same audit. Typed plan IR — no raw shell, SQL, or filesystem. Capability-aware LLM routing. Token budgets enforced preflight + reconciled.
Explainability as a peer plane
Every product decision carries a typed reason code projected from canonical authorities — never log-scraped. The compile pipeline IS the explain pipeline.
Observability by construction
Audit trails, operational trails, debug traces, OpenTelemetry spans, handler runs, workflow steps, provider calls - every product action enters the same observability plane.
Field encryption, RLS, fail-closed
Six-dimensional field security descriptor. AEAD envelope with AAD-bound context. Access policies compile native where supported, runtime where not. Same outcome.
Atomic publications, locked workflows
Every project advance is a monotonic publication carrying a contract version + source commit. SDK manifest with seven version dimensions. Runtime check on the cross-layer compatibility seam.
Publish any safe plane as capability
Entities, CLI commands, workflows, agents, analytics, events, webhooks, auth, runtime policy - make it a Vadyl project surface and let other projects install with audit, grants, billing, and revocation.
Projects nest. Everything inherits.
Provider bindings, governance envelope (~30 axes), capability grants, auth policies, federation rules, cache bindings, secret references — all flow down the project tree. Closer-ancestor-wins for bindings; deterministic merge discipline for envelopes. Override what you must; inherit what you don't.
An IDE in your browser. Same APIs as the CLI.
Edit source assets, configure governed connections, inspect publication lineage, branch a sandbox — all through the same canonical APIs the CLI consumes. The workspace is a peer client, not a privileged authority. Monaco contract-projection bridge keeps types current as your model evolves.
Everything your product is.
Already wired up.
Your product is more than a data model. Entities are the things in it; policies are who can do what; workflows are the long-running parts; custom logic is the behavior; agents are the AI; surfaces are how it reaches the world. Define each once. Vadyl wires them to each other and to the running backend — all from the same definition.
Define your product once. Get the backend around it.
Describe what a Customer, Order, or Invoice means — fields, relations, who can access them. Vadyl creates the database tables, the typed API, the SDK, the access checks, the audit trail. No more keeping six definitions in sync.
defineEntity(({ name: "Customer", fields: ({ id: id(), email: email(unique()), }), relations: ({ orders: hasMany(Order), }), }))
Branch your backend like you branch code.
Try a schema change in a real isolated database. Open a PR. Review the migration plan. Merge with confidence — never dread a database change again.
Write code where it belongs.
API handlers. Long-running workflows. Scheduled jobs. Webhook receivers. Edge logic. Same SDK, same product entities, same auth — just drop the file in.
Use any database. Any cloud. Any service.
Postgres or Mongo. S3 or Azure Blob. SendGrid or Twilio. Vadyl keeps the wiring, secrets, and failover behind your product model — you write product logic.
AI agents that actually work safely.
Agents see the same entities, auth, and rules as the rest of the product. They can't hallucinate access. They can't blow past your budget. They show their work.
When this happens, do that.
Trigger on product events. Run on a schedule. Wait for approval. Send an email. Compensate on failure. Build complex flows visually without a parallel automation model.
Read moreThe backend changes with it.
When you add a field to Customer, rename a status on Order, tighten a permission, ship a new workflow, or swap a payment provider — that's a product change. Vadyl makes those changes safe by construction. Migrations don't break prod, sandboxes mirror reality, agents test your proposals before you merge, and when something fails across providers, Vadyl rolls it back.
Schema changes that don't take prod down.
Vadyl classifies every migration into 8 risk levels and picks the right execution path. Add a NOT NULL column on a 50M-row table? It expands, backfills with checkpoint-resumable batches, then contracts.
Sandboxes with a real database. Not a mock.
Every workspace can spin up an isolated copy of Postgres, Mongo, or Redis with a sample of production data. Test the migration. Run the new agent. Break things on purpose. Discard when done.
Agents test your proposal before you merge.
Open a PR. A Vadyl agent spins up a sandbox, replays last week's production traffic shape against your changes, and reports back — what broke, what slowed, what regressed. Reviewers see a real test report, not just a green checkmark.
Same contract. Different execution per provider.
Postgres has native row-level security? Vadyl compiles to that. The provider doesn't? Runtime enforcement kicks in. Same entity, same access policy — the platform picks the right execution path. You don't write the if/else. Vadyl does.
if (caps.security.supportsNativeRls) { return compileToNativePolicy(access); } if (caps.transitions.expandThenBackfill) { return buildBackfillPlan(diff); } // otherwise compose runtime + saga
When step 4 fails, Vadyl rolls back step 1, 2, and 3.
Crossing providers? Vadyl tracks every mutation and registers a compensation. If anything fails partway, it walks the chain backward — DELETE → UPDATE → INSERT — until the world is consistent again. No manual rollback scripts.
Merge backend changes with semantic conflict detection.
Schema, providers, federation, scheduling, webhooks, agents — 19 typed manifest domains, all branchable. When two PRs touch the same access policy or rename the same field, Vadyl surfaces the conflict before either lands.
Seven storage models. One product definition.
Your entities — the things in your product — don't pick the database. They define what they are. Vadyl picks the storage that fits, fans out across providers when needed, and absorbs the difference. Same Customer entity backed by Postgres, Mongo, or both. Same product model. Different physics under the hood.
Publish your project as a capability.
A Vadyl project that uses the full platform internally can publish selected entities, operations, CLI commands, workflows, agent skills, analytics, events, webhooks, and auth schemes as a versioned, scoped, billable, revocable surface. Other projects install it like a governed package.
Bring your own connector. Bring your own language.
Author capability-surface connectors in Rust, C, AssemblyScript, Go, or Python — any language that compiles to the WebAssembly Component Model. WIT contracts. Hermetic build. Canonical conformance. Indistinguishable from built-in native at the router.
TypeScript, Python, Go, Rust. Same product, same types.
When you write logic — an order handler, a billing workflow, an agent action — it talks to the same Customer, Order, Subscription that your product model defines. Strict types end-to-end. The SDK regenerates the moment your product changes; the compiler catches the gap before runtime does.
import { defineCoreHandler } from "@vadyl/sdk"; import { Order, Customer } from "@/entities"; export default defineCoreHandler(({ name: "createOrder", input: { customerId: string, items: OrderItem[] }, async handle(ctx, input) { const customer = await ctx.entities.Customer.findById(input.customerId); if (!customer) throw new NotFoundError("customer"); return await ctx.entities.Order.create({ customerId: customer.id, total: sum(input.items.map((i) => i.price)), status: "pending", }); }, });
Your code reads and writes through your product's typed entities — no raw SQL, no manual ORMs, no leaking secrets. The same access rules, the same validations, the same audit. Test in a sandbox. Deploy with the rest.
37 surface kinds. Your product never sees them.
Postgres, Mongo, Redis, S3, CloudFront, ECS, Kubernetes, OpenAI, Stripe, Twilio, your own Wasm extension — all the providers your product runs on, behind one canonical contract. Vadyl branches on declared capabilities so the product model never branches on vendor. Swap a database, change a CDN, move workloads, change instance shape — your product definition stays exactly the same.
Database
PostgreSQL · SQL Server · MongoDB · MySQL · Redis · Neo4j · Cassandra
Storage
S3 · Azure Blob · GCS · Local Disk · MinIO
Cache
Redis · In-Memory · KeyDB · Memcached
Distribution
CloudFront · Cloudflare · Azure Front Door · Fastly
Analytics
BigQuery · Snowflake · Databricks · Redshift
Runtime fabric
ECS Fargate · Cloud Run · Kubernetes · Nomad · Fly.io
SendGrid · Postmark · SES · Resend · SMTP
SMS
Twilio · Vonage · MessageBird · AWS SNS
Identity
OIDC · SAML · OAuth2 · Passkeys · Magic Link
Secrets
AWS KMS · Azure KV · GCP KMS · Vault · Doppler
Model inference
Anthropic · OpenAI · DeepSeek · Moonshot · vLLM
Connection adapters
HTTP · OAuth · SMTP · gRPC · LLM · KMS · Webhook
Agents that understand your product.
Most AI demos break the moment they touch real data. Vadyl agents see the same Customer, Order, Subscription you defined — bound to the same access rules, governed by the same policies, observable in the same audit trail. They can't leak what they shouldn't see, can't spend past your budget, and every action they take is traceable to the product model that produced it. They operate inside the backend's typed substrate, not around it through brittle tool calls.
export default defineAgent(({ name: "PricingOptimizer", model: { tier: "frontier", requires: ["tool-use"] }, budget: { maxTokens: 50_000, maxTurns: 20 }, memory: { scope: "project", persistent: true }, tools: [queryProducts, updatePricing], }));
Bound to your product model
Same entities, same access rules, same audit trail. Agents work on the real Customer, Order, Subscription — not a stale snapshot or a mock.
They can't escape your guardrails
Agents can only do what your access policies already allow. Roles, row filters, field masks — all enforced. The product's rules are the agent's rules.
Pick the right model automatically
Tell the agent it needs vision and tool use. Vadyl picks the best model from your providers. Switch any time without rewriting agents.
Hard budgets, every run
Set a token cap per definition or per call. Vadyl checks before the model call and reconciles after. No surprise OpenAI bills.
Memory that doesn't drift
Facts are versioned and superseded — never silently overwritten. Trace every recall back to where it came from.
MCP, ready to plug in
Connect Claude Desktop, Cursor, or any MCP client. Tools come straight from your product's API surface — filtered by what the agent is allowed to do.
A product vision with grounded proof.
Vadyl can describe the complete final-form platform while keeping customer and client claims anchored to the real relationship it can name today.
Neoterican
Vadyl gives Neoterican a backend that follows the product model instead of drifting into disconnected services. One definition reaches data, APIs, governance, and operations.
Real proof only
Customer logos, testimonials, and operating metrics appear only when they come from a real approved source.
Your product is one definition away.
Sign up free. Define your product: entities, permissions, workflows, agents, and surfaces. Watch Vadyl turn that definition into a running backend with APIs, SDKs, database tables, validations, and an audit trail in under five minutes. When the product changes, the backend changes with it.