v0 is a browser-based generative AI tool by Vercel that converts natural language descriptions into deployable full-stack applications. It produces complete project scaffolding, including frontend components, backend logic, and container configuration files. Coolify is a self-hosted platform-as-a-service that handles Docker image builds, Traefik-based reverse proxying, and automatic TLS certificate provisioning on your own infrastructure.

This guide explains how to generate a full-stack application with v0, export the source code to GitHub, and deploy it on a Vultr server using Coolify.

Prerequisites

Before you begin, you need to:

• Have a v0 account.
• Have a GitHub account.
• Deploy the Vultr Marketplace Application for Coolify with at least 2 GB RAM and 1 CPU core.
• Configure a DNS A record pointing to your server's IP address (for example, app.example.com).

Create an Application Using AI

v0 generates a complete project from a single prompt and can push the resulting code directly to a GitHub repository. The application needs at least a Dockerfile so Coolify can build and run it. For projects with multiple services, such as a separate database container, request a docker-compose.yml as well.

1. Navigate to v0 in a web browser and log in with your account.

2. Type a detailed description of your application in the prompt field. Specify the technology stack and all required features. Ask v0 to include a Dockerfile, or a docker-compose.yml if the project involves multiple services. v0 generates the source files, directory structure, and container configuration based on your prompt.

3. Click the arrow button to submit the prompt.

4. Wait for v0 to finish building the application.

5. Inspect the result in the interactive preview panel. Confirm that the generated features match your requirements.

6. Click the Project Settings icon in the top header on the right side.

7. Select GitHub in the left sidebar.

8. Click Connect repository.

9. Sign in with GitHub and authorize v0 to access your repositories.

10. Enter a name for your repository and click Create Repository.

11. v0 pushes your application's source code automatically to the new repository. The repository now contains all generated files including the Dockerfile or docker-compose.yml.

Access the Coolify Dashboard

The Vultr Marketplace deploys Coolify with a pre-configured web interface. Log in to create the administrator account before connecting any repositories or projects.

1. Open your instance's Management Page in the Vultr Console and scroll down to App Instructions. The Coolify endpoint URL appears there in the format http://SERVER_IP:8000.

2. Open the URL in a browser. The first-run wizard asks for an email address and password. Enter the credentials for your administrator account.

3. Coolify opens the dashboard after the account is created. The administrator account controls all deployments, team members, and server settings.

Connect GitHub Repository

Coolify requires a GitHub source connection before it can pull code from your repositories. Use the OAuth flow to grant Coolify read access to your selected repositories.

1. Click Sources in the Coolify dashboard.

2. Click Add Source and select GitHub.

3. Coolify redirects to GitHub for OAuth authorization. Click Authorize to grant access.

4. GitHub redirects back to Coolify after successful authorization. Coolify displays your GitHub account in the Sources list.

Create a New Project

A Coolify project groups related applications and services under one namespace, making it easier to manage environment variables, domains, and resources together.

1. Click Projects in the Coolify dashboard.

2. Click Add Project.

3. Enter a project name, such as my-v0-app.

4. Click Create. Coolify displays the project details page.

Deploy the Application

Coolify pulls source code from the linked GitHub repository, builds a Docker image using the Dockerfile or docker-compose.yml in the repository root, and starts the resulting containers.

1. Click Add Resource in the project details page.

2. Select Application as the resource type.

3. Choose GitHub as the source.

4. Select your v0 application repository from the dropdown.

5. Enter the branch name, typically main.

6. Coolify scans the repository and identifies the container configuration. Select Docker Compose as the build pack for multi-container applications.

7. Click Continue.

8. Coolify generates a temporary domain in the format RANDOM_ID.SERVER_IP.sslip.io for immediate testing. Configure a custom domain later for production use.

9. Click Save. Coolify redirects to the application configuration page.

Configure Environment Variables

Store secrets such as API keys and database credentials in Coolify's environment variable manager rather than hardcoding them in source files. Coolify injects these values into the container at runtime.

1. Open the application details page.

2. Click Environment Variables.

3. Click +Add to create a new variable.

4. Enter the variable name and value. Common variables for v0 applications include:

   • DATABASE_URL: PostgreSQL connection string, such as postgresql://user:pass@db:5432/dbname
   • API_KEY: External service API key, such as sk_live_abc123
   • NODE_ENV: Runtime environment, such as production
   • NEXT_PUBLIC_API_URL: Frontend API endpoint, such as https://api.example.com

5. Click Save after adding all required variables.

Start the Deployment

With the repository connected and environment variables saved, trigger the build to compile and launch the application containers.

1. Click Deploy to trigger the deployment process.

2. Coolify starts the build. Click Logs to watch the output in real time.

   Coolify works through the following steps:

   1. Cloning the repository
   2. Building Docker images for each service
   3. Starting containers
   4. Configuring Traefik routing rules
   5. Requesting TLS certificates

   Most applications are live within 3-5 minutes.

3. When deployment completes successfully, the application status changes to Running.

Verify Deployment

Check that the application is reachable before switching to a production domain.

1. Click Links in the application details page to view accessible URLs.

2. Click the Coolify-generated domain link to open your application.

3. Your application loads at http://RANDOM_ID.SERVER_IP.sslip.io. Verify that all features function correctly.

Configure Custom Domain with HTTPS

Replace the temporary sslip.io domain with your custom domain for production use. Coolify automatically provisions Let's Encrypt TLS certificates.

1. Open the application details page.

2. Select Configuration from the left sidebar.

3. Locate the Domains field and replace the Coolify-generated domain with your custom domain. Enter https://app.example.com in the field.

4. Enable Automatic HTTPS to provision Let's Encrypt certificates.

5. Click Save.

6. Click Redeploy to apply the domain configuration.

7. Coolify reissues the build with the updated domain and requests a certificate from Let's Encrypt. Allow 2-3 minutes for the process to finish.

8. Open the domain in a browser and confirm the padlock icon appears in the address bar, indicating an active TLS certificate.

Add a Database

Coolify can run a managed PostgreSQL container within the same project. The database container shares an internal Docker network with your application, keeping the connection string off the public internet.

1. Return to the project details page.

2. Click Add Resource.

3. Select Database.

4. Choose PostgreSQL as the database type.

5. Enter a name for the database, such as app-db.

6. Click Create. Coolify generates the database and its credentials automatically.

7. Copy the internal connection string from the database details page.

8. Open the Environment Variables section of your application.

9. Set DATABASE_URL to the copied connection string.

10. Click Restart to apply the new connection.

Configure CI/CD Pipeline

Coolify supports continuous deployment through GitHub webhooks, automatically rebuilding and redeploying your application on every push.

Enable Automatic Deployments

1. Open the application details page.

2. Click Settings.

3. Enable Automatic Deployment.

4. Coolify displays a webhook URL. Copy the URL.

5. Open your GitHub repository and click Settings.

6. Click Webhooks in the left sidebar, then click Add webhook.

7. Paste the copied URL into the Payload URL field.

8. Set the content type to application/json.

9. Select Just the push event.

10. Click Add webhook to save.

11. GitHub sends a test payload to Coolify. Verify that the webhook shows a green checkmark.

Test the CI/CD Pipeline

Push a small code change to confirm that Coolify picks up the update and redeploys automatically.

1. Edit any file in your application code.

2. Stage the changes.

   console Copy

   $ git add .
   

   Explain Code

3. Commit the changes.

   console Copy

   $ git commit -m "Update application feature"
   

   Explain Code

4. Push to GitHub.

   console Copy

   $ git push origin main
   

   Explain Code

5. Coolify detects the push event and starts a new deployment automatically.

6. Open the application details page in Coolify.

7. Click Deployments to view the deployment history.

8. The most recent entry appears at the top with a Building status.

9. Click Logs to follow the build output in real time.

10. When the build completes, the deployment status changes to Finished and the application restarts with the updated code.

Configure GitHub Actions for Testing

Add a GitHub Actions workflow to run automated tests on every push. Coolify only receives the webhook trigger after all workflow checks pass, preventing broken builds from reaching production.

1. Create the GitHub Actions workflow directory.

   console Copy

   $ mkdir -p .github/workflows
   

   Explain Code

2. Open a new workflow file in a text editor.

   console Copy

   $ nano .github/workflows/ci.yaml
   

   Explain Code

3. Paste the following configuration into the file. Update the test commands to match your application stack.

   yaml Copy

   name: CI
   
   on:
     push:
       branches: [ main ]
     pull_request:
       branches: [ main ]
   
   jobs:
     test:
       runs-on: ubuntu-latest
       steps:
         - uses: actions/checkout@v4
   
         - name: Run tests
           run: |
             # Add your test commands here
             # Example for Node.js:
             # npm install && npm test
             # Example for Go:
             # go test ./...
             echo "Tests passed"
   

   Explain Code

   Save and close the file.

4. Stage the workflow file.

   console Copy

   $ git add .github/workflows/ci.yaml
   

   Explain Code

5. Commit the changes.

   console Copy

   $ git commit -m "Add CI workflow"
   

   Explain Code

6. Push to GitHub.

   console Copy

   $ git push origin main
   

   Explain Code

7. GitHub Actions runs the tests on every push. Coolify deploys the application only after the workflow completes successfully.

Conclusion

You have successfully generated a full-stack application with Vercel v0, exported the project to GitHub, and deployed it on Vultr using Coolify. The application runs behind a custom domain secured with a Let's Encrypt TLS certificate and redeploys automatically on every code push. For more information, visit the official Coolify documentation.