Understanding Deployments
Learn what deployments are in Devpilot, how the deployment lifecycle works, what hooks do, and how to monitor deployments in real time.
Understanding Deployments
A deployment in Devpilot takes your application code from a Git repository and delivers it to a server where it runs. Every time you push changes and want them reflected on your server, you trigger a deployment. Devpilot handles the entire process — pulling your code, running your configured hooks, activating the new release, and tracking the outcome — while you monitor progress in real time.
What makes up a deployment
Each deployment in Devpilot tracks the following information:
- Branch — The Git branch from which the code is pulled (for example,
main,staging, orfeature/login). - Commit — The commit hash, commit URL, committer name, and committer email associated with the deployment.
- Provider and repository — The Git provider (GitHub, GitLab, or Bitbucket) and the repository the code came from.
- Duration — How long the deployment took from start to finish, recorded when the deployment ends.
- Logs — A console record of every hook that ran during the deployment, including output, exit codes, and per-hook durations.
- Status — The current state of the deployment (see Deployment Statuses below).
- Progress — A percentage indicator showing how far the deployment has progressed through its configured hooks.
- Live flag — A marker indicating whether this deployment is the currently active release on the server.
The deployment lifecycle
Every deployment moves through five ordered stages. At each stage, Devpilot executes the deployment hooks you have configured for that stage, in priority order. If a stage has no hooks, Devpilot moves on to the next one.
Pre Execution
Runs before anything else in the deployment. Use this stage for environment checks, notifications that a deployment is starting, or preparing directories on the server.
Pre Source Control
Runs right before Devpilot fetches your code. Use this stage for last-minute branch checks, pausing traffic, or announcing the upcoming release.
Post Source Control
Runs right after the repository is fetched into a new release directory. Use this stage for tasks that depend on having the source code present but should happen before the main setup work — syncing environment files, installing Composer dependencies, or copying shared assets.
Post Setup
Runs after the app's runtime is set up (dependencies installed, assets built). Use this stage for running database migrations, seeding data, clearing framework caches, and syncing persistent directories such as storage or vendor from shared locations.
Post Release
Runs after the new release is made live. Use this stage to restart application processes, reload Docker containers, run final post-activation migrations, or send deployment notifications.
You do not need to configure hooks for every stage. Devpilot skips any stage that has no active hooks assigned. Most applications do most of their work in the Post Setup stage.
Deployment statuses
Every deployment has a status that tells you where it stands:
| Status | Meaning |
|---|---|
| Pending | The deployment has been queued but has not started running yet. |
| Processing | The deployment is actively executing. Hooks are running on the server and live output streams to the deployment view. |
| Completed | All hooks finished without errors. If this deployment was also activated, it is marked as the Live release. |
| Failed | A hook returned a non-zero exit code or timed out. The deployment stopped at the hook where the failure occurred. The previous live release remains active. |
| Cancelled | The deployment was manually cancelled by a user before it completed. In-progress commands are terminated. |
In addition to status, each deployment carries a Live flag. Only one deployment per application is marked Live at any given time — this is the release currently serving traffic.
When a deployment fails, Devpilot does not activate the new release. Your previous live deployment remains in place so your application stays available. Use the Deployment Diagnosis feature to understand what went wrong.
Real-time progress tracking
Devpilot streams deployment output to your browser in real time. As each hook executes, you see:
- Live console output — Every line of output from your commands appears in the log viewer as it happens, along with the exit code once the hook finishes.
- Per-hook status — Each hook shows one of Pending, Processing, Successful, Failed, or Skipped so you can tell exactly which hooks have run and which are still waiting.
- Stage indicators — The current deployment stage is highlighted, and completed stages are marked as finished.
- Progress percentage — A progress bar fills as hooks complete, giving you a quick visual indicator of how far along the deployment is.
- Elapsed time — A running timer shows how long the deployment has been running.
The log viewer auto-updates as new output arrives. You can scroll up to review earlier output without losing your place.
Cancelling a deployment
If you need to stop a deployment that is in progress, click the Cancel button in the deployment detail view. Devpilot terminates any running processes and marks the deployment as Cancelled. The previous live deployment remains active.
Cancellation is useful when you notice incorrect output in the logs, realize you deployed the wrong branch, or need to halt a deployment that is taking too long.
Connecting your repository
Before you can deploy, your application needs a connected Git repository. Devpilot supports three repository providers:
GitHub
Connect your GitHub account through OAuth. Devpilot can access your personal repositories and any organization repositories you have authorized.
GitLab
Connect your GitLab account to pull from repositories hosted on GitLab.com or a self-managed GitLab instance.
Bitbucket
Connect your Bitbucket account to deploy from repositories hosted on Bitbucket Cloud.
Repository connections are configured at the application level. Once connected, Devpilot can pull code from any branch in that repository when you trigger a deployment.
Next steps
Your First Deployment
Follow a step-by-step tutorial to deploy your first application from start to finish.
Deployment Hooks
Learn how to configure the commands that run at each stage of the deployment lifecycle.
Rollback and Recovery
Understand how to revert to a previous deployment when something goes wrong.
Deployment Diagnosis
Use AI-powered analysis to understand and fix deployment failures.
App Configuration
Configure platforms, runtime versions, build commands, and process settings for your Devpilot apps.
Your First Deployment
A step-by-step tutorial that walks you through connecting a repository, configuring deployment hooks, deploying your application, and monitoring progress in Devpilot.