Read a deployment and its build log

Read a deployment to follow it while it builds and starts, to find out why it failed, and to check the health of each of its replicas. Each deployment has its own page in the dashboard, and the API returns the same facts. Every member of an organization can read its apps' deployments.

• In the dashboard, open the app. Through the API, find the deployment's ID in the app's history (List deployments). The five newest also come with the app itself.
• Deployments explains what each status means.

1. Open the app from Apps and select the Deployments tab.
2. Select the deployment's row, or Open deployment in the menu at the end of it.

When you start a deployment in the dashboard, its page opens on its own. All deployments goes back to the list. While the deployment is on its way, the page reads it again every few seconds, and the build log follows the build.

The header

The first line of the commit message, or what the deployment was, with its status and Current when it serves the app. Under it are its short ID with Copy deployment ID, the short commit or the branch, what started it, such as Push to main, and when. Roll back to this… and Cancel deployment… appear when you can use them.

Its progress

While it is on its way, a bar says what it is doing, such as Waiting for a builder, Building or Starting replicas, and how long it has taken so far.

How it ended

The deployment failed with the reason, The deployment was cancelled, or A newer deployment replaced this one. A deployment that went live without a region shows It went live without every region with the region it left out and why.

Build log

The end of the build log (The build log).

Replicas

Every replica the deployment has had (Replicas).

Details

Source, Started by, Branch or tag, Commit and Author for a git deployment, and Image and Digest once it has an image. Regions lists where it runs. Build gives the build's status, how it built (From its Dockerfile or Detected by the builder) and the attempt when it took more than one, and Build time how long it took. Created, Ready and Ended give the times.

A git deployment keeps the last 64 KB of its build log. The log hides the repository's access token and every secret build value of six characters or more, which appear as [redacted]. An image deployment has no build, so it has no log, and a redeploy or a rollback that reuses an image has none either.

The Build log card shows the last 40 lines, where a failure usually is. The button at the top of the card, such as Show all 312 lines, shows every line that is kept, and Copy the log lines shown copies what you see. The card's description says how the build ended and how long it took, such as Built in 2 min 37 s., or Only the end is kept when the build wrote more than 64 KB.

The Replicas card lists every replica the deployment has had, with its region, such as Frankfurt (fra), its state, when it was last checked, its last error and when it started. A replica that has failed health checks says how many, such as 2 failed checks.

The API sends each state in lower case, such as healthy. A replica's last error says what went wrong, such as Health check on /healthz: HTTP 500 or The app did not pass its health check within 10 minutes. Health check on /: the connection failed.

You know where the deployment is, and why when it failed. Troubleshoot Apps lists the common causes and their fixes.

Deployment not found or This deployment is not on this app

The ID belongs to another app's deployment, or to none. Check both IDs, or open the deployment from the app's Deployments tab.

The log is empty

An image deployment has no log (Image deployments have no build log), nor does a deployment that reused an image (Nothing was built for this deployment). A build that has not started has written nothing yet (No log yet).

The log starts partway through

The build wrote more than 64 KB, and only the end is kept.

• Deploy an app
• Roll back to an earlier deployment
• App and deployment fields
• Troubleshoot Apps

For an organization's app, send the same requests under /api/v1/orgs/{org_slug}/apps (organization apps reference).

GET /api/v1/client/apps/{app_uuid}/deployments/{deployment_uuid} returns the deployment with every replica it has had in replica_list:

curl https://api.coritan.com/api/v1/client/apps/3c9e2f4a-8b1d-4f6e-a2c7-5d8b9e0f1a21/deployments/1d7b4e9a-5c2f-4a8e-9d6b-2f8e5a1c7b11 \
  -H "Authorization: Bearer $CORITAN_TOKEN"

{
  "deployment": {
    "uuid": "1d7b4e9a-5c2f-4a8e-9d6b-2f8e5a1c7b11",
    "status": "failed",
    "source": "git",
    "trigger": "push",
    "git_ref": "main",
    "git_sha": "9f2c1e7b4a6d8e0f1a2b3c4d5e6f708192a3b4c5",
    "commit_message": "Move the health check to /healthz",
    "commit_author": "Alex Example",
    "image_ref": "registry.example.net/apps/3c9e2f4a-8b1d-4f6e-a2c7-5d8b9e0f1a21:1d7b4e9a-5c2f-4a8e-9d6b-2f8e5a1c7b11",
    "image_digest": "sha256:5b2d0c9e8f7a6b5c4d3e2f1a0b9c8d7e6f5a4b3c2d1e0f9a8b7c6d5e4f3a2b1c",
    "regions": ["fra", "iad"],
    "actor_type": "webhook",
    "error": "Replicas could not start in fra: The app did not pass its health check within 10 minutes. Health check on /healthz: HTTP 404",
    "is_current": false,
    "in_flight": false,
    "can_rollback": false,
    "replicas": {"healthy": 0, "unhealthy": 0, "starting": 0, "total": 0},
    "build": {
      "uuid": "e2a9c4d1-3b5f-4e7a-9c8d-1f2e3a4b5c6d",
      "status": "succeeded",
      "strategy": "railpack",
      "error": null,
      "attempts": 1,
      "log_bytes": 48211,
      "started_at": "2026-09-26T10:05:04Z",
      "finished_at": "2026-09-26T10:07:41Z",
      "created_at": "2026-09-26T10:05:00Z"
    },
    "ready_at": null,
    "promoted_at": null,
    "finished_at": "2026-09-26T10:18:02Z",
    "created_at": "2026-09-26T10:05:00Z",
    "updated_at": "2026-09-26T10:18:02Z",
    "replica_list": [
      {
        "location": "fra",
        "state": "failed",
        "health_failures": 0,
        "last_health_at": null,
        "last_error": "The app did not pass its health check within 10 minutes. Health check on /healthz: HTTP 404",
        "created_at": "2026-09-26T10:07:45Z",
        "drained_at": null
      }
    ]
  }
}

The example shows one replica of several. App and deployment fields describes every field. These say the most:

The version

A git deployment has the branch or ref it built and the ID of the commit it checked out. A deployment started by a push also has the commit's message and author. Every deployment that has an image shows its reference and, once known, its digest.

Where it came from

source is git, image, redeploy or rollback. trigger is push for the push webhook, rollback for a rollback, and manual for a request from you or a member of your organization. actor_type is user for a person signed in to Coritan, staff for a staff console session, webhook for a push, and admin when Coritan staff started it.

Its progress

status, in_flight while it is on its way, is_current while it serves the app, and can_rollback. replicas counts the replicas in provisioning, starting, healthy and unhealthy: starting counts the first two, and total all four.

What went wrong

When a deployment fails or is cancelled, its error says why. A deployment that went live without a region also says so there.

The build

For a git deployment, its build's status (queued, running, succeeded, failed or canceled), its strategy (dockerfile or railpack), how many attempts it took, and when it started and finished. A build that stops reporting is tried once more.

In each replica, health_failures counts its failed health checks in a row, and drained_at is when it stopped taking requests.

GET /api/v1/client/apps/{app_uuid}/deployments/{deployment_uuid}/log returns the end of the build log:

curl https://api.coritan.com/api/v1/client/apps/3c9e2f4a-8b1d-4f6e-a2c7-5d8b9e0f1a21/deployments/1d7b4e9a-5c2f-4a8e-9d6b-2f8e5a1c7b11/log \
  -H "Authorization: Bearer $CORITAN_TOKEN"

{
  "build": {"uuid": "e2a9c4d1-3b5f-4e7a-9c8d-1f2e3a4b5c6d", "status": "succeeded", "strategy": "railpack"},
  "log": "[builder] Fetching https://github.com/example/web-shop main at 9f2c1e7b4a6d.\n[builder] Checked out 9f2c1e7b4a6d.\n[builder] Planning the build with Railpack.\n...",
  "log_bytes": 48211,
  "truncated": false
}

log is the text, up to 64 KB. log_bytes is how much the build wrote in all, and truncated is true when that is more than log holds. An image deployment answers {"build": null, "log": "", "log_bytes": 0, "truncated": false}. The log grows while the build runs, so read it again to see new lines.