Introducing Instant App Deployments in Partnership with Vercel

AI coding platforms let anyone create software from a prompt, but turning generated code into a deployed app is still a hard problem. Announcing Instant App Deployment, a new API built on Prisma Postgres and Vercel, that solves this problem.

The infrastructure problem nobody wants to readily solve

AI coding and no-code platforms all face the same hurdle: users build great apps, then stall when it comes to deployment.

Hosting is costly, complex, and far from your core focus cause you care about models, code generation, and UX, not Kubernetes and database scaling.

The result: users have working code but no clear path to a deployed application. Platforms must either take on heavy infrastructure themselves or risk losing users when they leave to deploy elsewhere.

How instant app deployment works

Instant app hosting provides a complete deployment solution through a single API call. When users click "Deploy" in a platform, here's what happens:

1. The platform calls the deployment API with the application code and configuration.
2. A Prisma Postgres database is provisioned with connection pooling and caching configured.
3. Vercel deploys the application across their global infrastructure, with the database automatically connected.
4. Users receive a production URL where their application is live. All in just a single action. Users can also claim the deployed application in their own Vercel account.

The entire process takes minutes, not hours. No configuration files, no DevOps knowledge required. It's an elegant setup from both the platform and the users perspective that removes friction on both ends.

Required ENV variables in .env:

// VERCEL_TOKEN – Create a Personal Access Token at
//   https://vercel.com/account/tokens
//   Example: VERCEL_TOKEN="vercel_pat_abc123xyz"
//
// TEAM_ID – From your Vercel Team Settings (not personal account).
//   Example: TEAM_ID="team_abc123xyz"
//
// INTEGRATION_CONFIG_ID – Prisma Integration Config ID.
//   Go to Vercel Dashboard → Team → Integrations → Prisma → Configure.
//   Copy the `icfg_...` part from the URL.
//   Example: INTEGRATION_CONFIG_ID="icfg_abc123xyz"

const { VERCEL_TOKEN, TEAM_ID, INTEGRATION_CONFIG_ID } = process.env;

const API = "https://api.vercel.com";
const PRISMA_PRODUCT_ID = "prisma-postgres";

const api = (path: string, body: any, method = "POST") =>
  fetch(
    `${API}${path}${path.includes("?") ? "&" : "?"}teamId=${TEAM_ID}`,
    {
      method,
      headers: {
        Authorization: `Bearer ${VERCEL_TOKEN}`,
        "Content-Type": "application/json"
      },
      body: body ? JSON.stringify(body) : undefined,
    }
  ).then(r => r.json());

Create project & Setup

const projectName = `demo-${Date.now()}`;
const project = await api(`/projects`, { name: projectName });

Authorize Prisma integration

const auth = await api(`/integrations/billing/authorization`, {
  integrationIdOrSlug: "prisma",
  productId: PRISMA_PRODUCT_ID,
  billingPlanId: "pro",
  metadata: JSON.stringify({ region: "iad1" }),
  integrationConfigurationId: INTEGRATION_CONFIG_ID,
});
console.log(`Prisma authorized`);

Provision Database & Connect

const db = await api(`/storage/stores/integration`, {
  name: `ppg-${project.name}`,
  billingPlanId: "pro",
  metadata: { region: "iad1" },
  integrationConfigurationId: INTEGRATION_CONFIG_ID,
  integrationProductIdOrSlug: PRISMA_PRODUCT_ID,
  authorizationId: auth.authorization.id,
  source: "marketplace",
});
console.log(`DB: ${db.store.id}`);

Deploy Application

await api(
  `/integrations/installations/${INTEGRATION_CONFIG_ID}/products/${PRISMA_PRODUCT_ID}/resources/${db.store.id}/connections`,
  { projectId: project.id }
);
console.log(`DB connected`);

Deploy

const deployment = await api(`/deployments`, {
  name: `deploy-${Date.now()}`,
  project: project.name,
  projectSettings: { framework: "nextjs" },
});
console.log(`URL: https://${deployment.url}`);

Transfer Code (claim link)

const transfer = await api(`/projects/${project.id}/transfer-request`, {});
console.log(`Claim: https://vercel.com/claim-deployment?code=${transfer.code}`);

To explore all the APIs for claiming a Vercel deployment, check out our guide or visit the official Vercel docs. You can also try out the live demo we’ve prepared.

Built for real production workloads

This isn't a sandbox or a demo environment. Every deployment is production-ready:

• Database included: Each deployment gets a Prisma Postgres instance with automatic backups, connection pooling, and global caching
• Global scaling: Applications run on Vercel's network with automatic scaling, performance optimizations, and zero-config CDN
• Zero configuration: Database connections, environment variables, and all config elements are automatically set up

The user claiming flow

Here's where it gets interesting. When users are ready to take ownership of their deployed application, they can claim it seamlessly. The entire deployment, both database and application, transfers to their own Vercel and Prisma accounts.

This solves a critical problem for platforms: you can offer instant deployments without being responsible for long-term hosting support or costs. Users get a working application they fully control, with their own billing and management. The claiming process ensures continuity, preserving the application state and data while transferring ownership cleanly to the user's accounts.

Perfect for modern development workflows

Whether you're building an AI assistant that generates full applications, a no-code tool for app development, or a teaching platform where students deploy projects, Instant App Deployment handles the infrastructure complexity.

Consider these use cases:

• AI-powered development: Users prompt an AI to build an e-commerce site. With one click, it's deployed with a real database, ready for customers.
• No code platforms: Drag-and-drop builders can offer instant deployment without building hosting infrastructure.
• Educational platforms: Students can deploy projects instantly, then claim them for their portfolios.
• Rapid prototyping tools: Transform ideas into deployed applications in minutes, not days.

Sounds interesting?

The future of application development is here. AI is making app development accessible to everyone, and this new API ensures that deployment is just as simple.

If you're building a platform that generates code, we want to work with you. Whether you're focused on AI-assisted development, no-code programming tools, or any other approach to application creation, the Instant App Deployment API can handle your deployment needs.

Ready to get started or have questions? Ping us!