One product model.
Every backend concern.
The product model on top: entities, permissions, workflows, custom logic, agents, surfaces — the things your product is built around. The running backend in the middle: data, APIs, rules, migrations, integrations, observability, operations — all derived from that model. The interchangeable substrate underneath: databases, caches, CDN, identity, models, runtime. Browse the full surface.
Every Vadyl invariant attaches to your product model, and every safe Vadyl plane can become a project-owned capability surface.
Your product inherits the platform
Every Vadyl invariant — branching, sandboxes, seven execution surfaces, governance, agents — attaches to your product model.
Project capability surfaces
The central parity rule: projects can author, publish, install, govern, observe, and expose the same capability planes Vadyl uses internally.
Projects & hierarchy
Nested projects with inherited governance, providers, policies, federation. Closure-table topology, ~30-axis envelope.
Coding workspace
Browser-native IDE that's a peer consumer of canonical APIs — same as the CLI.
CLI
Standalone console app. Same product model, same auth, same surfaces.
Where your entities become backend truth. Persistence, access, migrations, and cross-provider behavior all derive from it.
Entity Model
The product nouns — customers, orders, invoices, teams — that drive every backend layer.
Polyglot persistence
Relational, document, KV, graph, wide-column, time-series, vector — derived from one product definition.
Cross-provider operations
One product operation across provider boundaries. DAG planner, fan-out reads, in-memory hash join.
Transactions & compensation
Capability-driven 2PC vs saga. Priority-LIFO rollback. Three guarantee tiers.
Schema transitions
Product model changes become classified, checkpoint-resumable migrations with zero downtime by default.
Field security
Six-dimensional descriptor. AEAD envelope. Blind indexes. Tenant-scoped key derivation.
Access control & RLS
Row filters, field masks, attribute checks. Compiles native where supported, runtime where not.
Triggers & validations
Three-phase Gate / Pre / Post. Cross-field invariants. Trigger audit.
AI data
Native pgvector. Native Mongo time-series. Embedding pipeline. Capability-gated fallbacks.
How the product model reaches callers. Compiled APIs, realtime, webhooks, MCP, installable surfaces.
Compiled APIs
REST, GraphQL SDL + executor, gRPC, OpenAPI, MCP, typed SDKs — one product model.
Realtime subscriptions
WebSocket + SSE. Entity-indexed fan-out. Field names only — never values.
Webhooks
Outbound + inbound. 5-state delivery machine. HMAC over bytes. Public receiver keys.
MCP
Canonical projection through the same dispatcher as REST and SDK. Capability-grant filtered.
Installable surfaces
Provider projects publish versioned capability bundles across every plane. Consumer projects install with grants, audit, billing, revocation, and PCG evidence.
Actions, durable workflows, edge runtime, source assets, and governed connections attached to the same model.
Authored runtime
Seven canonical execution surfaces. Language-neutral runtime bridge. Capability-bounded by construction.
Durable workflows
Journaled steps, durable signal resume, LIFO compensation, deterministic ctx.now / ctx.random.
Edge runtime
Constrained execution surface for low-latency stateless logic. Build-time and runtime gated.
Scheduling
Cron / interval / one-shot triggers. Distributed locks. Per-project + per-definition concurrency caps.
Governed connections
Typed external integrations. Secret refs via key ring. Egress policy. Branch / environment overrides.
Source assets
Files and folders as first-class branchable entities. Content-addressed storage split.
Branching, versioning, project scaling, identity, auth, secrets, quotas, observability, explainability, the Plane Capability Graph.
Branching
Workspaces, real-DB sandboxes, immutable commits, three-way merge, 19 typed manifest domains.
Versioning & publications
Monotonic project publication, contract version, source commit. Seven-dimensional SDK taxonomy.
Project scaling
Manual scale, autoscale, load balancing, per-surface topology, vertical resources, and PCG-backed measures as one Runtime Fabric capability.
Templates
Project templates with adoption lineage. Never auto-upgrade — always explicit.
Federation
Per-entity directional grants between projects. Asymmetric. Time-bounded. Deny-by-default.
Identity
Eight entities, six services. JIT provisioning. MFA, refresh-token families, federation flows.
Auth
Foundational kernel: connectors, ActorContext, runtime-compiled policy, scope-chain merge.
Secrets
Key ring, secret references, rotation. config: and env: refs only — never raw strings on the wire.
Quotas & billing
Append-only usage ledger. Periodic rollups. Hard / soft / monitor enforcement.
Observability
Audit, operational, debug. OpenTelemetry. Source-transactional relay.
Explainability
Why decisions happened. Projected directly from canonical authorities — never log-scraped.
Plane Capability Graph
The unifying typed graph every plane contributes to. Content-hashed. Branching-aware.
Drift & health
Continuous reconciliation against declared state. Per-connector drift detection and health probes.
37 surface kinds across 7 families. The swappable substrate underneath your product model.
Capability surfaces
37 surface kinds across 7 families. Capability-aware execution lives here.
Database providers
Seven providers, four maturity tiers. Direct + cloud access plane separate from execution plane.
Storage
Multi-provider. Signed URLs. Multi-part upload. Capability declaration in 14 sub-interfaces.
Caching
Two-layer model. Post-enforcement only. AEAD-wrapped protected payloads. Real singleflight fill.
Distribution
Five vendor connectors. Real signed URLs. Tag-surrogate-key purge. Residency-aware.
Analytics
UMG compiler. Privacy gates. Lineage. Materialization. Reports / Dashboards / Models / Metrics.
Runtime fabric
Where authored handlers run and scale. ECS, Cloud Run, K8s, Nomad, Fly.io, and edge substrates as peer connectors.
Email & SMS
Transports as canonical surfaces. Vendor-neutral. Branchable bindings.
Custom connectors via WIT
Author connectors in Rust, Go, AssemblyScript, C, Python via Wasm Component Model.
Agents, automation, LLM routing, knowledge corpora — all consuming the same product model as the rest of the backend.
Agents
Native AI plane bound to the same product model, permissions, workflows, audit, and operations.
Automation
Declarative orchestration above every surface. Bounded typed AST. Synthesized durable workflows.
LLM routing
Capability-aware model selection. Tier requirements. Deprecation fallback policy.
Knowledge corpora & RAG
Embeddings, retrieval, immutable agent memory with supersession.
One canonical event substrate, with realtime and webhooks as the projection surfaces.
Cross-cutting optimization at every layer. No tuning required, no opt-in.
A backend that understands your product.
Start free. Define your first entity. Watch Vadyl turn the product model into a coherent backend — APIs, SDKs, validations, audit, observability — all from the same source of truth.