# Archify Diagram Types: 5 Technical Diagrams Supported by the AI Generator

> Discover Archify's 5 AI-generated diagram types: Architecture, Workflow, Sequence, Data Flow, and Lifecycle. Ensure accuracy with type-safe JSON schemas for superior technical documentation.

- Repository: [tt-a1i/archify](https://github.com/tt-a1i/archify)
- Tags: getting-started
- Published: 2026-07-13

---

**Archify supports five distinct diagram types—Architecture, Workflow, Sequence, Data Flow, and Lifecycle—each backed by dedicated JSON schemas for type-safe validation and rendering.**

Archify is an open-source diagram generation tool from the `tt-a1i/archify` repository that transforms structured JSON input into self-contained HTML/SVG visualizations. Understanding the diagram types supported by Archify helps developers choose the right visualization for system documentation, API design, and process modeling.

## The Five Diagram Types Supported by Archify

The project defines five specialized diagram formats in `archify/schemas/`, each optimized for specific technical communication needs.

### Architecture Diagrams

**Architecture diagrams** visualize high-level system components including cloud resources, databases, caches, services, and security boundaries. These are ideal for infrastructure overviews and deployment documentation.

The structure is governed by [`archify/schemas/architecture.schema.json`](https://github.com/tt-a1i/archify/blob/main/archify/schemas/architecture.schema.json), which validates components like nodes, connections, and security groups before rendering.

Example prompt:

```text
Use archify to draw an architecture diagram:
React frontend calls a Node.js API backed by PostgreSQL and Redis, deployed on AWS behind CloudFront.

```

### Workflow Diagrams

**Workflow diagrams** map request lifecycles, approval flows, CI/CD pipelines, and agent tool chains. These charts emphasize step order and decision branches rather than temporal sequences.

Validation occurs against [`archify/schemas/workflow.schema.json`](https://github.com/tt-a1i/archify/blob/main/archify/schemas/workflow.schema.json), ensuring proper node connections and state transitions.

Example prompt:

```text
Use archify to draw a workflow:
User submits a request → Agent plans → Approval gate (if needed) → Tool call → Trace log → Final reply.

```

### Sequence Diagrams

**Sequence diagrams** illustrate API call chains, async traces, cache fallback patterns, and service interactions with strict temporal ordering. These focus on "who calls whom" and response flows.

The schema at [`archify/schemas/sequence.schema.json`](https://github.com/tt-a1i/archify/blob/main/archify/schemas/sequence.schema.json) enforces participant definitions and message ordering.

Example prompt:

```text
Use archify to draw a sequence diagram:
User opens a page, the frontend calls the API, the API verifies JWT, reads Redis, falls back to PostgreSQL on cache miss, returns JSON, and emits trace.

```

### Data Flow Diagrams

**Data flow diagrams** track pipelines, ETL/ELT processes, analytics events, PII isolation boundaries, and warehouse synchronization. These visualize how data moves through systems with sensitivity classifications.

Schema validation happens via [`archify/schemas/dataflow.schema.json`](https://github.com/tt-a1i/archify/blob/main/archify/schemas/dataflow.schema.json).

Example prompt:

```text
Use archify to draw a data flow:
Web and mobile emit analytics events → Edge API collects them → Consent gate filters PII → Kafka carries accepted events → Warehouse stores analytics tables → Feature store derives daily features → Dashboards and ML model consume downstream data.

```

### Lifecycle Diagrams

**Lifecycle diagrams** model state machines for orders, tasks, deployments, or agent runs, including wait states, retry paths, and terminal conditions. These visualize state transitions rather than linear flows.

The schema at [`archify/schemas/lifecycle.schema.json`](https://github.com/tt-a1i/archify/blob/main/archify/schemas/lifecycle.schema.json) validates state definitions, transition events, and terminal outcomes.

Example prompt:

```text
Use archify to draw a lifecycle diagram:
Agent run starts at Queued, moves through Planning, Executing, and Reviewing. It can pause at Needs Approval, wait at Blocked, retry after Failed, end at Cancelled or Expired, or finish at Completed.

```

## Schema Validation and Type Safety

Each diagram type supported by Archify uses a dedicated JSON schema to enforce structure before rendering. Located in `archify/schemas/`, these files prevent invalid intermediate representations from reaching the rendering engine:

- Architecture: [`architecture.schema.json`](https://github.com/tt-a1i/archify/blob/main/architecture.schema.json)
- Workflow: [`workflow.schema.json`](https://github.com/tt-a1i/archify/blob/main/workflow.schema.json)
- Sequence: [`sequence.schema.json`](https://github.com/tt-a1i/archify/blob/main/sequence.schema.json)
- Data Flow: [`dataflow.schema.json`](https://github.com/tt-a1i/archify/blob/main/dataflow.schema.json)
- Lifecycle: [`lifecycle.schema.json`](https://github.com/tt-a1i/archify/blob/main/lifecycle.schema.json)

This schema-first approach ensures that the CLI tool at `bin/archify.mjs` can validate inputs early and provide clear error messages when diagram structure violates type constraints.

## Generating Diagrams via CLI

You can generate any of the five diagram types using the Archify CLI. First install the skill:

```bash
npx skills add tt-a1i/archify -g

```

Then render specific diagram types:

```bash
node bin/archify.mjs render workflow examples/agent-tool-call.workflow.json workflow.html

```

The repository includes working examples for each diagram type:

- Architecture: [`examples/web-app.html`](https://github.com/tt-a1i/archify/blob/main/examples/web-app.html)
- Workflow: [`examples/workflow-agent-tool-call-rendered.html`](https://github.com/tt-a1i/archify/blob/main/examples/workflow-agent-tool-call-rendered.html)
- Sequence: [`examples/sequence-cache-miss-request.html`](https://github.com/tt-a1i/archify/blob/main/examples/sequence-cache-miss-request.html)
- Data Flow: [`examples/dataflow-product-analytics.html`](https://github.com/tt-a1i/archify/blob/main/examples/dataflow-product-analytics.html)
- Lifecycle: [`examples/lifecycle-agent-run.html`](https://github.com/tt-a1i/archify/blob/main/examples/lifecycle-agent-run.html)

## Summary

- Archify supports **five diagram types**: Architecture, Workflow, Sequence, Data Flow, and Lifecycle diagrams.
- Each diagram type has a **dedicated JSON schema** in `archify/schemas/` for input validation.
- **Architecture diagrams** show system components and cloud infrastructure.
- **Workflow diagrams** depict approval flows and CI/CD pipelines.
- **Sequence diagrams** trace API calls and service interactions chronologically.
- **Data Flow diagrams** map ETL pipelines and data sensitivity boundaries.
- **Lifecycle diagrams** model state machines with retry and terminal states.

## Frequently Asked Questions

### What file format does Archify use for diagram definitions?

Archify uses JSON Intermediate Representation (IR) files validated against type-specific schemas. Each diagram type requires a JSON file matching the structure defined in its corresponding schema file in `archify/schemas/`.

### Can I use Archify without installing it globally?

Yes. You can use `npx` to run Archify without permanent installation: `npx skills add tt-a1i/archify -g` installs the skill temporarily, or you can invoke the CLI directly via `node bin/archify.mjs` after cloning the repository.

### Which diagram type should I use for showing API authentication flows?

Use **Sequence diagrams** for API authentication flows. According to the [`sequence.schema.json`](https://github.com/tt-a1i/archify/blob/main/sequence.schema.json) specification, these diagrams excel at showing "who calls whom, in what order, and what returns"—perfect for JWT verification, cache lookups, and fallback chains.

### Where can I find example implementations of each diagram type?

Working examples for all five diagram types reside in the `examples/` directory. Key files include [`web-app.html`](https://github.com/tt-a1i/archify/blob/main/web-app.html) (Architecture), [`sequence-cache-miss-request.html`](https://github.com/tt-a1i/archify/blob/main/sequence-cache-miss-request.html) (Sequence), and [`lifecycle-agent-run.html`](https://github.com/tt-a1i/archify/blob/main/lifecycle-agent-run.html) (Lifecycle), demonstrating valid JSON IR structures for each type.