Update commit status on successful / failed deployment

[r3ps4J]

I was thinking it could be very helpful if Coolify updated the commit status shown in GitHub. This is something that many CI playforms do (like GitHub Actions and Jenkins) as well as CD platforms (such as Vercel).

Basically what it does is add a check or cross icon to the commit if the deployment was successful or failed respectively. Something Vercel does is also comment on the commit, I don't think this is needed as it introduces email spam (so if it can be turned off it's fine). But something like those notifications can be discussed in this other discussion: #503

Why is this helpful?

Well you do not want your entire team to have access to your Coolify instance, but it is important for them to know if their latest commit was deployed to production for example.

I think it can be updated using a GitHub App. Here is some information about how to implement this using the REST API: https://docs.github.com/en/rest/commits/statuses?apiVersion=2022-11-28

[AlejandroAkbal]

Would love to see this in a future

[ErlandssonA]

This would be really nice to have. I'm not sure if this is exactly what I was thinking, but I will attach a image of what CloudFlare Pages does.

[mukundshah]

Any update on this?

[atuncer]

I managed to do it with a post deployment command (partially, it only calls the deployment api with success)

Human readable version:

# Update the package list and install jq
apt update && apt install -y jq

# Create a deployment on GitHub and capture the deployment ID
DEPLOYMENT_ID=$(curl -s \
  -X POST \
  -H "Authorization: Bearer $GITHUB_TOKEN" \
  -H "Accept: application/vnd.github+json" \
  https://api.github.com/repos/<REPO_OWNER>/<REPO>/deployments \
  -d '{
    "ref": "main",
    "environment": "production",
    "description": "Finalizing deployment",
    "auto_merge": false,
    "required_contexts": []
  }' | jq -r ".id")

# Check if the deployment creation failed
if [ -z "$DEPLOYMENT_ID" ] || [ "$DEPLOYMENT_ID" = "null" ]; then
  echo "Failed to create deployment on GitHub"
  exit 1
fi

# Post a successful deployment status to GitHub
curl -s \
  -X POST \
  -H "Authorization: Bearer $GITHUB_TOKEN" \
  -H "Accept: application/vnd.github+json" \
  https://api.github.com/repos/<REPO_OWNER>/<REPO>/deployments/$DEPLOYMENT_ID/statuses \
  -d '{
    "state": "success",
    "description": "Deployment completed successfully",
    "environment_url": "<YOUR_ENDPOINT_URL>",
  }'

one-liner version to paste directly into the Post-deployment input area inside your Project->Configuration

apt update && apt install -y jq && DEPLOYMENT_ID=$(curl -s -X POST -H "Authorization: Bearer $GITHUB_TOKEN" -H "Accept: application/vnd.github+json" https://api.github.com/repos/<REPO_OWNER>/<REPO>/deployments -d "{\"ref\": \"main\", \"environment\": \"production\", \"description\": \"Finalizing deployment\", \"auto_merge\": false, \"required_contexts\": []}" | jq -r ".id") && [ -z "$DEPLOYMENT_ID" ] || [ "$DEPLOYMENT_ID" = "null" ] && echo "Failed to create deployment on GitHub" && exit 1 || curl -s -X POST -H "Authorization: Bearer $GITHUB_TOKEN" -H "Accept: application/vnd.github+json" https://api.github.com/repos/<REPO_OWNER>/<REPO>/deployments/$DEPLOYMENT_ID/statuses -d "{\"state\": \"success\", \"description\": \"Deployment completed successfully\", \"environment_url\": \"<YOUR_ENDPOINT_URL>"}"

Change:

• <REPO_OWNER>
• < REPO>
• <YOUR_ENDPOINT_URL>
• apt commands to your flavor to install jq
• "ref": "main" -> to your branch
• "environment": "production" -> to your env (I guess it only affects the deployments page on github UI, nothing functional)

Get an access token from Github settings -> developer settings ... and add it to your environment variables as $GITHUB_TOKEN.

I couldn't find a way to get if the deployment was success or not so I only call the api with success.

[webgas-tech]

Summary

Add native GitHub commit status updates to Coolify, so deployment status (pending, success, failure) is automatically shown on commits and pull requests, similar to Laravel Forge, Vercel, Netlify, and Railway.

Problem

When deploying applications connected to GitHub, users have no visibility into deployment status directly from GitHub. They must:

Open the Coolify dashboard in a separate tab

Navigate to the specific application

Check deployment logs manually

This creates friction, especially when:

Reviewing pull requests, with no indication if preview deployment succeeded

Monitoring main branch deployments

Working in teams where not everyone has Coolify access

Proposed Solution

Automatically update GitHub commit status when deploying GitHub-connected applications.

Status Flow

Deployment Queued -> pending (yellow, Coolify: Deployment queued)
Deployment Started -> pending (yellow, Coolify: Building...)
Deployment Success -> success (green, Coolify: Deployed successfully)
Deployment Failed -> failure (red, Coolify: Deployment failed)
Deployment Cancelled -> error (red, Coolify: Deployment cancelled)

Visual Example (GitHub PR)

All checks have passed

Coolify Production Deployed successfully 2m ago
Coolify Preview Preview ready 1m ago
GitHub Actions Build passed 3m ago

Implementation Approach
Option A: GitHub App Integration (Recommended)

If Coolify is installed as a GitHub App, it already has the necessary permissions. Add commit status updates to the deployment pipeline.

Pseudo-code example:

class DeploymentStatusNotifier
{
public function notify(Deployment deployment, string state): void
{
if (!deployment.application.hasGitHubIntegration()) {
return;
}

github = deployment.application.getGitHubClient();

github.repos().statuses().create(
    deployment.application.repository_owner,
    deployment.application.repository_name,
    deployment.commit_sha,
    [
        state => state,
        target_url => route('deployment.show', deployment),
        description => this.getDescription(deployment, state),
        context => this.getContext(deployment),
    ]
);

}

private function getContext(Deployment deployment): string
{
return "Coolify / " + deployment.environment.name;
}

private function getDescription(Deployment deployment, string state): string
{
switch (state) {
case 'pending': return 'Deployment in progress...';
case 'success': return 'Deployed successfully';
case 'failure': return 'Deployment failed';
case 'error': return 'Deployment error';
}
}

}

Option B: Personal Access Token (Fallback)

For users who connect via PAT instead of GitHub App, allow optional configuration.

Example application settings:

github_status_updates:
enabled: true
context_prefix: "Coolify"

Configuration UI

Application Settings -> GitHub

Repository: myorg/myrepo
Branch: main

Update commit status on deployment
Shows deployment status on commits and pull requests

Require successful deployment for PR merge
Block PR merges until deployment succeeds via GitHub

Required GitHub Permissions

For GitHub App:
statuses write

For PAT:
repo status scope

Events to Hook

Event: ApplicationDeploymentJob handle start
Status: pending
Description: Building application

Event: Docker build complete
Status: pending
Description: Deploying to server

Event: Health check passed
Status: success
Description: Deployed successfully

Event: Any exception caught
Status: failure
Description: Deployment failed with reason

Event: Job timeout
Status: error
Description: Deployment timed out

Event: Manual cancellation
Status: error
Description: Deployment cancelled

Benefits

Better developer experience with deployment status visible directly in GitHub

Improved PR review workflow with preview deployment visibility

Team-wide visibility without requiring Coolify access

Enables GitHub branch protection with deployment gates

Feature parity with Vercel, Netlify, Railway, Render, and Forge

Alternatives Considered
GitHub Actions Workflow (Current Workaround)

Users can create a workflow that triggers a Coolify webhook, polls the Coolify API for status, and updates GitHub commit status.

Drawbacks:

Requires extra secrets management

Consumes GitHub Actions minutes

Polling is less reliable than native integration

High setup complexity for many users

GitHub Check Runs API

More powerful than commit statuses, but requires GitHub App only and is more complex to implement. Commit statuses are sufficient for this use case.

Prior Art

Vercel: Commit Status yes, Check Runs yes, PR Comments yes
Netlify: Commit Status yes, Check Runs yes, PR Comments yes
Railway: Commit Status yes, Check Runs no, PR Comments no
Render: Commit Status yes, Check Runs no, PR Comments yes
Laravel Forge: Commit Status yes, Check Runs no, PR Comments no
Heroku: Commit Status yes, Check Runs yes, PR Comments no
Coolify: Commit Status no, Check Runs no, PR Comments no

Success Metrics

Reduced context switching for developers

Faster PR review cycles

Increased team adoption of Coolify

Ability to enforce deployment gates via GitHub branch protection

Additional Context

There is an existing third-party implementation demonstrating this concept at github.com/mascarock/coolify-deployment-status, and this is a common request across deployment platforms.

Mockups

GitHub Commit View

Commit abc123f Add new feature

Status checks
Coolify / production Deployed 2 minutes ago
Coolify / staging Deployed 3 minutes ago
GitHub Actions / test Passed 5 minutes ago

GitHub PR Checks

Some checks have not completed yet

Coolify / preview Deploying In progress
GitHub Actions / lint Passed 1 minute ago
GitHub Actions / test Passed 2 minutes ago

Related: This pairs well with a Dynamic Favicon Badge feature that shows deployment status in the browser tab.