How to Deploy Claude Code Projects on Vultr Using Coolify

Claude Code is an interactive CLI tool that generates full-stack applications through conversational AI assistance, producing production-ready code repositories with Docker configurations. Coolify provides a self-hosted platform-as-a-service that simplifies deployment by automating Docker orchestration, reverse proxy configuration, and TLS certificate management.

This guide covers installing Claude Code, generating a full-stack application using AI, pushing the code to a GitHub repository, and deploying it with Coolify. The guide uses VS Code, but the steps are the same when using the Claude Code from a terminal.

Prerequisites

Before you begin, you need to:

• Have an Anthropic account with an API key, or a Claude subscription.
• Have a GitHub account.
• Deploy the Vultr Marketplace Application for Coolify with at least 2 GB RAM and 1 CPU core.
• Configure a domain name, such as app.example.com, to point to your server's public IP address.

Set Up Claude Code with VS Code

Install the Claude Code extension in VS Code to generate and iterate on application code. The extension includes the Claude Code CLI, so no separate installation is required.

1. Download and install VS Code.

2. Open the Extensions view. Press Ctrl + Shift + X on Windows or Linux, or Cmd + Shift + X on macOS. Search for Claude Code and click Install.

3. Open a file or folder in VS Code. Click the Spark icon in the Editor Toolbar (top-right corner of the editor) to open the Claude Code panel. You are prompted to sign in on first use. Sign in using a Claude subscription or an Anthropic Console account. Refer to the Claude Code setup documentation for additional authentication options.

4. Open the integrated terminal. Press Ctrl + ` on Windows or Linux, or Cmd + ` on macOS.

5. Create a project directory.

   CONSOLE

   Copy

   $ mkdir my-claude-app

   Explain Code

   Powered by Vultr AgentBeta

6. Navigate into the project directory.

   CONSOLE

   Copy

   $ cd my-claude-app

   Explain Code

   Powered by Vultr AgentBeta

7. Initialize a Git repository.

   CONSOLE

   Copy

   $ git init

   Explain Code

   Powered by Vultr AgentBeta

Create an Application Using AI

Use Claude Code to generate a full-stack application with container support. At minimum, the application requires a Dockerfile for Coolify to build and deploy. If your application uses multiple services such as a database, you can also request a docker-compose.yml file.

1. Open the Claude Code panel in VS Code. Click the Spark icon in the Editor Toolbar, or press Ctrl + Esc on Windows or Linux, or Cmd + Esc on macOS.

2. Describe your application to Claude Code. Include your preferred technology stack, the features you need, and request a Dockerfile for containerized deployment. If your application requires multiple services, also ask for a docker-compose.yml file. Claude Code generates the source code, project structure, and container configurations based on your description.

3. Review the generated files in VS Code to verify the project structure and Docker configuration.

4. Optionally, test the application locally using the generated Docker configuration. Refer to the generated README for local setup and run instructions.

5. Stage all generated files.

   CONSOLE

   Copy

   $ git add .

   Explain Code

   Powered by Vultr AgentBeta

6. Commit the files to your local repository.

   CONSOLE

   Copy

   $ git commit -m "Initial application generated with Claude Code"

   Explain Code

   Powered by Vultr AgentBeta

7. Create a new repository on GitHub.

8. Add the GitHub repository as a remote. Replace YOUR_USERNAME and my-claude-app with your GitHub username and repository name.

   CONSOLE

   Copy

   $ git remote add origin https://github.com/YOUR_USERNAME/my-claude-app.git

   Explain Code

   Powered by Vultr AgentBeta

9. Set the default branch to main.

   CONSOLE

   Copy

   $ git branch -M main

   Explain Code

   Powered by Vultr AgentBeta

10. Push the code to your GitHub repository.

    CONSOLE

    Copy

    $ git push -u origin main

    Explain Code

    Powered by Vultr AgentBeta

    Your application is now in a GitHub repository. The following sections deploy this repository using Coolify. Alternatively, you can integrate the repository with platforms such as Supabase for managed database and backend hosting.

Access the Coolify Dashboard

After the marketplace instance finishes provisioning, access the Coolify web interface to complete the initial configuration.

1. Navigate to your instance's Management Page in the Vultr Console. Scroll down to App Instructions to find the Coolify endpoint URL. The format resembles http://SERVER_IP:8000.

2. Open the URL in your browser. The setup wizard prompts for an email address and password. Enter your credentials for the administrator account.

3. Coolify displays the dashboard after successful registration. This account has full control over deployments, team management, and server configuration.

Connect GitHub Repository

Coolify integrates with GitHub to deploy applications directly from source code repositories. Configure OAuth authentication to authorize repository access.

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

Projects organize applications and resources within Coolify. Create a project for your Claude Code-generated application.

1. Click Projects in the Coolify dashboard.

2. Click Add Project.

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

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

Deploy the Application

Configure Coolify to build and deploy your application from the GitHub repository. Coolify detects Docker Compose configurations automatically.

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 Claude Code application repository from the dropdown.

5. Enter the branch name, typically main.

6. Coolify analyzes the repository and detects the Docker Compose 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

Claude Code applications often require environment variables for API keys, database credentials, or feature flags. Coolify provides a secure interface for managing secrets.

1. Navigate to 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 Claude Code 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
   • REACT_APP_API_URL - Frontend API endpoint, such as https://api.example.com

5. Click Save after adding all required variables.

Start the Deployment

Initiate the build and deployment process to make your application live.

1. Click Deploy to trigger the deployment process.

2. Coolify initiates the deployment. Click Logs to monitor build progress.

   The deployment process includes:

   • Cloning the repository
   • Building Docker images for each service
   • Starting containers
   • Configuring Traefik routing rules
   • Requesting TLS certificates

   The entire process completes in 3-5 minutes for typical applications.

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

Verify Deployment

Access your application through the temporary domain to confirm successful deployment.

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. Navigate to the application details page.

2. Click Configuration in 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 rebuilds the application with the new domain and requests an TLS certificate. This process takes 2-3 minutes.

8. Open your custom domain in a browser. Verify that the browser displays a padlock icon next to the URL, indicating a valid TLS certificate.

Add a Database

Claude Code applications typically require a PostgreSQL or MySQL database for persistent data storage. Coolify provides managed database containers.

1. Return to the project details page.

2. Click Add Resource.

3. Select Database.

4. Choose PostgreSQL as the database type.

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

6. Click Create. Coolify generates secure credentials automatically.

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

8. Navigate to your application's Environment Variables section.

9. Add or update the DATABASE_URL variable with the connection string.

10. Click Restart to establish the database connection.

Configure CI/CD Pipeline

Coolify provides continuous deployment capabilities through GitHub webhooks. Configure automatic deployments to rebuild and redeploy your application whenever you push changes to the repository.

Enable Automatic Deployments

1. Navigate to 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 settings.

6. Navigate to Webhooks and click Add webhook.

7. Paste the Coolify webhook URL in the Payload URL field.

8. Select application/json as the content type.

9. Choose Just the push event.

10. Click Add webhook.

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

Test the CI/CD Pipeline

1. Make a change to your application code.

2. Stage the changes.

   CONSOLE

   Copy

   $ git add .

   Explain Code

   Powered by Vultr AgentBeta

3. Commit the changes.

   CONSOLE

   Copy

   $ git commit -m "Update application feature"

   Explain Code

   Powered by Vultr AgentBeta

4. Push to GitHub.

   CONSOLE

   Copy

   $ git push origin main

   Explain Code

   Powered by Vultr AgentBeta

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

6. Navigate to the application details page in Coolify.

7. Click Deployments to view the deployment history.

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

9. Click Logs to monitor the build process in real time.

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

Configure GitHub Actions for Testing

Integrate GitHub Actions to run tests before Coolify deploys your application. This ensures only passing builds reach production.

1. Create the GitHub Actions workflow directory.

   CONSOLE

   Copy

   $ mkdir -p .github/workflows

   Explain Code

   Powered by Vultr AgentBeta

2. Open the workflow file in a text editor.

   CONSOLE

   Copy

   $ nano .github/workflows/ci.yaml

   Explain Code

   Powered by Vultr AgentBeta

3. Add the following configuration. Adjust test commands for 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

   Powered by Vultr AgentBeta

   Save and close the file.

4. Stage the workflow file.

   CONSOLE

   Copy

   $ git add .github/workflows/ci.yaml

   Explain Code

   Powered by Vultr AgentBeta

5. Commit the changes.

   CONSOLE

   Copy

   $ git commit -m "Add CI workflow"

   Explain Code

   Powered by Vultr AgentBeta

6. Push to GitHub.

   CONSOLE

   Copy

   $ git push origin main

   Explain Code

   Powered by Vultr AgentBeta

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

Conclusion

You have successfully deployed a Claude Code-generated application using Vultr's Coolify Marketplace Application, configured environment variables, and secured the deployment with a custom domain and TLS certificate. For more information, refer to the official Coolify documentation.