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

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

{
  "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 and render it with the Archify CLI:

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 — The canonical schema specifying allowed type values: cloud, database, cache, service, boundary, external, storage, queue

• examples/archify-repo.architecture.json — Production-ready example demonstrating component taxonomy in a real-world architecture

• 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 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 and validated at compile time

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

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

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}