What is Scapius · For enterprise architects

Architecture that stays readable, reviewable, and checked by code.

Model business capabilities, applications, data flows, and security controls in plain text. Validate structure with the compiler, review changes in Git, and compile 13 specialized projections from one source of truth.

Maintain the model in readable text

In Scapius, you never manually draw boxes or drag connector lines. You describe entities and relationships in concise `.ea` files. Declarative view queries recompile views whenever code updates.

architecture/payments.ea
DSL
// 1. Define systems, apps, and dependencies once
system payment_hub "Payment Gateway" {
    description "Core authorization and settlement pipeline"
    tier "Tier-1"
    criticality "Mission-Critical"
    internet_facing true

    app payment_api "Payment API" {
        technology "ASP.NET Core"
        api_type "REST"
        
        relationships {
            this writes transaction_db "Records ledger entries"
            this flows_to payment_stream "Publishes payment events"
        }
    }
}

// 2. Declarative views compile automatically
view landscape payment_overview "Payment System Landscape" {
    include app where system == "payment_hub"
    include data_object
}

Compiled landscape projection

The compiler resolves relationships, determines hierarchical boundaries, and calculates layouts automatically whenever code changes are saved or merged in Git.

payments-landscape.svg
SVG
Compiled customer onboarding context view

Core capabilities for architecture teams

Readable DSL in VS Code

Describe capabilities, systems, components, and data objects in plain-text .ea files with LSP autocomplete, hover definitions, and syntax validation.

  • 21 first-class entity types covering strategy, business, application, and tech
  • 16 typed relationship verbs (serves, hosts, reads, writes, flows_to, realizes)
  • Zero manual box drawing or connector routing

Compile-Time Validation

Scapius uses a compiler to check grammar, entity references, and relationship rules before changes merge.

  • Hard errors for missing targets or illegal relationship declarations
  • Configurable linter rules enforcing descriptions, tags, and owners
  • Catch architecture violations directly in your CLI or pre-commit hook

Deep Relational Topology

Connect third-party SaaS, COTS packages, legacy mainframes, and modern microservices in one unified architecture graph.

  • Model SAP, Salesforce, and Workday alongside in-house APIs
  • Typed data objects and CRUD read/write interaction flows
  • Cluster by physical infrastructure, cloud environment, or network tier

STRIDE Threats & AI Governance

Embed security threat modeling and autonomous agent governance directly into your architecture definitions.

  • Native STRIDE threat classifications and CVSS risk ratings
  • Map mitigating controls and compliance standards (NIST, ISO 27001)
  • Model autonomous AI agents, their tool access, and human oversight gates

Git Pull Request Reviews

Treat architecture changes like software engineering. Use branches, line-by-line diffs, and pull requests for architectural governance.

  • Peer review architecture proposals in GitHub or GitLab
  • Automate architecture validation in CI/CD pipelines
  • Full commit history and audit trail of every system change

13 Compiled Projections

Update the code once and recompile views for any stakeholder discussion without redrawing diagrams.

  • Landscapes, container models, data flows, capability maps, and roadmaps
  • Workspace executive dashboard with health and Gartner TIME quadrants
  • Export standalone SVG and PNG diagrams for presentations

The Architecture as Code operating cycle

01

Model in Git

Capture capabilities, applications, and data flows in modular, human-readable .ea files.

02

Validate in CI

Compiler and linters catch dangling references, illegal links, and unmitigated threats.

03

Peer Review PRs

Review line-by-line diffs in GitHub or GitLab before approving architectural changes.

04

Share Live Views

Views compile automatically, giving business stakeholders up-to-date visual evidence.

Language specification

Metamodel and framework alignment

Scapius bridges strategic enterprise architecture and software delivery. Its 21 entity types and 16 typed relationship verbs map cleanly to TOGAF layers, ArchiMate concepts, C4 structural hierarchy, and Gartner TIME portfolio management without forcing teams to maintain separate repositories.

Architecture domainScapius DSL entities (21)Primary relationship verbs (16)Framework alignment
Strategy & Businessenterprise, domain, capability, value_stream, stage, actor, person, goalrealizes, serves, triggers, owns, influencesTOGAF Business Architecture, ArchiMate Strategy & Business layers, BIAN capability domains
Application & AIsystem, app, component, service, ai_agentuses, calls, flows_to, publishes, subscribes, approvesC4 Model (System, Container, Component), Gartner TIME & 6R rationalization, EU AI Act oversight
Data & Informationdata_object, datastorereads, writes, stores, classifiesTOGAF Data Architecture, GDPR / HIPAA data lineage and classification
Technology & Hostingnode, environment, network_zonehosts, deployed_to, connects_toTOGAF Technology Architecture, C4 Deployment View, hybrid cloud zoning
Risk, Security & Governancethreat, control, standardthreatens, mitigates, complies_withSTRIDE threat modeling, CVSS v3 scoring, NIST CSF, ISO 27001, DORA, SOC 2
Inventory onboarding

How to seed 500+ applications without manual typing

Because `.ea` files are structured, deterministic plain text with a published grammar, you do not need to type existing inventories by hand.

  • CSV and CMDB transformation: Export spreadsheets from ServiceNow, LeanIX, Ardoq, or Excel and run a lightweight Python or PowerShell template script to emit modular `.ea` files by domain.
  • Infrastructure and API discovery: Generate baseline `system`, `app`, and `node` blocks from Backstage `catalog-info.yaml` files, OpenAPI specs, or Terraform state.
  • Incremental domain federation: Split models across domain folders (`payments.ea`, `channels.ea`, `security.ea`) and enforce ownership with Git `CODEOWNERS`.
Continuous governance

End-to-end CI/CD and Architecture Review Board workflow

Replace monthly slide-deck bottlenecks with automated checks on every architecture pull request in GitHub Actions, GitLab CI, or Azure DevOps.

  • 1. Branch and propose: Solution architects propose a new microservice, data flow, or AI agent on a feature branch alongside an Architecture Decision Record (ADR).
  • 2. Automated compiler gate: CI runs the Scapius CLI compiler to verify zero unresolved references, valid typed verbs, required owner metadata, and mitigated STRIDE threats.
  • 3. Diff and merge: Domain leads and security architects review the exact `.ea` diff and compiled SVG preview in the pull request before approving.

Architect tutorials and documentation

Step-by-step guides to master the Scapius DSL, compiler, and projection views.

All documentation
Start with one model

Evaluate Community locally on your workstation

Free and in beta for a single local workspace. No database, server, or cloud account required.