Monorepo deployment guide

# Deploy a monorepo: multiple services from one repository

Deploy a monorepo on Deplomo: run multiple services from one repository with Turborepo and pnpm workspaces. Set the root directory, Dockerfile path, and build context, then deploy with the CLI.

Short answer

For each app in the monorepo, such as `apps/web` or `apps/api`, create a separate service on the cloud platform. Connect each app to the same repository and branch. Set the Root Directory to choose where to build from, and use Watch Paths to avoid deploying unaffected services. Browse [Deployment guide](/guides) all the deployment guides.

Last reviewed:6 September 2026

## How monorepo deployments work on Deplomo

A single repository can contain multiple services. Each app in a multi-service deployment has its own build and run commands, environment variables, domain, and scaling settings, while all the services belong to one shared project:

```
repo/
├── apps/
│   ├── web/       # frontend service
│   └── api/       # backend service
├── packages/
│   └── shared/    # shared code package
├── package.json
└── pnpm-lock.yaml
```

## Set the root directory, Dockerfile path, and build context

- **Root Directory:** Path to the app directory relative to the repository root. For example, `apps/api`. Stack detection and scripts start from this directory.

- **Dockerfile path:** Path to the Dockerfile relative to the repository root, for example `apps/api/Dockerfile`. If you need a dedicated isolated environment, use the advanced Deplomo [Cloud containers](/products/containers) platform.

- **Build Context:** value `.` This makes shared root files and the lockfile available to the `COPY` Docker build.

## Deploy Turborepo and workspaces with shared packages

When deploying a Turborepo, if apps need code from the `packages/shared` directory, set the build context to the repository root:

```
# Configure deployment in the Deplomo dashboard
Root Directory:    apps/api
Dockerfile path:   apps/api/Dockerfile
Build Context:     .
Watch Paths:
  apps/api/**
  packages/shared/**
  pnpm-lock.yaml
```

With this setting, changes in shared packages will automatically rebuild all dependent services.

## Watch Paths: avoid unnecessary builds

A Git-connected service is redeployed only when changed files match its Watch Paths patterns:

- `apps/api/**` Covers all API files and subfolders.

- `packages/shared/**` Monitors changes to shared libraries.

- Including the lockfile name at the repository root ensures dependency updates trigger a build.

## Deploy multiple services with the Deplomo CLI

Use the Deplomo CLI to deploy monorepo services from your local machine:

```
cd repo
deplomo deploy . \
  --name api \
  --root-dir apps/api \
  --dockerfile apps/api/Dockerfile \
  --build-context . \
  --port 8080
```

## Frequently asked questions

### What is a monorepo, and how can it help development teams?

A monorepo is a code management strategy that keeps multiple independent software projects and services in a single Git repository. It makes it easier to share code, coordinate packages, and make large-scale changes.

### How do you deploy a monorepo on Deplomo?

Connect the repository, then create a separate service for each app and set its Root Directory. Watch Paths detect changes and trigger builds and deployments only for affected services.

### Are Turborepo and pnpm workspaces supported?

Yes. Turborepo and pnpm, Yarn, and npm workspaces are supported when you set the correct Build Context, so each service can access root files and shared packages.

### How does deploying multiple services from a single repository affect resource consumption?

Each service in a multi-service project runs in its own container with allocated CPU and RAM. The combined resources count towards your fixed monthly package limits for the selected zone.