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

# Deploying a generated app

> Running what cordango build produces.

```bash theme={null}
cordango build --app support --target dotnet-vue
```

What lands in `generated/support/` is an ordinary ASP.NET Core, EF Core, PostgreSQL, Vue 3 and Vuetify project.
No license server, no account, no model API, no runtime dependency on Cordango. It keeps working
whether or not this project does.

## Run it

```bash theme={null}
cd generated/support
docker compose up
```

The scaffold ships its own `docker-compose.yml` with the database alongside the application.

## The first screen creates the administrator

There's no default password, and nothing printed to a log. A password delivered by a log line isn't
really delivered. It sits in a scrollback, a log aggregator and a CI artifact, and nobody ever
rotates it.

So the first screen asks you to create the account instead. Once that's happened, the endpoint that
creates it **closes for good**.

> [!WARNING]
>
> Reach the application before anyone else does. Between first start and first account, that endpoint
> is open to whoever gets there. On a laptop this is nothing. On a public address, start it closed to
> the world and open it once you have signed in.

## The key ring lives on the volume

Data protection keys have to persist. If they live inside the container, every restart invalidates
every existing session and every token signed with them.

The generated compose file puts them on a volume. Keep that arrangement when you move to whatever
you actually deploy on, and back that volume up with the database rather than separately from it.

## Migrations

The generated project includes an EF Core migration for the schema its definition describes. It's
certified, meaning regenerating it produces an empty diff, so what sits in the project is exactly
what the model implies.

Change the app, regenerate, and you get a new migration. Review it like any other. A generated
migration is still a migration, and it still runs against real data.

## Choosing how the runtime arrives

**default** `NuGet reference`

`Cordango.Standalone` is restored from NuGet, pinned to the version of the generator that wrote the
project file. The repository then holds your application and nothing else.

**--runtime source** `source`

Emits `Cordango.Standalone` as a `runtime/` project beside `api/` instead. Nothing to restore and
no feed to depend on, at the cost of twenty files of ours in front of yours.

Take the default unless you have a reason. Either way the runtime is Apache-2.0 and its source is
public, so what you generate outlives its generator: `--runtime source` is a switch you can throw
later, not a decision you are locked out of.

## Seed data

```bash theme={null}
cordango build --app support --target dotnet-vue --seed 7
```

Deterministic demo data. The same seed produces the same dataset, which is what you want for a demo
environment, or for a screenshot that has to look the same next week.

It's demo data. Don't ship it to production, and don't build a report against it.

> [!NOTE]
>
> **Platform features need a Cordango workspace.**
> [Sign up here](https://www.cordango.com/start/) and create one in a few minutes.

## Publishing to the Platform instead

Generating is one of two destinations. The other is an instance:

```bash theme={null}
cordango publish --app support
```

Same definition, different target. See [Publishing](https://docs.cordango.com/cli/publish.md).


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.