Deploying services
This guide walks you through deploying a service to Forte, end to end. Use the web console or the CLI — choose the tab that matches your workflow.
Prerequisites
- A Forte account
- A GitHub repository with your code
- The Forte GitHub App installed on your repository
If you prefer the CLI, install the Forte CLI before continuing.
Step 1: Create a Project
Projects group related services. You need at least one project before creating a service.
- Open the Forte Console and click Create Project from the dashboard.
- Enter a name for your project (for example,
my-app). - Click Create.
Your new project appears in the sidebar project picker.
Open Console →Step 2: Create a Service
A Service connects a GitHub repository to Forte's deployment pipeline. By default, each push to the configured branch triggers a deployment.
- Select your project from the sidebar, then navigate to Services.
- Click Create Service to open the creation form.
- Fill in the service details:
Service Details
Enter the details for your new service
GitHub Repository
GitHub Branch
What is this service for?
- Service Name — A unique name within the project (for example,
my-api-service). - GitHub Repository — Select from repositories where the Forte GitHub App is installed.
- GitHub Branch — The branch to deploy from (typically
main). - Usage Tier — Choose a tier that matches your workload. The Development tier is free and good for getting started.
- Click Create Service to start the first deployment.
Step 3: Watch your deployment
After you create the service, Forte starts the first build and deployment automatically. Follow along in real time.
Navigate to your service's detail page. The Deployments tab shows:
- Build status — Live logs as your container image is built.
- Deploy status — Progress as the image is pushed to the container registry and rolled out.
- Service URL — Once healthy, your service's public endpoint appears at the top.
Forte deploys when you push to the configured branch. Each push triggers a build and rollout.
What happens behind the scenes
When you create a service, Forte runs a multi-stage pipeline:
- Containerization — If your repository already includes a Dockerfile, Forte uses it as-is. If not, Forte auto-detects your language and framework and generates a Dockerfile — no configuration needed.
- Image build — Forte builds your code into a container image in a Linux environment. Environment variables configured on the service are available during the build as build arguments, so dependencies that need non-sensitive configuration (for example, feature flags or public API URLs) can read them. Secrets are not injected into the build environment — they're runtime-only, so they can't leak into build logs or image layers. If a build step needs a credential (for example, a private npm registry token), use an environment variable. Docker-in-Docker is supported, so you can use libraries like TestContainers from within your build. Builds time out after 30 minutes.
- Health check discovery — Your app must expose an HTTP GET route that returns a success status, such as
/health,/status, or/. Forte detects the port your app listens on and discovers the health check path. This is required for your deployment to succeed. - Deployment — Forte deploys the image to its infrastructure with autoscaling based on your selected tier.
- DNS & TLS — Forte provisions a permanent HTTPS endpoint on the
tryforte.devdomain. This URL never changes for the lifetime of your service. - DDoS protection — Forte automatically protects your service against distributed denial-of-service attacks. It monitors traffic and mitigates malicious requests before they reach your app.
Forte logs each step on the service's deployment detail page.
Re-detecting build configuration
Forte caches your service's Dockerfile and health check configuration after the first deployment so later builds are fast. If something structural changes — your app's port, runtime version, base image, build dependencies, or project layout — you can ask Forte to discard the cached configuration and re-detect it on the next deployment.
- Open your service in the Forte Console and click Edit Service.
- Scroll to Advanced Settings.
- Toggle the relevant switch:
- Reset Dockerfile — Discards the cached Dockerfile so Forte detects or generates a new one on the next deployment.
- Reset to auto-detect (under Health Check Configuration) — Discards the cached health check port and path so Forte re-detects them on the next deployment.
- Click Save Changes. Forte starts a new deployment automatically using the refreshed configuration.
Routine code changes don't require a reset — Forte continues to use your existing Dockerfile and health check on every push. Reset only when something about your build environment has changed in a way the existing configuration can't handle.
GitHub deployment status
Forte automatically reports deployment status back to your GitHub repository using GitHub Deployments. No configuration is required — this works out of the box for any service connected to a GitHub repository.
For each deployment, Forte:
- Creates a GitHub Deployment linked to the commit (or branch HEAD for manual triggers).
- Posts status updates as the pipeline progresses:
in_progresswhen the build starts, andsuccessorfailurewhen it completes. - Links back to the Forte Console — each status includes a link to the deployment detail page with full build logs.
The deployment environment name in GitHub is set to your service name, so you can track deployment history per service directly in your repository's Environments tab.
GitHub deployment status reporting is best-effort. If reporting fails (for example, a GitHub API issue), your build and deployment continue normally.