Skip to content

OpenSESA Documentation

OpenSESA documentation is organized to help you move from first run to production operation with clear technical depth at each stage.

Best starting point

Start with Getting Started, then move to Architecture and Platform Capabilities.

Open Source and Free to Use

OpenSESA is an open-source project and is free to use.

What OpenSESA Is and Is Not

OpenSESA is an integrated systems engineering platform for managing scope, requirements, architecture, interfaces, verification, assurance, baselines, and operational traceability across a shared project model.

OpenSESA is not a generic ticketing tool, a standalone diagram editor, or a pure document repository. It focuses on governed engineering data, cross-module linkage, and lifecycle control.

What You Can Do From This Documentation

  • Stand up a local OpenSESA environment and validate that it is functioning.
  • Stand up a production OpenSESA environment for real end users.
  • Understand module responsibilities, data flow, and integration boundaries.
  • Implement and review changes with confidence using defined workflows and testing guidance.
  • Operate the platform in runtime environments with clear deployment and incident playbooks.
  • Navigate cross-module capability flows such as requirements traceability, verification evidence, and baseline governance.

Fast Start

Use this path when you want a running environment first, then architectural context.

  1. Quickstart
  2. Local Setup
  3. First-Run Validation
  4. Architecture
  5. Platform Capabilities
If you are onboarding a new team member

Use this order:

  1. Quickstart
  2. First-Run Validation
  3. Core Concepts Index
  4. Module Capability Matrix
  5. Development Workflow
  6. Testing Strategy
If you are onboarding production end users

Use this order:

  1. Production Setup and End-User Onboarding
  2. Deployment
  3. Platform Capabilities
  4. Governance and Scope
  5. Interfaces and Requirements
  6. Verification and Assurance

Choose Your Task

flowchart TB
    H["Select your goal"] --> L["Run locally"]
    H --> A["Understand architecture"]
    H --> T["Trace requirement to verification"]
    H --> O["Operate production"]

    L --> GS["Getting Started"]
    A --> CA["Core Concepts + Architecture"]
    T --> CP["Capabilities + Traceability"]
    O --> BO["Build & Operate + Playbooks"]
Task Recommended path
Run OpenSESA locally Quickstart -> Local Setup -> First-Run Validation
Deploy OpenSESA for real end users Production Setup and End-User Onboarding -> Deployment -> Run Operations
Understand platform architecture Platform Overview -> Architecture -> Module Boundaries and Integration Rules -> Data and State Model
Trace requirements to verification evidence Interfaces and Requirements -> Verification and Assurance -> Engineering Traceability
Plan release and baseline controls Baseline, Impact, and Operations -> Run Operations -> Operations Playbooks
Configure and secure deployment Security & Configuration -> Environment Variables -> Deployment

Architecture At a Glance

System Context

flowchart TB
    U["Engineers, Leads, Operations"] --> W["OpenSESA Web Application (Django)"]
    W --> P["PostgreSQL (System of Record)"]
    W --> R["Redis (Cache + Broker)"]
    W --> C["Celery Workers (Async Jobs)"]
    C --> P
    C --> R

Module Interaction View

flowchart TB
    S["Scope and Governance"] --> D["System Definition and Design"]
    D --> I["Interfaces and Requirements"]
    I --> V["Verification and Assurance"]
    V --> B["Baseline, Impact, Operations"]
    B --> F["Governance Feedback"]
    F --> S

    D --> T["Engineering Traceability"]
    I --> T
    V --> T

Documentation Structure

Software Engineer

  1. Getting Started
  2. Core Concepts
  3. Development Workflow
  4. Testing Strategy
  5. Change Impact Guide

Technical Lead and Architect

  1. Architecture
  2. Module Boundaries and Integration Rules
  3. Module Capability Matrix
  4. Engineering Traceability
  5. Architecture Decisions

Operations and Delivery

  1. Deployment
  2. Run Operations
  3. Build & Operate
  4. Operations Playbooks
  5. Environment Variables

End Users and Enablement

  1. User Guide
  2. Platform Capabilities
  3. Governance and Scope
  4. Interfaces and Requirements
  5. Verification and Assurance
  6. Baseline, Impact, and Operations

Common First-Week Workflows

Workflow 1: Build Confidence in Local Development

  1. Quickstart
  2. First-Run Validation
  3. Development Workflow
  4. Testing Strategy
  5. Reference Scripts

Workflow 2: Follow an End-to-End Engineering Thread

  1. Governance and Scope
  2. System Definition and Design
  3. Interfaces and Requirements
  4. Verification and Assurance
  5. Baseline, Impact, and Operations
flowchart LR
    A["Scope"] --> B["Requirements"]
    B --> C["Design"]
    C --> D["Verification"]
    D --> E["Baseline"]
    E --> F["Impact and Operations"]

Capability-Centric Entry Points

OpenSESA spans governance, requirements, design, verification, and release governance. Use capability guides when you want complete end-to-end behavior across modules.

Choosing between Core Concepts and Capabilities

Use Core Concepts when you need platform mechanics (runtime behavior, data model, lifecycle, boundaries).

Use Capabilities when you need cross-module business workflows (what users can achieve and how modules collaborate).

Migrating from previous documentation organization

If you previously navigated by broad topics, use this mapping:

Documentation conventions used in this site
  • Tip callouts highlight the quickest route.
  • Warning callouts identify risk-prone decisions.
  • Collapsible callouts (click to expand) are used for secondary guidance and migration context.
  • Diagrams use the notation described in Diagram Conventions.
  • Terms are defined in the Glossary.

Troubleshooting Entry Points

High-Value References

If a page does not answer the question you are working on, use Reference first, then Architecture Decisions for implementation intent and tradeoffs.