One project for your entire stack
A Next.js frontend and a FastAPI backend may feel like a single product to a user, but for engineers they’ve traditionally meant two different clouds, two workflows, and two deployment pipelines. Vercel Services, now in public beta, lets you run multiple frameworks inside one Vercel Project, bringing the whole stack under a single deployment model.
With services declared in a project, you get atomic deployments (frontend and backend ship or roll back together), shared preview URLs that reflect changes across all services, and internal service-to-service communication that never touches the public internet. Routing, builds, scaling, and the standard Vercel developer experience all extend to the backend pieces.
Declaring services and bindings
You compose services explicitly under a services key in vercel.json. Routing stays visible in the config: public traffic goes to the frontend, while a backend can be left with no public route at all, reachable only through an internal binding.
{
"services": {
"my_frontend": {
"root": "frontend/",
"framework": "nextjs"
},
"my_backend": {
"root": "backend/",
"entrypoint": "main:app"
}
},
// my_backend has no public route
// it is only reachable from my_frontend internally
"rewrites": [
{
"source": "/(.*)",
"destination": { "service": "my_frontend" }
}
]
}
The same configuration feeds the rest of the platform. The Deployments panel renders a services graph, Logs can be filtered per service, and the vercel dev CLI runs every service locally for a production-like environment.
The Deployments UI shows a graph of your project’s services.
For internal communication, a bindings key injects an internal URL into a consuming service. A binding named BACKEND_INTERNAL_URL, for example, gives the frontend a route to the backend over Vercel’s internal network, so frontend code can call the Python service without an internet round trip.
{
"services": {
"my_frontend": {
"root": "frontend/",
"framework": "nextjs",
"bindings": [
{
"type": "service",
"service": "my_backend",
"format": "url",
"env": "BACKEND_INTERNAL_URL"
}
]
},
"my_backend": { ... }
},
"rewrites": [ ... ]
}
export async function GET() {
const url = new URL("/users", process.env.BACKEND_INTERNAL_URL);
const res = await fetch(url);
const users = await res.json();
return Response.json(users);
}
This lets many independent services behave as one application wired together internally, rather than separate deployments you stitch across hosts.
Framework-aware compute and networking
Services lean on the same zero-config detection as frontends. FastAPI, Flask, Express, Hono, Go, and Rust backends are auto-provisioned from their framework. Django gets an extra optimization: static assets are detected automatically and served from the CDN. Services run on Fluid compute with autoscaling and Active CPU pricing, so you pay for execution time, not idle connections.
The backend story continues with primitives that sit alongside services in the same platform:
- Sandboxed agents: Vercel Sandbox gives each agent its own Linux environment with a filesystem, shell, Docker support, and isolated kernel. It can run commands or spin up Redis and Postgres without touching production. Automatic persistence carries state between sessions, and Pro projects can run sandboxes for up to 24 hours.
- WebSockets: Vercel Functions handle persistent connections in Node.js, Python, or Go runtimes, working with standard libraries like Socket.IO.
- Short-lived credentials: Vercel Connect replaces long-lived secrets with runtime-scoped, short-lived credentials for reaching external services like Slack, GitHub, or managed databases.
- Data and storage: Databases from Neon, Supabase, and AWS (Aurora PostgreSQL, Aurora DSQL, DynamoDB, OpenSearch Serverless) are provisionable from the Marketplace, with credentials injected. Vercel Blob covers object storage.
- Background work: Queues handle jobs off the request path, Workflow manages durable multi-step processes, and Cron runs scheduled tasks.
- Private connectivity: Secure Compute, static IPs, and VPC peering reach private databases and internal networks.
For compute limits, Functions run up to 30 minutes on Pro and Enterprise, and Python backends can deploy with up to 500 MB of dependencies.
A single home for everything you ship
By bringing frontend, backend, and supporting services into one project, Vercel Services makes them build, preview, deploy, and roll back together, communicating internally by default. With compute, data, queues, workflows, cron, secure networking, and sandboxed agent environments already on the platform, the full stack now has one home to live in.
