---
title: "Get started"
description: "Install tide, sign up for Atlantis Cloud, create an organisation, connect a repository, and apply your first entity."
---

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

# Get started

From nothing to a schema change applied in production: install `tide`, sign
up for Atlantis Cloud, create an organisation, connect a repository, and
apply your first entity.

> **Prerequisites**
>
> - A Go service repository to hold the schema.
> - macOS or Linux on amd64 or arm64.

## 1. Install tide

```bash
curl -fsSL https://releases.tryatlantis.dev/install.sh | sh
```

The script verifies the release checksum and installs into `/usr/local/bin`
or `~/.local/bin`, whichever is writable first. Confirm the install:

```tideout title="tide version"
  ⊙
  tide  v0.4.0
```

## 2. Sign up and create an organisation

1. Sign up at Atlantis Cloud with your email, name, and a password, then
   open the verification link atlantis sends.
2. Set up two-factor authentication. Sign-in requires it, and your backup
   codes are shown exactly once — save them.
3. On the Organisations screen, create an organisation. The name is a DNS
   label: it starts with a letter or digit, then lowercase letters,
   digits, and hyphens, up to 63 characters. A few names — `admin`, `api`,
   `atlantis`, `console`, `support`, `system`, `www` — are reserved.
4. Wait for the organisation to report ready. Creating it provisions a
   dedicated database and server; the screen shows progress and links to
   the console when it is up.

## 3. Register a caller

A caller is a repository's identity at atlantis
([Manage members and callers](/guides/manage-members-and-callers/)).
In your organisation's console:

1. Open **Callers** and select **Add caller**.
2. Name the caller after the repository — `api`, for example — and enable
   mutate permission so it can plan and apply schema.

## 4. Connect the repository

In the repository root:

```bash
tide init --caller api
tide login
```

`tide init` writes `tide.yaml`, the repository's only atlantis
configuration file.
`tide login` opens your browser: sign in, type the code the terminal shows,
and approve the machine. The credential lands in `~/.atlantis/` and renews
itself.

## 5. Declare an entity

Create `schema.atl`:

```atl
entity Note in app {
  id         bigint primary serial
  title      varchar(200) not null
  created_at timestamptz not null default now()
}
```

## 6. Plan and apply

```bash
tide plan
tide apply
```

`tide apply` runs the migration and records the new schema version. An
additive change like this one applies unattended; a class that needs a
decision waits in the console's Approvals queue, and `tide apply` exits 2
to say the change is queued, not failed.

## Verify

```bash
tide list
```

```
schema.atl
```

`tide list` prints every file the server holds for this caller — the one
you just applied. The console's **Schema** page shows the entity with its
fields, and **History** shows the version your apply created.

## Next steps

- [Declare a custom query](/getting-started/your-first-custom-query/) — SQL the typed
  surface doesn't cover.
- [Generate the typed client](/concepts/the-generated-client/) — set
  `output_dir` in `tide.yaml` and run `tide generate`.
- [Add a new entity](/guides/add-a-new-entity/) — the full modifier
  tour: references, soft delete, tenant partitioning.
- [Set up CI](/guides/set-up-ci/) — plan on pull requests, apply on
  merge, no repository secrets.

Source: https://docs.tryatlantis.dev/getting-started/index.mdx