Lovable is a web-based AI agent that generates full-stack applications through natural language prompts and enables you to preview them live. Coolify is a self-hosted platform-as-a-service that orchestrates Docker containers, manages Traefik reverse proxy routing, and provisions Let's Encrypt TLS certificates automatically.

This guide explains how to create an application using Lovable, transfer the source code to GitHub, and deploy it on Vultr using Coolify.

Prerequisites

Before you begin, you need to:

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

Create an Application Using Lovable

Lovable generates application code through its web-based AI agent interface. The platform creates a GitHub repository automatically and pushes the generated code, eliminating manual Git setup. The generated project needs a Dockerfile so Coolify can build and deploy the containers.

1. Navigate to Lovable and log in.

2. Provide a detailed description of your application in the prompt field. Specify all necessary features and your desired technology stack. Instruct the agent to ensure Coolify compatibility. Request a Dockerfile or, if your application requires multiple services, a docker-compose.yml file.

3. Wait for the agent to create the file structure and application code.

4. Verify that all features of your application are functional in the Preview panel.

5. (Optional): To test the code locally, click the </> icon in the top-left corner of the Preview panel. Then, click the Download icon. Ask the agent for instructions on testing locally.

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

7. Click Connect GitHub and then Add connection.

8. Click Add in the Install on new account section.

9. Sign in to your GitHub account in the opened window, and select All repositories or Only select repositories. Then click Install & Authorize.

10. Verify that a new repository shows in the Repository connection section and has a Connected status. Lovable created the repository and pushed the code.

11. Click Go Back in the top right corner of the screen.

Access the Coolify Dashboard

Coolify serves its administration interface on port 8000. The initial login creates the administrator account that controls all deployments and server settings.

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 prompts you to create an administrator account. Complete the required fields and submit the form.

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

Connect GitHub Repository

A GitHub source entry tells Coolify where to pull code from during builds. Adding the source once makes it available to every project on the server.

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 uses projects to group related applications, databases, and services. Resources within the same project share a common Docker network.

1. Click Projects in the Coolify dashboard.

2. Click Add Project.

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

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

Deploy the Application

Coolify fetches source code from the GitHub repository, builds Docker images based on the Dockerfile or docker-compose.yml, and starts the containers with Traefik routing configured 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 Lovable application repository from the dropdown.

5. Enter the branch name, typically main.

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

Sensitive configuration values such as API keys and database credentials belong in Coolify's environment variable storage rather than in source code. Coolify passes these values to containers 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 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

Once the repository and environment variables are configured, initiate the build to create and launch the application containers.

1. Click Deploy to trigger the deployment process.

2. Coolify schedules the build. Select Logs to track each stage as it runs.

   Each deployment runs through the following sequence:

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

   The full sequence takes 3-5 minutes for a typical application.

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

Verify Deployment

Test that the application loads correctly using the temporary domain before switching to production.

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. Edit the Domains field, removing the temporary domain and replacing it with your custom domain. Enter the value as https://app.example.com so Coolify knows to provision HTTPS.

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

5. Click Save.

6. Click Redeploy to apply the domain configuration.

7. Coolify rebuilds and reconfigures Traefik with the new hostname, then requests a certificate from Let's Encrypt. This takes 2-3 minutes.

8. Load the custom domain in your browser and check that the address bar shows a padlock, confirming the TLS certificate is valid.

Add a Database

Coolify deploys database containers within the same project, connected over an internal Docker network. The internal connection URL keeps database traffic isolated from the public internet.

1. Navigate back to the project details page.

2. Click Add Resource.

3. Select Database.

4. Choose PostgreSQL as the database type.

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

6. Click Create. Coolify starts the container and generates login credentials.

7. Copy the connection string shown on the database details page.

8. Open the Environment Variables section for your application.

9. Add DATABASE_URL as a new variable and paste the connection string as the value.

10. Click Restart so the application picks up the updated database configuration.

Configure CI/CD Pipeline

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

Enable Automatic Deployments

1. Navigate to the application details page.

2. Click Settings.

3. Enable Automatic Deployment.

4. Coolify shows the generated webhook URL. Copy it.

5. Open the GitHub repository that holds your application code.

6. Go to Settings, then click Webhooks and select Add webhook.

7. Enter 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 to register it.

11. GitHub sends an initial test event. Check that a green checkmark appears next to the webhook entry.

Test the CI/CD Pipeline

Confirm that pushing code to GitHub triggers an automatic rebuild and deployment in Coolify.

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

Set up a GitHub Actions workflow to run automated tests before every deployment. Coolify receives the webhook only after all checks pass, blocking broken code 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 created a full-stack application with Lovable, pushed the code to GitHub, and deployed it on Vultr using Coolify. The application now serves traffic over a custom domain with automatic HTTPS and redeploys on every push to the repository. For more information, visit the official Coolify documentation.