# What is tapstate? (https://tapstate.dev/docs/overview/what-is-tapstate)

## Agent metadata

- Content type: concept
- Identifier: what-is-tapstate
- Aliases: tapstate overview, unified operational data engine, operational state layer, capture transform serve, live operational state

Tapstate is an open-source unified operational data engine in preview. It builds and maintains live operational state—an Operational State Layer—for applications, APIs, automation, and AI agents. The Quickstart assembles MySQL orders and PostgreSQL shipments into a MongoDB document, then keeps it current with CDC.

- **Capture:** Load existing data, then follow committed changes.
- **Transform:** Filter, map, script, and merge data as it moves.
- **Serve:** Write current state to a downstream system.

[Run the Quickstart](https://tapstate.dev/docs/overview/quickstart) or [browse connectors](https://tapstate.dev/docs/connectors).

## Why operational data becomes difficult [#why-operational-data-becomes-difficult]

Keeping operational data fresh usually means assembling and operating separate CDC, broker, stream-processing, and serving systems:

### Operational data path comparison

| Approach | Data path | Operating model |
|---|---|---|
| The assembled stack | Source systems → Capture → Broker → Processing → Serving store → Apps, automation & agents | Separate tools and operating boundaries. |
| The tapstate target path | Source systems → tapstate (Capture · Transform · Serve) → Apps, automation & agents | Target Capture–Transform–Serve operating model. |

Each tool can be the right choice on its own. The operational cost comes from making the tools behave as one system: coordinating offsets, retries, schemas, serialization, upgrades, and observability across every boundary.

Composable streaming stacks remain the right choice when a workload requires a
highly customized event topology. Tapstate's target model focuses on teams whose
main requirement is to keep operational state current through one deployable
data path. See [Tapstate vs. a streaming stack](https://tapstate.dev/docs/overview/vs-streaming-stack)
for the tradeoffs.

## How tapstate works [#how-tapstate-works]

Capture, Transform, and Serve are three responsibilities in the same operational data path. They let you move from source changes to application-ready state without operating a separate product at every stage.

### Capture — load existing data, then follow changes [#capture--load-existing-data-then-follow-changes]

Capture loads an initial data set and, when the connector supports it, follows committed changes from database logs or later updates from streams, APIs, and files. Each connector guide describes the available capture modes and the preparation required by the source system.

### Transform — shape data incrementally as it moves [#transform--shape-data-incrementally-as-it-moves]

The current preview filters, maps, runs scripted transforms, merges streams,
and uses `nest` to maintain documents assembled from related tables. `join`
combines a fact stream with dimensions using a restricted SQL subset. See
[Transform reference](https://tapstate.dev/docs/reference/transforms#join) for its input and key requirements.

### Serve — deliver current state [#serve--deliver-current-state]

The current release includes `serve.sync` writes to a target connector. The v1
declaration model also contains `serve.query` and `serve.push`, but the current
preview does not execute them. The CLI, REST API, and MCP provide bounded
inspection instead of a stable application-facing data API.

## Current preview boundary [#current-preview-boundary]

Tapstate v0.6 runs as a single member by default and offers opt-in cluster
operation. It stores recovery positions and durable operator state in MongoDB;
recovery can replay records and does not provide exactly-once delivery.

Use the web application for the default interactive path. The Quickstart
captures MySQL orders and PostgreSQL shipments and assembles them into current
order documents. CLI, REST, and MCP support developers and automation.
See [Architecture](https://tapstate.dev/docs/overview/architecture) and the
[v0.6 limits](https://tapstate.dev/docs/releases/v0.6#known-limits-and-issues) before choosing a deployment.

## When to use tapstate [#when-to-use-tapstate]

Use tapstate when applications, APIs, automation, or AI agents depend on operational data that loses value when it becomes stale. Common examples include inventory availability, logistics tracking, fraud and risk signals, cross-system customer or account views, and AI agents that need current system-of-record data. See [Use cases](https://tapstate.dev/docs/overview/use-cases) for detailed patterns.

## How to use these docs [#how-to-use-these-docs]

The documentation follows the same path you use to build a data pipeline:

* **Prepare the current path.** Use the [connector directory](https://tapstate.dev/docs/connectors) to prepare MySQL, PostgreSQL, Oracle, and SQL Server capture with MongoDB materialization, and to distinguish current connectors from roadmap references.
* **Run the shortest path.** Use the [Quickstart](https://tapstate.dev/docs/overview/quickstart) with sample MySQL, PostgreSQL, and MongoDB data in Docker.
* **Explore the data model.** Change both sources in the [order-state demo](https://tapstate.dev/docs/overview/order-state-demo) and watch one assembled document stay current.
* **Automate when needed.** Developers can use the [offline walkthrough](https://tapstate.dev/docs/overview/create-workspace) to create and validate `.tap.yml` resources.
* **Look up exact syntax.** Use the [reference](https://tapstate.dev/docs/reference/dsl-grammar) for resource fields and examples.
* **Work with an AI assistant.** Use [`llms.txt`](https://tapstate.dev/llms.txt) or the page-level Markdown view to provide the same canonical content to an assistant.

## Next steps [#next-steps]

  - [Quickstart](https://tapstate.dev/docs/overview/quickstart): Explore MySQL and PostgreSQL CDC assembled into one document in Docker.


  - [Architecture](https://tapstate.dev/docs/overview/architecture): See how Capture, Transform, and Serve fit together.


  - [Use cases](https://tapstate.dev/docs/overview/use-cases): See where current operational data changes an application outcome.


  - [Connectors](https://tapstate.dev/docs/connectors): Browse connector maturity, roles, modes, and setup guidance.