# Can Arc-Kit Be Used for SSR? A Technical Analysis of Server-Side Rendering Capabilities

> Discover if Arc-kit supports SSR. Learn why this enterprise architecture toolkit isn't a web framework but excels in server-side CI/CD for documentation generation.

- Repository: [tractorjuice/arc-kit](https://github.com/tractorjuice/arc-kit)
- Tags: technical-analysis
- Published: 2026-04-19

---

**Arc-kit cannot be used for traditional SSR because it is an Enterprise Architecture governance toolkit, not a web framework, though it can run in server-side CI/CD environments to generate static documentation artefacts.**

Arc-kit is an AI-driven toolkit for Enterprise Architecture Governance and Vendor Procurement, distributed as a local CLI (`arckit`) and Claude-Code plugin. While developers often search for arc-kit SSR capabilities hoping to render dynamic web pages, the toolkit's architecture is fundamentally designed to produce static Markdown files, JSON configurations, and diagrams rather than server-rendered HTML.

## What Is Arc-Kit and Why It Doesn't Support SSR

### Enterprise Architecture Toolkit vs. Web Framework

Unlike Next.js, Nuxt, or Express, arc-kit does not implement a request-response cycle or template engine for HTML generation. According to the repository's [`README.md`](https://github.com/tractorjuice/arc-kit/blob/main/README.md), the tool generates "documentation, diagrams and governance artefacts through AI-driven slash commands." Its core execution model writes files to disk—specifically Markdown templates populated under `projects/` directories—rather than returning rendered content to a client.

### Core Execution Model (CLI and Claude-Code Plugin)

The primary entry points for arc-kit are:

- **Local CLI**: The `arckit` command installed via `pip install arckit-cli`
- **Claude-Code Plugin**: Located at [`arckit-claude/.claude-plugin/plugin.json`](https://github.com/tractorjuice/arc-kit/blob/main/arckit-claude/.claude-plugin/plugin.json)

Neither entry point exposes an HTTP server or SSR middleware. The Python API exposed in [`src/arckit_cli/__init__.py`](https://github.com/tractorjuice/arc-kit/blob/main/src/arckit_cli/__init__.py) provides functions like `get_data_paths()` for directory resolution, but these are utility functions for file system operations, not rendering engines.

## Server-Side Execution Without SSR

While arc-kit does not support SSR in the traditional sense, it can be invoked from server-side processes to automate documentation generation.

### Running Arc-Kit in CI/CD Pipelines

You can execute arc-kit within containerized CI/CD jobs to generate architecture artefacts as part of your build process:

```bash

# Install the CLI in a CI container

pip install arckit-cli

# Initialise a fresh project without a git repo

arckit init my-project --ai codex --no-git

# Generate a requirements document (server-side execution)

cd my-project && arckit requirements "Customer portal"

```

The CLI writes [`ARC-001-REQ-v1.0.md`](https://github.com/tractorjuice/arc-kit/blob/main/ARC-001-REQ-v1.0.md) under `projects/001-customer-portal/` as a static file, suitable for deployment to static site generators or document servers.

### Python API for Server Scripts

For programmatic server-side usage, the `get_data_paths()` function resolves arc-kit's data directories:

```python
from arckit_cli import get_data_paths

# Returns a list of directories where ArcKit looks for shared data

paths = get_data_paths()
print("ArcKit data directories:", paths)

```

This function is defined in [`src/arckit_cli/__init__.py`](https://github.com/tractorjuice/arc-kit/blob/main/src/arckit_cli/__init__.py) at line 147 and is useful for scripts that need to locate template repositories or configuration files.

## The Partial SSR Exception: Infographic Rendering

The only SSR-related code in the repository is an experimental infographic renderer with significant limitations.

### render-infographics.mjs Limitations

The script `docs/book/render-infographics.mjs` attempts to generate infographics in a headless SSR context using Node.js. However, this is not a general-purpose SSR solution for arc-kit content.

### Why Hierarchy Templates Fail (Line 96)

According to the source code comment at line 96 of `render-infographics.mjs`:

> "Three hierarchy templates fail when rendered without a browser."

This confirms that the SSR support is **partial and experimental**, limited to specific visualisation outputs, and explicitly broken for hierarchy diagrams. The script is intended for the documentation build process, not as a runtime SSR engine for web applications.

## Summary

- **Arc-kit is not a web framework** and does not provide SSR capabilities for dynamic HTML generation.
- **Server-side execution is supported** via CLI and Python API for automated documentation generation in CI/CD pipelines.
- **Static artefact generation** is the core output: Markdown files, JSON configs, and governance documents written to disk.
- **Experimental SSR exists** only in `docs/book/render-infographics.mjs`, with known failures for hierarchy templates when running without a browser.
- **Primary use case** remains local or CI-driven architecture governance, not web application rendering.

## Frequently Asked Questions

### Can arc-kit render HTML pages on the server?

No, arc-kit cannot render HTML pages on the server. It is designed to generate static documentation artefacts like Markdown files and JSON configurations. While it can run in server-side CI/CD environments to produce these files, it does not include an HTML templating engine or SSR runtime.

### Is arc-kit a replacement for Next.js or Nuxt SSR?

No, arc-kit is not a replacement for Next.js, Nuxt, or any web framework. It is an Enterprise Architecture Governance toolkit focused on generating architecture documentation and procurement artefacts. It operates as a CLI tool rather than a web server, making it unsuitable for replacing frontend SSR frameworks.

### Why does the infographic renderer have partial SSR support?

The `docs/book/render-infographics.mjs` script includes experimental headless rendering capabilities for generating documentation infographics without a browser. However, this support is limited and buggy—specifically, three hierarchy templates fail when rendered in a headless SSR context according to line 96 of the source file. This feature is intended for the documentation build process, not general SSR use.

### How do I automate arc-kit documentation generation in production?

You can automate arc-kit in production by invoking the CLI from server-side scripts or CI/CD pipelines. Install the package with `pip install arckit-cli`, then use commands like `arckit init` and `arckit requirements` to generate documentation. For programmatic access, import `get_data_paths()` from `arckit_cli` to resolve data directories within your automation scripts.