Bolt.new is a browser-based AI agent by StackBlitz that generates, executes, and previews full-stack web applications directly in the browser without requiring any local development setup. Coolify is an open-source, self-hosted platform-as-a-service that manages Docker container builds, Traefik reverse proxy routing, and automated Let's Encrypt certificate provisioning.

This guide explains how to generate a full-stack application with Bolt.new, export the codebase to GitHub, and deploy it on Vultr using Coolify.

Prerequisites

Before you begin, you need to:

• Have a Bolt.new 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

Bolt.new runs entirely in the browser and can generate a working application from a single prompt. The generated project requires a Dockerfile at minimum so Coolify can containerize and deploy it. For applications with multiple services, such as a separate backend and database, include a docker-compose.yml in your prompt.

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

2. Enter a detailed description of your application in the prompt field. Specify the technology stack, required features, and request a Dockerfile for containerized deployment. For multi-service projects, also request a docker-compose.yml file. Bolt.new generates the complete source code, directory structure, and container configuration.

3. Click Build Now to start generating the application.

4. Wait for the Bolt agent to finish creating the application.

5. Test the application in the live preview panel. Confirm that all requested features work as expected.

6. Click the GitHub icon in the top right corner.

7. Click Log in to GitHub and authorize Bolt.new to access your repositories.

8. Enter a name for your repository.

9. Click Create Repository.

10. Bolt.new pushes the complete source code to the new GitHub repository. The repository includes all generated files, including the Dockerfile or docker-compose.yml.

Access the Coolify Dashboard

Coolify runs as a Vultr Marketplace application and exposes a web-based control panel on port 8000. The first login creates the administrator account that manages all subsequent deployments.

1. Open your instance's Management Page in the Vultr Customer Portal 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

Linking a GitHub account gives Coolify permission to clone your repositories during each build. The connection is established through GitHub's OAuth flow and persists across all projects.

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

Coolify organizes deployments into projects. Each project can contain multiple applications, databases, and services that share a common network and configuration namespace.

1. Click Projects in the Coolify dashboard.

2. Click Add Project.

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

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

Deploy the Application

Coolify clones the repository, builds a Docker image from the Dockerfile or docker-compose.yml, and launches the containers on the server. Traefik handles incoming traffic routing 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 Bolt.new 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

Environment variables allow you to pass runtime configuration and secrets to your application without committing sensitive data to the repository. Coolify encrypts stored values and injects them into containers during startup.

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

After configuring the repository and environment variables, start the build process to compile and launch the application.

1. Click Deploy to trigger the deployment process.

2. Coolify queues the build. Open Logs to stream the output as each stage runs.

   The build pipeline executes the following steps in order:

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

   The pipeline duration depends on application size and server resources.

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

Verify Deployment

Confirm that the application responds correctly before configuring 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. Go 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 triggers a new build, registers the domain with Traefik, and fetches a certificate.

8. Visit the domain in a browser. A padlock in the address bar confirms the certificate is active and HTTPS is working.

Add a Database

Coolify provisions managed database containers that run alongside your application on the same internal Docker network. This keeps the database credentials and traffic isolated from 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. Provide a name for the database instance, such as app-db.

6. Click Create. Coolify provisions the container and generates access credentials.

7. Locate and copy the internal connection string on the database details page.

8. Navigate to the Environment Variables tab of your application.

9. Create or update the DATABASE_URL entry and paste the connection string as its value.

10. Click Restart to reconnect the application with the new database.

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

2. Click Settings.

3. Toggle on Automatic Deployment.

4. Coolify generates and displays a webhook URL. Copy it.

5. Switch to your GitHub repository and open Settings.

6. Select Webhooks from the sidebar and click Add webhook.

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

8. Choose application/json as the content type.

9. Under events, select 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

Verify that Coolify triggers a new build when code changes are pushed to the repository.

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

Run automated tests before deployment by adding a GitHub Actions workflow. The webhook fires only after all workflow checks pass, ensuring that broken code never reaches 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 built a full-stack application with Bolt.new, pushed the codebase to GitHub, and deployed it on Vultr using Coolify. The application now runs behind a custom domain with automatic HTTPS and redeploys whenever you push new code. For more information, visit the official Coolify documentation.