# How to Use the Engineering Profile for Deployment-Ownership Validation in Archify

> Learn to use Archify's engineering profile for deployment-ownership validation. Enforce ownership, region, and boundary constraints for production readiness.

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

---

**Enable the `deployment-ownership` engineering profile in your architecture JSON's `meta` field to enforce strict ownership, region, and boundary constraints that validate production-deployment readiness.**

Archify transforms architecture diagrams into truth-verified artifacts through engineering profiles. The `deployment-ownership` profile specifically validates that every component in your diagram has required ownership metadata and boundary definitions, producing a machine-readable receipt that proves your topology meets production-deployment standards.

## Enabling the Deployment-Ownership Profile

To activate deployment-ownership validation, you must explicitly declare the profile in your architecture source file and run the validator with JSON output enabled.

### Setting the Engineering Profile Field

Add a top-level `meta.engineering_profile` field set to `"deployment-ownership"` in your architecture JSON:

```json
{
  "meta": {
    "title": "Production Deployment",
    "engineering_profile": "deployment-ownership"
  },
  "components": [
    { "id": "frontend", "type": "service", "owner": "team-web", "region": "us-east-1" },
    { "id": "api", "type": "service", "owner": "team-api", "region": "us-east-1" },
    { "id": "db", "type": "database", "owner": "team-db", "region": "us-east-1", "private": true }
  ],
  "relationships": [
    { "source": "frontend", "target": "api", "crossing": "http" },
    { "source": "api", "target": "db", "crossing": "tcp" }
  ]
}

```

According to the Archify source code, this profile is optional and must be set explicitly in the metadata to trigger validation logic.

### Running Validation

Execute the `validate` command with the `--json` flag to receive a machine-readable receipt:

```bash
node archify/bin/archify.mjs validate architecture my-app.architecture.json --quality showcase --json

```

When validation succeeds, the receipt contains the `engineeringProfile` property confirming compliance:

```json
{
  "engineeringProfile": "deployment-ownership",
  "status": "pass"
}

```

The validation engine is implemented in `archify/renderers/shared/engineering-profiles.mjs`, which processes each component against the strict deployment-ownership rules.

### Delivering the Artifact

Once validation passes, deliver the final artifact with the compliance badge attached:

```bash
node archify/bin/archify.mjs deliver architecture my-app.architecture.json out.html --quality showcase --json

```

The delivered HTML includes validation metadata that allows the gallery UI to display a green **"PASS"** badge next to the engineering profile label.

## Validation Rules and Diagnostics

When `deployment-ownership` is active, Archify enforces seven hard rules as errors rather than warnings. If any component violates these constraints, the validator aborts and returns a diagnostic receipt.

The `archify/renderers/shared/engineering-profiles.mjs` implementation checks for the following diagnostic codes:

- **`engineering/deployment-owner-missing`** — Every component must declare an explicit owner
- **`engineering/deployment-region-scope`** — All components must be placed in a single, named region
- **`engineering/deployment-private-state`** — Private state must be scoped to a region
- **`engineering/deployment-crossing-mechanism`** — Any boundary crossing must use a concrete mechanism (e.g., `http`, `tcp`)
- **`engineering/deployment-boundary-kind`** — Boundary kinds must be explicitly typed
- **`engineering/deployment-region-ambiguous`** — No component may be assigned to multiple regions
- **`engineering/deployment-private-region-consistency`** — Private resources cannot span regions

The validation receipt includes a `diagnostics` array listing specific failures, enabling precise fixes to the architecture source.

## Visual Verification in Rendered Artifacts

Successful validation embeds proof directly into the rendered output. Archify adds a data attribute to the SVG element:

```html
<svg data-engineering-profile="deployment-ownership" viewBox="...">

```

The gallery UI detects this attribute to display a green **"DEPLOYMENT OWNERSHIP · PASS"** badge. This visual indicator appears in the engineering profile section of the artifact viewer, as demonstrated in the example gallery file.

## Complete Working Example

Here is a complete end-to-end workflow using the example files from the repository:

```json
{
  "meta": {
    "title": "Production Deployment",
    "engineering_profile": "deployment-ownership"
  },
  "components": [
    { "id": "frontend", "type": "service", "owner": "team-web", "region": "us-east-1" },
    { "id": "api", "type": "service", "owner": "team-api", "region": "us-east-1" },
    { "id": "db", "type": "database", "owner": "team-db", "region": "us-east-1", "private": true }
  ],
  "relationships": [
    { "source": "frontend", "target": "api", "crossing": "http" },
    { "source": "api", "target": "db", "crossing": "tcp" }
  ]
}

```

Save this as [`examples/production-deployment.architecture.json`](https://github.com/tt-a1i/archify/blob/main/examples/production-deployment.architecture.json), then run:

```bash

# Validate the architecture

node archify/bin/archify.mjs validate architecture examples/production-deployment.architecture.json --quality showcase --json

# Deliver the HTML with compliance metadata

node archify/bin/archify.mjs deliver architecture examples/production-deployment.architecture.json out.html --quality showcase --json

```

Inspect [`out.html`](https://github.com/tt-a1i/archify/blob/main/out.html) to verify the SVG contains `data-engineering-profile="deployment-ownership"`, confirming the artifact meets deployment-ownership validation standards.

## Summary

- **Enable validation** by setting `meta.engineering_profile` to `"deployment-ownership"` in your architecture JSON
- **Validate** using the CLI with `--json` to receive machine-readable receipts from `archify/renderers/shared/engineering-profiles.mjs`
- **Fix failures** using the specific diagnostic codes (`engineering/deployment-owner-missing`, etc.) provided in the validation receipt
- **Deliver proof** that embeds compliance data into the SVG for gallery display
- **Verify visually** through the green "PASS" badge shown in the gallery UI when `data-engineering-profile` is present

## Frequently Asked Questions

### What is the deployment-ownership engineering profile?

The `deployment-ownership` engineering profile is a strict validation mode in Archify that ensures architecture diagrams meet production-deployment readiness standards. According to the source code in `archify/renderers/shared/engineering-profiles.mjs`, it enforces seven hard rules requiring explicit owners, single-region placement, scoped private state, and documented boundary crossings for every component.

### How do I fix validation errors for missing component owners?

Add an `owner` field to every component object in your architecture JSON. The validator in `archify/renderers/shared/engineering-profiles.mjs` generates the `engineering/deployment-owner-missing` diagnostic for any component lacking this field. Re-run `archify validate` after adding owner strings to confirm resolution.

### Can I use multiple engineering profiles simultaneously?

Currently, Archify supports only the `deployment-ownership` profile for production-deployment review. The `meta.engineering_profile` field accepts a single string value, and the validation engine processes only one profile per architecture diagram. Check [`README.md`](https://github.com/tt-a1i/archify/blob/main/README.md) for supported profile values as the ecosystem expands.

### Where does Archify store the validation receipt?

Archify emits the validation receipt to stdout when you pass the `--json` flag to the `validate` or `deliver` commands. The receipt includes the `engineeringProfile` field and any diagnostics. As shown in `archify/test/engineering-profile.test.mjs`, the JSON output contains structured data suitable for CI/CD pipelines and automated compliance checks.