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

6. Navigate into the project directory.

   console Copy

   $ cd my-claude-app
   

   Explain Code

7. Initialize a Git repository.

   console Copy

   $ git init
   

   Explain Code

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

6. Commit the files to your local repository.

   console Copy

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

   Explain Code

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

9. Set the default branch to main.

   console Copy

   $ git branch -M main
   

   Explain Code

10. Push the code to your GitHub repository.

    console Copy

    $ git push -u origin main
    

    Explain Code

    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 Customer Portal. 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

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 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

2. Open the workflow file in a text editor.

   console Copy

   $ nano .github/workflows/ci.yaml
   

   Explain Code

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

   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 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.