# Archify Component Types: The Complete Guide to Supported Architecture Diagram Elements

> Explore Archify's eight supported component types for architecture diagrams including cloud resources databases services security and more Discover the full range of elements for your diagrams

- Repository: [tt-a1i/archify](https://github.com/tt-a1i/archify)
- Tags: api-reference
- Published: 2026-09-01

---

**Archify supports eight built-in component types for architecture diagrams: cloud resources, databases, caches, services, security groups/boundaries, external clients, storage, and queue/message bus systems.**

The `tt-a1i/archify` tool uses a strict JSON schema to validate and render system architecture diagrams. Each component in your diagram must declare one of these standardized types, which determines its visual representation and semantic meaning in the final output.

## Complete List of Supported Component Types

Archify's **Architecture** diagram type enforces a typed taxonomy. According to the source documentation in [`docs/index.html`](https://github.com/tt-a1i/archify/blob/main/docs/index.html) lines 24-31, the following categories are available:

| Component Type | Represents | Typical Examples |
|----------------|-----------|----------------|
| **cloud** | Cloud-native infrastructure services | Load balancers, CDNs, Kubernetes clusters, serverless functions |
| **database** | Persistent data stores | PostgreSQL, MySQL, MongoDB, DynamoDB |
| **cache** | In-memory caching layers | Redis, Memcached, EC2 ElastiCache |
| **service** | Application logic and APIs | REST APIs, microservices, worker processes, gRPC services |
| **boundary** | Security zones and network controls | VPCs, security groups, firewalls, IAM policy boundaries |
| **external** | External actors and third-party systems | Web browsers, mobile apps, end users, SaaS integrations |
| **storage** | Object and file storage systems | S3 buckets, Azure Blob Storage, NFS servers |
| **queue** | Message brokers and streaming platforms | RabbitMQ, Kafka, SQS, background job queues |

These types are hardcoded into the validation schema at [`archify/schemas/architecture.schema.json`](https://github.com/tt-a1i/archify/blob/main/archify/schemas/architecture.schema.json). The compiler rejects any component with an unrecognized `type` value.

## Component Type Reference in the Schema

The authoritative source for supported types is [`archify/schemas/architecture.schema.json`](https://github.com/tt-a1i/archify/blob/main/archify/schemas/architecture.schema.json). This file defines the JSON Schema that the `workflow-compiler` enforces at build time.

The schema restricts the `type` property to an enumerated list. You cannot use arbitrary strings—only the eight values above pass validation. This design guarantees consistent visual semantics across all Archify diagrams.

Unit tests in `archify/test/workflow-compiler.test.mjs` verify this enforcement, ensuring that invalid component types trigger clear error messages during the `deliver` command.

## Practical Example: Declaring All Component Types

Here's a complete, runnable JSON document that exercises every supported Archify component type:

```json
{
  "meta": { "type": "architecture" },
  "components": [
    { "id": "users",   "type": "external",    "label": "Browser" },
    { "id": "cdn",     "type": "cloud",       "label": "CDN" },
    { "id": "lb",      "type": "cloud",       "label": "Load Balancer" },
    { "id": "api",     "type": "service",     "label": "API Service" },
    { "id": "db",      "type": "database",    "label": "PostgreSQL" },
    { "id": "cache",   "type": "cache",       "label": "Redis" },
    { "id": "queue",   "type": "queue",       "label": "RabbitMQ" },
    { "id": "storage", "type": "storage",     "label": "S3 Bucket" },
    { "id": "sg",      "type": "boundary",    "label": "Security Group" }
  ],
  "connections": [
    { "source": "users",   "target": "cdn",      "label": "HTTPS" },
    { "source": "cdn",     "target": "lb",       "label": "Route" },
    { "source": "lb",      "target": "api",      "label": "Forward" },
    { "source": "api",     "target": "db",       "label": "SQL" },
    { "source": "api",     "target": "cache",    "label": "Cache-Read" },
    { "source": "api",     "target": "queue",    "label": "Enqueue" },
    { "source": "api",     "target": "storage",  "label": "Static-Fetch" },
    { "source": "api",     "target": "sg",       "label": "Secured-By" }
  ]
}

```

Save this as [`arch-example.json`](https://github.com/tt-a1i/archify/blob/main/arch-example.json) and render it with the Archify CLI:

```bash
node archify/bin/archify.mjs deliver architecture arch-example.json out.html \
  --quality showcase --open

```

This command validates component types against the schema, then generates a self-contained HTML visualization with appropriate icons for each type.

## Key Files for Component Type Definitions

Understanding where Archify defines and enforces component types helps when debugging schema errors or extending the tool:

- **[`archify/schemas/architecture.schema.json`](https://github.com/tt-a1i/archify/blob/main/archify/schemas/architecture.schema.json)** — The canonical schema specifying allowed `type` values: `cloud`, `database`, `cache`, `service`, `boundary`, `external`, `storage`, `queue`

- **[`examples/archify-repo.architecture.json`](https://github.com/tt-a1i/archify/blob/main/examples/archify-repo.architecture.json)** — Production-ready example demonstrating component taxonomy in a real-world architecture

- **[`docs/index.html`](https://github.com/tt-a1i/archify/blob/main/docs/index.html)** (Architecture section) — Human-readable documentation describing each category, referenced at lines 24-31

- **`archify/test/workflow-compiler.test.mjs`** — Test coverage for schema enforcement and invalid type rejection

## Choosing the Right Component Type

Selecting the appropriate Archify component type improves diagram clarity:

- **cloud** vs. **service** — Use `cloud` for managed infrastructure you don't own (CDNs, load balancers); use `service` for code you've written (APIs, microservices)

- **boundary** — Apply to logical security perimeters rather than physical network gear. A VPC is a `boundary`; a firewall appliance is `cloud`

- **external** — Reserved for entities outside your system boundary. Internal mobile apps developed by your team are `service`; user devices running your app are `external`

The type determines iconography, color coding, and relationship semantics in the rendered output.

## Extending Component Types

The current Archify release does not support custom component types. The enumeration in [`architecture.schema.json`](https://github.com/tt-a1i/archify/blob/main/architecture.schema.json) is closed. If your architecture requires unrepresented concepts (e.g., machine learning models, blockchain nodes), map them to the nearest semantic equivalent:

- ML inference endpoints → `service`
- Model registries → `storage`
- Distributed ledgers → `database` or `service` depending on usage

Feature requests for additional types can be submitted to the `tt-a1i/archify` repository.

## Summary

- Archify supports **eight component types** for architecture diagrams: `cloud`, `database`, `cache`, `service`, `boundary`, `external`, `storage`, and `queue`

- Types are enforced by [`archify/schemas/architecture.schema.json`](https://github.com/tt-a1i/archify/blob/main/archify/schemas/architecture.schema.json) and validated at compile time

- Each type maps to distinct visual styling and semantic meaning in rendered diagrams

- The [`examples/archify-repo.architecture.json`](https://github.com/tt-a1i/archify/blob/main/examples/archify-repo.architecture.json) file provides a reference implementation

- No custom types are currently supported; use the nearest semantic match for unlisted components

## Frequently Asked Questions

### What happens if I use an unsupported component type in Archify?

The `workflow-compiler` will reject your JSON with a schema validation error. Run `archify deliver` with the `--verbose` flag to see which component violates the allowed enumeration. Correct the `type` value to one of the eight supported options and re-run the command.

### Can I create custom component types in Archify?

No. The schema at [`archify/schemas/architecture.schema.json`](https://github.com/tt-a1i/archify/blob/main/archify/schemas/architecture.schema.json) uses a closed enumeration. You cannot extend the type system without modifying the source schema and rebuilding the compiler. Map unconventional components to existing types based on their functional role.

### Where can I see component types used in a real architecture?

The [`examples/archify-repo.architecture.json`](https://github.com/tt-a1i/archify/blob/main/examples/archify-repo.architecture.json) file in the repository demonstrates production usage of all eight types. Study this file alongside the rendered output from `archify deliver architecture examples/archify-repo.architecture.json` to understand visual conventions for each category.