Cursor is an AI-powered code editor built on VS Code that uses large language models to generate, refactor, and debug full-stack applications through natural language prompts. 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 set up Cursor, generate a full-stack application with AI assistance, push the code to GitHub, and deploy it on Vultr using Coolify.

Prerequisites

Before you begin, you need to:

• Have a Cursor 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).

Set Up Cursor

Cursor functions as a standalone code editor with integrated AI capabilities. Install and authenticate the application before creating a new project.

1. Download and install Cursor.

2. Launch the application and sign in with your Cursor account.

3. Complete the initial environment preferences configuration when prompted.

Create an Application Using AI

Cursor generates application code directly in the editor through its AI chat interface. The generated project needs a Dockerfile so Coolify can build and deploy the containers. For multi-service applications, include a docker-compose.yml file.

1. Open a new, empty project directory in Cursor.

2. Open the AI chat panel. Press Ctrl + I on Windows or Linux, or Cmd + I on macOS.

3. Enter a detailed prompt describing your application. Specify the technology stack, required features, and request a Dockerfile for containerized deployment. For applications with multiple services, also request a docker-compose.yml file. Cursor generates the source code, project structure, and container configurations based on your description.

4. Review the generated files to verify the project structure and Docker configuration.

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

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

7. Initialize a Git repository.

   console Copy

   $ git init
   

   Explain Code

8. Stage all generated files.

   console Copy

   $ git add .
   

   Explain Code

9. Commit the files to your local repository.

   console Copy

   $ git commit -m "Initial application generated with Cursor"
   

   Explain Code

10. Create a new repository on GitHub.

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

    console Copy

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

    Explain Code

12. Set the default branch to main.

    console Copy

    $ git branch -M main
    

    Explain Code

13. Push the code to your GitHub repository.

    console Copy

    $ git push -u origin main
    

    Explain Code

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

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-cursor-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 Cursor 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 for Cursor 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

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 spins up 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 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 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 Cursor, 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.