Requirements stay with the design
Capture use case, RPS, consistency, availability, SLA, functional requirements, and NFRs where analysis can actually use them.
Architecture clarity for serious teams
Keep system design, journeys, docs, reviews, and analysis in one living workspace.
Stratum turns architecture design from a static drawing into a reviewable, versioned, and evaluatable system model. It is built for teams that need engineering context to survive beyond meetings.
Design first
Journey aware
Docs included
Review ready
Notification Platform
v8 Draft
Web Client
client.web
API Gateway
edge.api
Orchestrator
compute.service
Fanout Queue
messaging.queue
Ledger DB
data.sql
Requirement brief
99.99% availability
1s SLA · 2k RPS · strong consistency
Analysis score
82
3 risks ready for review
Journey
7 step delivery flow
sync call · async fanout · callback
AI analysis with deterministic evidence
Run math-first checks for topology, traffic, reliability, and risk, then use enterprise-configured AI for structured review synthesis.
Versioning, reviews, and release state
Move designs through draft, ready for review, reviewed, and live states with reviewer history attached to the right version.
Journeys explain how systems behave
Model request flows, async events, callbacks, and operational walkthroughs so architecture is understandable without another meeting.
Enterprise catalog reduces duplicates
Reuse canonical services and infrastructure across designs so teams can reason about shared ownership and future impact analysis.
Self-hosted enterprise control
Keep architecture data inside your environment with admin-managed users, access control, SSO direction, storage, and AI provider setup.
Product surface
The important architecture context stays together.
Stratum is built around the full design lifecycle: capture requirements, model the system, explain flows, review versions, and analyze risk without scattering context across tools.
Briefs that analysis can read
Use case, RPS, SLA, availability, consistency, functional requirements, and NFRs stay attached to the design.
Structured system modeling
Components, cloud frames, linked designs, typed dependencies, and shared catalog references form a machine-readable architecture model.
Explain traffic and behavior
Capture request direction, async events, callbacks, failure paths, and walkthroughs for reviewers and new team members.
Version lifecycle with accountability
Move versions from draft to review to live, assign reviewers, and keep comments tied to the correct design state.
Math first, AI second
Run deterministic topology and reliability checks before AI produces structured risks, tradeoffs, and recommendations.
Catalog, ACL, and admin controls
Reuse canonical services, manage access, configure storage, connect SSO, and centrally control AI provider settings.
The problem
Architecture knowledge is too fragmented to trust at scale.
Enterprise systems are rarely understood from one artifact. Design diagrams live in one place, journeys in another, requirements in documents, reviews in chat, and decisions in memory.
Diagrams lose intent
A box and arrow can show a dependency, but it does not explain traffic, consistency needs, failure strategy, or why the dependency exists.
Reviews lack structure
Architecture reviews often happen without version state, assigned reviewers, or a clear record of what was approved.
Analysis starts too late
Traffic assumptions, availability targets, data behavior, and security checks should be attached to the design from the start.
The Stratum approach
One workspace for the system, not just the drawing.
Design
Structured architecture canvas
Create components, cloud boundaries, shared catalog references, and typed connections that remain readable to humans and machines.
Journeys
Explain how requests move
Map synchronous calls, async flows, callbacks, and review paths so stakeholders can traverse a design without needing a live walkthrough every time.
Docs
Keep decisions beside the model
Attach documentation, notes, requirements, and review context to the same design surface instead of sending readers across disconnected tools.
Analysis
Combine deterministic checks with AI review
Use structured inputs for traffic, consistency, availability, risk, and security analysis, then layer AI synthesis on top when configured by the enterprise.
Why it is different
Stratum treats architecture as an operating model.
The goal is not to create another pretty diagram. The goal is to make a design usable for review, onboarding, impact analysis, and future evaluation. Stratum keeps the core system model structured while still giving teams a calm, visual workspace.
Shared enterprise catalog
Manual version lifecycle
Review and comment history
Self-hosted deployment path
Enterprise ready direction
Built for controlled environments.
Stratum is designed around the realities of internal platforms: access boundaries, central configuration, private deployment, and the need to keep sensitive architecture context inside the organization.
Admin console
Manage users, sign-in options, AI provider settings, storage mode, integrations, and catalog governance from one command surface.
Access control
Plan workspace and design-level access with roles, groups, review permissions, and future SSO group mapping.
Version governance
Move versions through draft, ready for review, reviewed, and live states with explicit reviewer participation.
Private analysis
Configure AI centrally when needed, while keeping deterministic analysis available as a baseline.
Distribution model
Free to host. Private by design.
Stratum is planned as a self-hosted product. The source code is not planned for public release, but teams can run published Docker images or binaries in their own infrastructure.
docker run --rm -p 8080:8080 \
ghcr.io/chaosphere-apps/stratum-allinone:latest
open http://localhost:8080
Start with the all-in-one image for evaluation, then connect PostgreSQL when you need persistent workspaces, versions, reviews, users, and configuration.