---
title: "Inspect schema history"
description: "tide history lists schema versions, tide diff compares two, tide blame and tide owners attribute changes, and rollback restores an earlier snapshot."
---

> 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.

# Inspect schema history

`tide history` lists every version of your deployed schema, `tide diff`
compares two versions, `tide blame` and `tide owners` attribute each field
and entity to the caller that introduced it, and a rollback restores an
earlier snapshot.

> **Prerequisites**
>
> - At least one `tide apply` completed, so the registry has a version.
> - `tide` on `$PATH`, enrolled via `tide login`.

## 1. View history

```bash
tide history
```

Output, newest first:

```tideout
  Schema History

  ● v7  apply  vendor     2h ago
  │      +4 change(s)
  │
  ● v6  apply  consumer    22h ago
  │      +2 change(s)
  │
  ● v5  apply  vendor     Jun 12, 14:30
  │      +16 change(s)
  │
  ● v4  apply  auth        Jun 10, 11:00
  │      +1 change(s)
  │
  ● v3  apply  consumer    Jun 09, 09:55
  │      +1 change(s)
  │
  ● v2  apply  vendor     Jun 08, 16:20
  │      +36 change(s)
  │
  ◌ v1  seed   auth        Jun 07, 10:00
     no changes
```

Each row is one schema version, and the second column is the event that
wrote it: `apply`, `rollback`, `adopt`, or `seed`. A `seed` renders as ◌;
the other three render as ●. Timestamps under a day old are relative
(`2h ago`); older ones are absolute. Use `--limit=N` to show only the most
recent N versions.

```bash
tide history --limit=3
```

## 2. Compare versions

```bash
tide diff 3 7
```

Output:

```tideout
diff v3 → v7

─── vendor.VendorImport (new entity)
  + vendor_id       varchar(7)  not null
  + import_strategy varchar(20) not null
  + status          varchar(10) not null

─── consumer.Order
id              varchar(8) primary
user_id         varchar(8) not null
  + shipping_label  text
  - total           int not null
  + total           bigint not null

─── consumer.LegacyCart (removed)

+4 additive  ~1 backfill  ✗1 destructive
```

The diff is structural, not line-level. Each changed entity gets a `───`
header, suffixed `(new entity)` or `(removed)`; inside it, `+` marks an
added field, `-` a removed one, and a modified field prints as its old
line with `-` followed by its new line with `+`. Unchanged fields of a
changed entity print unmarked. The last line counts the changes per plan
class. Both version arguments are required.

## 3. Check ownership

```bash
tide owners
```

Output (one row per entity):

```tideout
ENTITY                           OWNER            SINCE   FIELDS
auth.User                        auth             v1      6
auth.Session                     auth             v1      4
auth.ApiKey                      auth             v4      3
consumer.Order                   consumer         v1      5
consumer.Invoice                 consumer         v3      4
vendor.Product                   vendor           v2      8
vendor.Variant                   vendor           v2      6
vendor.Collection                vendor           v2      5
vendor.VendorImport              vendor           v5      3
```

Each row shows which caller introduced the entity, the version it was
introduced in, and the current field count. Read this before a
cross-caller change: it names the caller that owns each entity.

## 4. Blame a field

```bash
tide blame consumer.Order
```

Output:

```tideout
Blame: consumer.Order

FIELD                    INTRODUCED BY    AT       MODIFIED BY      AT       STATUS
(entity)                 consumer         1        consumer         1        active
id                       consumer         1        consumer         1        active
user_id                  consumer         1        consumer         1        active
item_ids                 consumer         1        consumer         1        active
total                    consumer         3        consumer         3        active
shipping_label           vendor           5        vendor           5        active
```

Each row shows which caller introduced the field, who last modified it,
and whether it is still active. `shipping_label` was added by the `vendor`
caller in version 5. The server merges submissions from several callers,
so `git blame` on one repository's `.atl` file does not show this.

## 5. Roll back

Preview what a rollback would do:

```bash
tide rollback --to=5 --dry-run
```

Output:

```tideout
Rollback preview: v7 -> v5

3 change(s) would be applied.
  1 additive
  1 backfill_required
  1 destructive
(use without --dry-run to execute)
```

Executing the rollback happens in the console: the Operations page's
Rollback tab, `admin` role. The server refuses `tide rollback` without
`--dry-run` from a caller enrolment — executing it needs an operator
capability callers do not hold.

The rollback creates a new version whose IR snapshot matches the target —
version 8 here, matching version 5. The versions between remain in
history; nothing is deleted.

## Verify

```bash
tide history --limit=1
```

The newest row is the rollback's version:

```tideout
  ● v8  rollback  atlantis-console  just now
     +3 change(s)
```

## Common errors

- **`schema version N not found`** — no version with that number exists in
  the registry: a number above the latest, or an empty registry. Run
  `tide history` to see available versions.

## Related

- [Schema versioning](/concepts/schema-versioning/) — how the version registry works
- [The apply path](/concepts/how-atlantis-runs-your-schema/) — the checkpoint the history records.
- [Recover a dropped table](/guides/recover-a-dropped-table/) — when the version you want back parked something

Source: https://docs.tryatlantis.dev/guides/schema-history/index.mdx