> ## Documentation Index
> Fetch the complete documentation index at: https://docs.goldsky.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Deploying and Monitoring

> Deploy Compose apps with goldsky compose deploy and monitor runs, logs, and state through the Goldsky webapp.

Once you've built your Compose App and tested it locally, deploy it. Your app runs in an isolated runtime environment
with a dedicated database. Environment variables and secrets you've provided are available to your app, and the durability engine resumes task execution
across restarts and rolling deploys. You can monitor your app via the Goldsky webapp.

### The `deploy` command

Deploy by running this command with a reference to your manifest file. The command is idempotent: it upserts your app to the cloud.

```bash theme={"dark"}
goldsky compose deploy
```

<Note>
  Your manifest must include an `api_version` field to deploy. This pins your app to a specific Compose runtime. Use `"stable"` if unsure. See [Release channels](./app-configuration#release-channels) for details.
</Note>

The Compose CLI extension provisions the necessary resources and launches your app based on your manifest. Once complete, cron tasks start and HTTP triggers become available. See [Task triggers](./task-triggers) for more information.

On success, `deploy` prints the URL of your app's dashboard.

### Hosted Postgres database

When you deploy, Compose automatically provisions a dedicated Postgres database for your app. This database is used for two things:

* **Your state.** Any [collections](./context/collections) you create in your tasks are stored here. You can query or inspect your own data directly.
* **Compose internal state.** Compose uses the same database to power durable execution (resuming tasks cleanly after crashes and rolling deploys), reorg monitoring for transactions, and wallet bookkeeping. These internal tables live in reserved namespaces and are managed by the runtime.

Because your app has its own database, your data is isolated from other apps and from Goldsky's own systems.

### Monitoring your app via the webapp

Like with our indexing products, you'll see your Compose Apps in the Goldsky webapp. From there you can view the app's status, recent task runs (with per-operation details: each `ctx.*` call a task made), and raw log output.
The URL for your app's dashboard is:

```
https://app.goldsky.com/{projectId}/dashboard/compose/{appName}
```

#### Viewing and downloading deployed source

When you deploy, the CLI uploads your app's full local source tree: the transitive local import closure, `package.json` and lockfile, `tsconfig.json`, and everything under `src/contracts/`. `node_modules`, `.env*`, and files that look like keys or secrets are excluded.

The dashboard's Code tab is a file browser over that source tree. The Download app button produces a zip that is a runnable local Compose project, including a names-only `.env.example`.

Apps deployed before source capture existed show per-task compiled bundles instead of original sources. Redeploy with a current CLI to get full fidelity. Very large projects may skip source capture, in which case the CLI warns at deploy time and the dashboard falls back to the same per-task bundles.

The CLI equivalents are [`goldsky compose source`](./cli-reference#inspecting-a-deployed-app) and [`goldsky compose download`](./cli-reference#inspecting-a-deployed-app); see [App lifecycle](./app-lifecycle#view-and-download-deployed-source) for the workflow.

### Managing a deployed app from the CLI

For day-to-day app management from the terminal, use the [lifecycle commands](./app-lifecycle):

```bash theme={"dark"}
goldsky compose status   # runtime status
goldsky compose list     # all apps in your project
goldsky compose logs -f  # tail logs
goldsky compose pause    # stop triggers without deleting state
goldsky compose resume
goldsky compose delete   # delete the app (and optionally the database)
```

### Deleting a Compose app

You can delete a Compose app either from the webapp (navigate to the app's dashboard and click **Delete**) or from the CLI:

```bash theme={"dark"}
goldsky compose delete
```

Both paths require you to type the app name to confirm. See [App lifecycle](./app-lifecycle#delete-an-app) for CLI flags.

#### Database management options

When deleting a Compose app that uses a hosted Postgres database, you can choose whether to keep or delete the associated database:

* **Delete associated database**: The hosted Postgres database will be permanently deleted along with the app and all its data. This is the default in the webapp modal ("Delete associated database" is pre-checked). From the CLI, pass `--delete-database` or answer the interactive prompt to opt in.
* **Keep database**: Preserve the database when deleting the app. This is useful if you want to retain your data for analysis or migrate it to another app. This is the default in the CLI; in the webapp, uncheck "Delete associated database" before confirming.

<Warning>
  Database deletion is permanent and cannot be undone. Make sure to back up any important data before deleting.
</Warning>

#### Pipeline validation

If you choose to delete the associated database, Compose checks whether any active pipelines use it. If one or more pipelines reference the database, deletion is blocked and the error message lists the affected pipelines.

To proceed with database deletion in this case, you must first:

1. Delete or modify the pipelines that reference the database
2. Then retry deleting the Compose app with the database option selected

Alternatively, uncheck the "Delete associated database" option: the app is deleted but the database stays available to the existing pipelines.


## Related topics

- [Wallets and Secrets](/compose/secrets.md)
- [App Lifecycle](/compose/app-lifecycle.md)
- [Monitoring](/edge-rpc/platform/monitoring.md)
- [Live inspect](/turbo-pipelines/live-inspect.md)
- [Operating pipelines](/turbo-pipelines/guides/operating-pipelines.md)