Your product inherits the platform.
Vadyl is product-first. You define the things your product is built around; Vadyl turns them into a running backend. The platform's invariants — branching, sandboxes, the seven execution surfaces, project scaling, cross-provider compensation, governance, observability, explainability, agents — attach to that product model the moment it exists.
What your product gets for free, before you write a line of code.
Every project on Vadyl is a first-class participant in the same canonical operating plane as the platform. The invariants extend through your entities, handlers, workflows, permissions, integrations, and agents.
Branching, end-to-end
Your schema, code, providers, federation, surfaces, agents — every typed manifest domain in the product model — branchable in the same DAG as Vadyl itself.
Real-database sandboxes
Devs spin up isolated copies of Postgres, Mongo, Redis with sampled production shape. Test the migration, run the agent, throw it away when done.
Seven execution surfaces
Core handlers, durable workflows, scheduled jobs, webhook receivers, edge logic, event consumers, management handlers — all wired, all governed.
Project scaling
Manual scale, autoscale, load balancing, per-surface topology, vertical resources, PCG measures, and runtime budgets are inherited as project capabilities.
Cross-provider correctness
Saga compensation across Postgres, Mongo, Stripe, SendGrid — automatic. Step 4 fails, steps 1-3 roll back. No manual rollback scripts.
Compiled APIs in five languages
REST, GraphQL, gRPC, OpenAPI, plus typed SDKs in TypeScript, Python, C#, Go, Rust — generated and version-pinned the moment you change the model.
Agents you can audit
Your agents see the same product model as the rest of the backend. Same access policies, same governance. Typed plan IR. Token budgets. Show their work.
Observability by construction
Audit trails, operational trails, debug traces, OpenTelemetry — your handlers, mutations, and product decisions all flow through the canonical relay automatically.
Explainability as a peer plane
Every product decision carries a typed reason code projected from canonical authorities. Not log-scraped. Not paraphrased. The truth.
Governance without ceremony
Field encryption, RLS, fail-closed access, capability grants, descendant envelopes, federation rules — applied everywhere your data flows.
Versioning that holds
Atomic project publications, locked workflow versions, contract-version-pinned SDKs, generated-format compatibility checks at runtime. Rollbacks are first-class.
CLI, SDK, IDE — same canon
The CLI, every language SDK, the in-browser coding workspace, MCP — all peer consumers of the same canonical surfaces. No second authority anywhere.
Capability surfaces, plug-and-play
Swap Postgres for SQL Server. Swap CloudFront for Fastly. Swap Anthropic for OpenAI. The platform branches on declared capabilities — your code doesn't change.
Every domain your product touches
Pre-wired with auth, audit, capability bounds
Across 7 families. Use any. Ship custom.
TypeScript, Python, C#, Go, Rust
The platform's capabilities become your project's capabilities.
Vadyl does not stop at giving you built-in modules. The same planes Vadyl uses internally can be authored, projected, published, installed, governed, observed, and explained by projects.
Your own CLI surfaces
Projects can publish governed command groups, not just use the official vadyl CLI. Installed commands keep typed flags, output contracts, exit codes, audit, grants, and usage records.
Your own workflow and automation surfaces
Durable workflows, scheduled handlers, event triggers, automation actions, and management handlers can be packaged for other projects to install.
Your own agent and MCP surfaces
Agent skills, prompts, tools, resources, and memory scopes can project into MCP and SDKs through the same exposure binding model.
Your own analytics surfaces
Measures, metrics, dashboards, reports, materializations, and lineage become publishable PCG nodes with governed consumption.
Your own event and webhook surfaces
Event vocabularies, realtime channels, webhook topics, subscription filters, and receivers can be installed without inventing a side-channel.
Same governance envelope
Publish, install, grant, consume, bill, revoke, and explain all flow through ProjectCapabilitySurfaceManifest, InstallationManifest, ProjectCapabilityGrant, and PCG evidence.
Your product, on day one
You define an entity. Vadyl compiles the database tables, typed REST routes, GraphQL types, gRPC contracts, OpenAPI spec, SDKs, access checks, and audit trail. One product noun. Every backend projection in sync.
You write a handler. It runs on a canonical execution surface — capability-bounded by construction. Runtime Fabric decides how that surface scales, which resources it receives, and how it is exposed. It reaches product data through the runtime bridge (never raw DB) and external systems through governed connections (never arbitrary egress).
You open a PR. A Vadyl agent spins up a sandbox with sampled production shape, replays last week's traffic against your changes, and reports what broke, what slowed, what regressed. Reviewers see a real test report.
You ship. Migration plan classified into one of six zero-downtime strategies. Expand-then-backfill, compatibility window, shadow copy cutover — Vadyl picks the right execution path. You don't write the if/else.
Something fails in production. Step 4 of a cross-provider mutation errors out. Vadyl walks the saga LIFO — DELETE → UPDATE → INSERT — until the world is consistent again. The audit log shows exactly what compensated. The explainer shows exactly why.
You publish a surface. Your project becomes a capability provider for other Vadyl projects - versioned, scoped, billed, revocable. Your email service, payments service, internal accounting service, command set, analytics pack, agent skill library, workflow package, or event vocabulary becomes a first-class platform participant.
This is the difference between wiring backend pieces together and defining the product the backend is supposed to understand.
Build on the same plane we built on.
A free Vadyl project gives you everything above. Define a product entity to get started — the backend begins from there.