# What Diagram Types Does Archify Support? Complete Guide to the 5 Core Schemas

> Explore Archify's 5 core diagram types: architecture, workflow, sequence, dataflow, and lifecycle. Discover how each is validated by dedicated JSON schemas. Get the complete guide today.

- Repository: [tt-a1i/archify](https://github.com/tt-a1i/archify)
- Tags: complete-guide
- Published: 2026-08-29

---

**Archify supports five diagram types—architecture, workflow, sequence, dataflow, and lifecycle—each validated against dedicated JSON schemas in the `archify/schemas/` directory.**

Archify is an open-source diagramming engine that converts structured JSON into technical visualizations. The `tt-a1i/archify` repository defines exactly five valid `diagram_type` values, with strict schema validation enforced through individual JSON Schema files located in the `archify/schemas/` path.

## The Five Diagram Types Supported by Archify

The following diagram types represent the complete set of visualizations that Archify can generate. Each type requires a specific JSON structure defined in its corresponding schema file.

### Architecture Diagrams

Architecture diagrams visualize system components, their boundaries, and the connections between them. According to [`archify/schemas/architecture.schema.json`](https://github.com/tt-a1i/archify/blob/main/archify/schemas/architecture.schema.json), these diagrams require `components` and `connections` arrays to define the system topology.

```json
{
  "schema_version": 1,
  "diagram_type": "architecture",
  "meta": { "title": "My System Architecture" },
  "components": [{ "id": "svc-A", "label": "Service A" }],
  "connections": [{ "from": "svc-A", "to": "svc-B" }]
}

```

### Workflow Diagrams

Workflow diagrams depict lanes, phases, groups, and the main execution path of a process. The schema in [`archify/schemas/workflow.schema.json`](https://github.com/tt-a1i/archify/blob/main/archify/schemas/workflow.schema.json) supports complex business process modeling with swimlane visualization.

```json
{
  "schema_version": 1,
  "diagram_type": "workflow",
  "meta": { "title": "Order Fulfilment Workflow" },
  "lanes": ["User", "Backend", "Payments"],
  "phases": ["Receive", "Process", "Ship"],
  "nodes": [{ "id": "order", "label": "Create Order" }],
  "edges": [{ "from": "order", "to": "payment" }]
}

```

### Sequence Diagrams

Sequence diagrams visualize participants, message exchanges, and activations following the classic UML sequence diagram pattern. The [`archify/schemas/sequence.schema.json`](https://github.com/tt-a1i/archify/blob/main/archify/schemas/sequence.schema.json) file defines structures for `participants` and `messages` arrays.

```json
{
  "schema_version": 1,
  "diagram_type": "sequence",
  "meta": { "title": "Login Sequence" },
  "participants": ["Client", "Auth Service", "Database"],
  "messages": [
    { "from": "Client", "to": "Auth Service", "label": "login()" },
    { "from": "Auth Service", "to": "Database", "label": "SELECT" }
  ]
}

```

### Dataflow Diagrams

Dataflow diagrams illustrate stages, nodes, and the flow of data between them, commonly used for ETL processes and data pipeline documentation. The schema is defined in [`archify/schemas/dataflow.schema.json`](https://github.com/tt-a1i/archify/blob/main/archify/schemas/dataflow.schema.json).

```json
{
  "schema_version": 1,
  "diagram_type": "dataflow",
  "meta": { "title": "ETL Data Flow" },
  "stages": ["Extract", "Transform", "Load"],
  "nodes": [{ "id": "src", "label": "Source DB" }],
  "flows": [{ "from": "src", "to": "transform" }]
}

```

### Lifecycle Diagrams

Lifecycle diagrams represent lanes, states, and transitions of a lifecycle model, ideal for feature development lifecycles or state machines. The [`archify/schemas/lifecycle.schema.json`](https://github.com/tt-a1i/archify/blob/main/archify/schemas/lifecycle.schema.json) file validates `states` and `transitions` properties.

```json
{
  "schema_version": 1,
  "diagram_type": "lifecycle",
  "meta": { "title": "Feature Lifecycle" },
  "lanes": ["Dev", "QA", "Prod"],
  "states": ["Proposed", "Implemented", "Released"],
  "transitions": [{ "from": "Proposed", "to": "Implemented" }]
}

```

## Schema Validation and Structure

Each diagram type supported by Archify enforces strict validation through JSON Schema files stored in the `archify/schemas/` directory. The [`archify/schemas/README.md`](https://github.com/tt-a1i/archify/blob/main/archify/schemas/README.md) file provides the authoritative mapping of `diagram_type` values to their required fields and validation rules.

All JSON inputs must include:

1. `schema_version`: Currently set to `1` for all diagram types
2. `diagram_type`: One of the five supported type identifiers
3. `meta`: Metadata object containing at minimum a `title` field

## Rendering Diagrams via CLI

To generate visualizations, save your JSON following one of the five schemas and execute the Archify CLI. The tool automatically detects the diagram type from the JSON and applies the appropriate rendering rules.

```bash
archify render my-diagram.architecture.json

```

## Summary

- **Archify supports five diagram types**: architecture, workflow, sequence, dataflow, and lifecycle.
- **Each type has a dedicated schema**: Located in `archify/schemas/[type].schema.json` with strict validation rules.
- **JSON structure varies by type**: Architecture uses `components` and `connections`, while sequence uses `participants` and `messages`.
- **Schema documentation**: The complete list of allowed values and fields is documented in [`archify/schemas/README.md`](https://github.com/tt-a1i/archify/blob/main/archify/schemas/README.md).
- **CLI rendering**: Use `archify render` with a JSON file following any of the five supported schemas.

## Frequently Asked Questions

### How do I specify which diagram type to use in Archify?

Set the `diagram_type` field in your JSON input to one of the five supported values: `architecture`, `workflow`, `sequence`, `dataflow`, or `lifecycle`. This value must match the corresponding schema file in `archify/schemas/` for validation to pass.

### Where are the JSON schema definitions located?

According to the `tt-a1i/archify` source code, schema definitions reside in the `archify/schemas/` directory, with individual files like [`architecture.schema.json`](https://github.com/tt-a1i/archify/blob/main/architecture.schema.json) and [`sequence.schema.json`](https://github.com/tt-a1i/archify/blob/main/sequence.schema.json). The [`README.md`](https://github.com/tt-a1i/archify/blob/main/README.md) file in that directory provides a complete mapping of diagram types to their required fields.

### Can I extend Archify with custom diagram types?

The current implementation supports only the five built-in schemas defined in the repository. Each diagram type enforces strict validation rules, and the codebase does not expose extension points for custom schemas without modifying the core validation logic.

### Which diagram type should I use for microservices communication?

Use the **sequence** diagram type to visualize synchronous request-response patterns between microservices, or choose **architecture** for static component boundaries and connection topology. The sequence schema in [`archify/schemas/sequence.schema.json`](https://github.com/tt-a1i/archify/blob/main/archify/schemas/sequence.schema.json) specifically supports participants and message exchanges ideal for API interactions.