What's New on DigitalOcean App Platform

Welcome to What’s New on DigitalOcean App Platform— your weekly roundup of the latest updates for App Platform. Here, we’ll share new feature releases, technical tutorials, or video walkthroughs to help you stay ahead of the curve and keep building. Check back regularly for new insights and inspiration, or get started now: Deploy Your First App on App Platform

Week of November 17th

Product Update Migrating to DigitalOcean App Platform: A Guided, AI-Assisted Start

PaaS platforms have made deploying modern applications seamless. But as applications mature, many teams look for predictable costs, flexibility in composing multi-services applications, and simpler infrastructure control, without sacrificing developer experience.

That’s where DigitalOcean App Platform comes in.

We designed an App Platform to let developers “bring their code, any way they want,” while managing everything from scaling to SSL, databases, and global CDN, all in one place. Recently, we’ve added AI-assisted tooling to make it easier for developers (and AI coding assistants) to help with migrations.

This post explains the conceptual foundation of App Platform and how developers can collaborate with AI assistants (like Claude Code, Cursor, or Gemini) to migrate apps step-by-step, and with the human still in control. This process uses a detailed migration guide, which you can find on GitHub (https://github.com/digitalocean-labs/mcp-digitalocean/blob/main/pkg/registry/apps/docs/vercel-migration-guide.md) . It’s designed to be fed directly to an AI assistant, supporting various scenarios, whether you’re migrating a live Vercel app, deploying from just a GitHub repository, or even starting from local source code.

App Platform in a Nutshell

App Platform lets you run multiple apps, each composed of components or resources. An app may contain a static site, a backend web service, functions or background workers, and cron jobs.

Each component scales independently and runs inside managed containers. You only pay for container instances and bandwidth, no hidden infrastructure costs.

Developers can deploy to App Platform through several input paths.

From there, you can choose to:

• Auto-deploy directly from Git or your container registry

• Integrate App Platform into your CI/CD pipeline through APIs

Every App Platform deployment is defined by a simple YAML file called an AppSpec. The AppSpec defines your entire app architecture: components, databases, routes, environment variables, in one declarative file. Two deployment models are supported:

1. Git-based (Pull Model)

• App Platform watches your repo and auto-deploys on code changes

• AppSpec is managed internally—you don’t need to include it

2. API/CI-based (Push Model) for CI/CD pipelines and automation

• You control deployments via CLI or API

• You must provide your AppSpec file

🤖 AI-Assisted Migration: Vercel → App Platform

While migrating from Vercel or similar platforms isn’t instant, our new AI-assisted instructions streamline the process. This “co-pilot” approach combines automation with human validation, offering a balance of control and convenience.

What the AI Assistant Does

• Analyzes your repository

• Generates a draft AppSpec YAML

• Detects common build or run issues

• Suggests fixes automatically (up to three retry attempts)

• Creates configuration for environment variables and databases

What You Do

• Verify and test builds locally

• Provide or confirm environment variables

• Approve configuration updates

• Validate deployments and DNS changes

This ensures accuracy without losing ownership of your app.

🚀 How to Get Started

Before you begin, you’ll need a DigitalOcean App Platform account and, ideally, the doctl command-line tool installed and authenticated. Having the MCP setup is a plus. These are the primary ways the assistant will interact with your account.

The migration guide supports several starting points, and the AI assistant will help you determine the best path:

• Scenario A: Full Vercel Migration: You have a live Vercel app and Vercel account access. The assistant will use the vercel CLI to pull environment variables and settings.

• Scenario B: Repository-Only: You just have a GitHub repository (it might be on Vercel, or not). This is simpler and doesn’t require Vercel credentials.

• Scenario C: Local Source Code: You have code locally and want to get it on App Platform, with the assistant helping you create a new repository.

Note on MCP Servers: You might see references to “MCP servers” in the guide. These are optional and not required for users. The doctl and gh CLIs are the primary tools used for the migration.

To start, simply find the “Vercel to App Platform Migration Guide” (available on the DigitalOcean-Labs GitHub) and load it into your AI assistant. Then, state your goal, like: “Help me migrate my app to DigitalOcean App Platform using this guide.”

🔍 A Typical Migration Walkthrough

Step 1. Local Testing

Before deployment, test locally:

pnpm install pnpm build

This catches build or dependency issues early, saving multiple failed deployment attempts.

Step 2. Generate App Spec

Example AI-generated configuration for a Next.js SaaS app:

name: my-saas-app region: nyc1

services:

• name: web github: repo: yourname/your-saas-app branch: main deploy_on_push: true source_dir: / build_command: “” # auto-detect run_command: “” # auto-detect http_port: 8080 instance_size_slug: basic-xxs envs:
  • key: DATABASE_URL value: ${db.DATABASE_URL}
  • key: STRIPE_SECRET_KEY value: “sk_live_…” type: SECRET

databases:

• name: db engine: PG version: “18”

App Platform buildpacks automatically detect the framework, no manual commands needed.

Step 3. Deploy and Troubleshoot

doctl apps create --spec app-spec.yaml

If something fails (e.g., missing lockfile or port error), the AI assistant reads logs, proposes corrections, and redeploys—while you stay in the loop.

** 🧱 Multi-Component Deployments**

App Platform shines when hosting multiple services together:

monorepo/ ├── apps/web # Frontend ├── apps/api # Backend └── worker # Background processor

Each runs as a separate component in one app, sharing databases and internal networking—no need for Kubernetes.

🔄 What Migrates Smoothly

✅ Next.js, React, Vue, Express, Python, Go, and Rails

✅ API routes (/api/*)

✅ Managed PostgreSQL and Redis (ValKey)

✅ Encrypted environment variables

✅ Custom domains with automatic SSL

✅ Native background workers and cron jobs

✅ Git-based deployments with preview URLs

⚠️ What Needs Human Touch

Some Vercel-specific features need adaptation. The AI assistant will identify these, but you will need to implement the changes.

💾 Database Migration

Schema migration is straightforward—but data migration is manual by design:

Export from Vercel pg_dump $VERCEL_DATABASE_URL > backup.sql

Import to App Platform psql $APP_PLATFORM_DATABASE_URL < backup.sql

This ensures you retain full control of production data integrity.

🧭 Rollback Plan

Before updating DNS:

• Test thoroughly on the .ondigitalocean.app URL

• Keep the original app live during propagation

• Document rollback steps (DNS, deployment, or code revert)

Rollback is as simple as reverting DNS or redeploying a previous version—App Platform keeps the last 10 deployments for one-click recovery.

💡 When to Use This Approach

This guided process works best for:

• Standard frameworks (Next.js, React, Express)

• Straightforward build pipelines

• Teams comfortable with basic DevOps commands

• Apps not reliant on Vercel-exclusive features

It is less ideal for:

• Heavy edge function usage

• Complex, multi-region architectures

• Apps requiring custom caching or GPU workloads

✨ Why AI Assistance Matters

Without AI, migration means reading multiple docs, manual YAML, guessing errors, and managing retries.

With AI, you get a guided workflow, automated error diagnosis, safe retries with explanations, environment variable mapping, and rollback instructions. AI amplifies your expertise; it doesn’t replace it.

Whether you’re moving an existing app or starting fresh, App Platform gives you the simplicity of a managed PaaS and the flexibility of modular components—without the hidden complexity.

To get started with running your Vercel App on App Platform, use our work-in-progress markdown instructions (https://github.com/digitalocean-labs/mcp-digitalocean/blob/main/pkg/registry/apps/docs/vercel-migration-guide.md).

Week of October 6th

Product Update DigitalOcean now supports Cron Jobs

Great news: support for Cron Jobs, a highly requested feature for DigitalOcean App Platform, is now in general availability.

This new capability allows you to automate essential and repetitive tasks in your deployed applications, bringing classic Unix scheduling power directly into our modern Platform-as-a-Service (PaaS) environment.

Cron Jobs saves you time and helps ensure operations run predictably and efficiently so you can focus on building.

The Power of Automation for Your App

Until now, running scheduled tasks in deployed apps often required setting up a separate Droplet or a third-party service. The new Cron Job component is designed for any process that needs to run regularly in the background, unlocking powerful automation for common application needs, such as:

• Running nightly database backups

• Cleaning up old data

• Sending daily notifications or reports

You can schedule jobs to run automatically at fixed intervals, whether every 15 minutes, daily at midnight, or on a custom schedule using Cron expressions.

With Cron Jobs you can keep your Droplet running — just add an App Platform Cron Job for your periodic tasks. If all you need is a single Cron Job and nothing else, you can now spin up an App Platform app with just one Cron Job component.

How to get started

DigitalOcean App Platform Cron Jobs leverage the standard cron expression format, giving you granular control over when your code executes.

You can configure your Cron Jobs by following these steps:

1. In the Apps section of the DigitalOcean Control Panel, select your app, then click the Create drop-down and choose Create Resources From Source Code to add a Job.

2. On the Choose a deployment source screen, select the code repository service your app resides on. If you have not previously created an app on App Platform, the repository service prompts you to provide DigitalOcean with read permissions to your account.

Select the app’s repo from the Repository drop-down and then select the branch to deploy from in the Branch drop-down menu.

3. Once you have selected the app’s repo and branch, click Next. App Platform retrieves your app’s code. App Platform inspects the code and app resources, and selects an appropriate runtime environment (such as Node, or Ruby). If you need to override this, upload a Dockerfile to your branch and restart the app creation process.

See our How to guide for more detailed instructions.

Note that App Platform enforces a minimum execution frequency of every 15 minutes (*/15 * * * *) to ensure optimal platform performance. You’re only billed for the time that the job runs.

Get started today

Whether you need to run a script once a day or four times an hour, CronJobs makes it simple.

Clone this template to get started with a real-life backup CronJob example; or, log-in to App Platform to start automating your application’s maintenance and background tasks today.

Looking to dive deeper into configuration, view job invocations, or explore examples? Check out our full documentation.

Week of September 23rd

Product Update Deploy Lovable.dev Apps to Production with App Platform

DigitalOcean App Platform now supports a new, streamlined workflow for deploying applications built on Lovable.dev directly to DigitalOcean App Platform. This integration bridges the gap between building an application with natural language and launching it in a secure, production-grade environment, allowing you to move from idea to live application in minutes without complex configuration.

What’s new

• Direct Lovable.dev Integration: Now you can seamlessly deploy applications built on Lovable.dev to DigitalOcean App Platform. App Platform supports the common Lovable.dev technology stack of Vite/React for the frontend and Supabase for the backend.

• Automated Deployment Pipeline: By connecting your Lovable project’s GitHub repository to App Platform, you create a fully automated deployment pipeline. Every code change or feature addition made in Lovable is synchronized with GitHub and can be set to auto-deploy on our platform with zero downtime.

Benefits

• Go from AI to Production Instantly: Bridge the crucial gap between an AI-generated application and a live, scalable website. You can focus on building features in Lovable, knowing a clear deployment path is waiting for you.

• Experience Zero-Configuration Deployment: App Platform’s built-in Node.js buildpack automatically detects and builds your Vite/React application without requiring you to write any Dockerfiles or YAML configuration files.

• Access Production-Grade Features: Your Lovable app benefits from App Platform’s robust, managed infrastructure. This includes built-in HTTPS, a global CDN, health checks, and zero-downtime deploys right out of the box, making production-level features accessible even to non-coders and first-time users.

How to get started

Step 1: Build Your App on Lovable.dev

• Create and refine your application using Lovable’s natural language interface. Lovable automatically handles version control by synchronizing your code with a GitHub repository.

Step 2: Prepare Your Application for Deployment

• Before deploying, ensure your application’s secrets, like Supabase credentials, are not hardcoded in your source code. Your application should be configured to use the environment variables VITE_SUPABASE_URL and VITE_SUPABASE_ANON_KEY.

Step 3: Deploy to DigitalOcean App Platform

1. Navigate to the DigitalOcean App Platform page and click “Create App”.

2. Select your Lovable project’s repository from GitHub.

3. App Platform will automatically detect your project as a Node.js application. You can deploy it as a Web Service or, if it’s a frontend-only app, change the component type to Static Site.

4. In the configuration settings, add your environment variables: VITE_SUPABASE_URL and VITE_SUPABASE_ANON_KEY with the corresponding values from your Supabase project.

5. Click deploy. App Platform will handle the build process and launch your application.

For a complete, step-by-step tutorial, check out our video guide covering the entire process from building an application in Lovable to deploying it on App Platform.

Resources

• DigitalOcean App Platform

• Lovable.dev

• App Platform Documentation

Week of September 15th

Product Update Outbound VPC for App Platform is now Generally Available

DigitalOcean App Platform now supports outbound VPC integration, enabling your apps to connect privately to databases, Droplets, and other resources across any region through VPC-to-VPC peering. This eliminates the need for public internet connectivity and creates secure, performant private network architectures at scale. Now, you can deploy multi-tier applications with confidence, knowing that your data layer remains completely isolated from external networks while maintaining the simplicity and scalability that makes App Platform powerful. This capability is transformative for digital-native enterprise (DNE) workloads, microservices architectures, and any application requiring enhanced security controls.

What’s new

• Outbound VPC connectivity for apps – Attach an App Platform app to a VPC in its region so your code talks to private services (Droplets, Managed Databases, DOKS nodes) over private IPs.

• Cross-region private access with VPC peering – Peer your app’s regional VPC to VPCs in other regions and keep traffic private end-to-end, even when the resource lives elsewhere.

• Simple, spec-first configuration – Add a vpc.id to your app spec by following the steps below and redeploy.

• General availability – Available today for all regions except ATL for outbound integration only - this means that the App can talk to resources in any region, but not vice versa (droplet to app via VPC).

• Built for real developer needs – This feature directly addresses long-standing requests to connect apps to Droplets and Managed Database over a private network.

Benefits

• Security by design: Your app reaches internal services (droplets, databases, DOKS) over private IPs, reducing public exposure and simplifying controls with existing VPC rules.

• Lower latency: When your app and database run in the same datacenter (e.g., NYC1) on the same VPC, traffic stays on private east-west paths with no internet/NAT hops—reducing round-trip time and smoothing tail latency.

• Multi-region flexibility: Keep an app in one region and a database in another, and still connect privately using VPC peering. This is especially helpful for regional data residency and gradual migrations.**

How to get started

1. Confirm access and region – Outbound VPC for App Platform is now generally available in all regions except ATL.
2. Find your VPC ID – List your VPCs and copy the UUID of the one you want the app to use:

doctl vpcs list

3. Attach the app to a VPC – Add the VPC to your app spec (replace your-id with the VPC UUID):

vpc:

  id: your-id

Save and redeploy. From your app’s Console, you can verify private reachability (for example, by curling a private IP on your VPC).

4. (Optional) – Reach resources in another region with VPC peering If your target resource (say, a database) lives in a different region, peer your app’s VPC to the remote VPC:

# Example: create a peering between two VPCs

doctl vpcs peerings create my-app-peering \

  --vpc-ids <VPC_ID_IN_APP_REGION>,<REMOTE_VPC_ID>

VPC peering is available across all regions (with limited exceptions noted in docs) and lets resources communicate over private IPs as if they were on the same network.

Note: Region/datacenter mapping: You create Apps in regions (eg. NYC, SFO). Your app is deployed in the first datacenter in that region (NYC1, SFO1). Apps connect directly to VPCs in the corresponding datacenter for their region:

fra → fra1, nyc → nyc1, tor → tor1. Use peering to reach other regions privately.

Resources

• How to Enable App Platform VPC (docs) – configuration steps & app spec snippet.

Week of September 8th

Product Update Build and deploy your MCP server on App Platform

What’s new

DigitalOcean App Platform now supports seamless deployment of remote MCP (Model Context Protocol) servers with essential AI infrastructure features like HTTP response streaming and subdomain routing—enabling developers to build centralized, cost-effective tool providers for AI applications.

• Remote MCP Server Deployment – Deploy centralized tool providers that AI assistants can access via HTTP with OAuth 2.1 authentication

• HTTP Response Streaming (SSE) – Enable real-time, responsive AI chatbot experiences with server-sent events support

• Subdomain Routing – Build sophisticated multi-tenant applications with precise service organization using custom subdomains

How to get started

1. Clone the MCP Server Template Start with our community template that includes best practices and deployment configuration:

git clone https://github.com/do-community/do-remote-mcp-server-template.git

cd do-remote-mcp-server-template

2. Configure Your App Spec Enable streaming and cost optimization features in your app.yaml:

name: my-mcp-server

services:

- name: mcp-api

  source_dir: /

  github:

    repo: your-username/your-mcp-server

    branch: main

  run_command: python app.py

  environment_slug: python

  instance_count: 1

  instance_size_slug: basic-xxs

  http_port: 8080

  routes:

  - path: /

  **disable_edge_cache:** **true**  **#** **Enable** **HTTP** **Response** **Streaming**

  **inactivity_sleep:** **true**    **#** **Enable** **Scale-to-Zero** **(contact** **support** **first)**

3. Deploy to App Platform:

doctl apps create --spec app.yaml



Or,



Use App Platform Console and Deploy from Git

Check out our comprehensive video tutorial that walks through the entire deployment process, from template setup to production configuration.

Resources

• MCP Server Template Repository

• MCP Server Template with Oauth

• App Platform Subdomain Routing Documentation – Advanced routing configuration guide

• HTTP Response Streaming Setup – Enable real-time streaming responses

Week of September 1st

Product Update App Platform Now Supports Integration with AI-coding Assistants using MCP

What’s new

Now you can integrate AI-powered coding assistants – including Claude Code, Cursor, and VS Code MCP plugins – directly with DigitalOcean App Platform using the new DigitalOcean MCP Server. This means that your AI assistant can deploy applications, spin up databases, manage Spaces, check billing, and more – without leaving your coding environment. Go from AI-generated code to production in just a few prompts with our MCP Server Setup Tutorial, Video Walkthrough, and DigitalOcean MCP Server GitHub.

How to get started

The AI development revolution shouldn’t stop at your IDE. Whether you’re building your first AI-powered app or deploying your hundredth, App Platform + MCP integration takes you from code to production faster than ever. We’ve built a working tutorial to take you from idea to production using only prompts. It uses MCP, DigitalOcean MCP Server, GitHub MCP, and Claude Code so you can go from building the app → committing to GitHub → staging with preview deployments → all the way to merging in production.

Check out our Claude Code Tutorial and GitHub repo.