Skip to content

Arda Platform Documentation

Select theme

Home
Product
- Product Areas
- Markets and Value
  - Markets and Value
  - Arda Value Proposition and Market Positioning
- Personas
- Features
  - Overview
  - UX Design Overview
  - Purchase Order Feature
  - General Behaviors
    
    General Behaviors
    Bulk Operations
    
    Entity Interactions
    
    Entity Interactions
    Entity Media Management
  - Reference Data
    
    Reference Data
    Item Management
  - Resources
    
    Kanban Card Notes
  - Shop Access
    
    printing
    
    Printing
    Print Diagnostics
- Use Cases
  - Use Cases
  - Naming Convention
  - General Behaviors
    
    General Behaviors
    Basic Interactions
    Error Handling
    
    List View Interactions
    
    List View Interactions
    Basic
    Advanced
    
    Entity Interactions
    
    Entity Interactions
    Entity Data Authority Behaviors
    Entity Subordinate Behaviors
    Entity Media Behaviors
  - Foundation
    
    Foundation
  - Shop Access
    
    Shop Access
    
    printing
    
    Print Diagnostics Behaviors
    Printing Behaviors
  - Reference
    
    Reference Data
    
    Items
    
    Item Behaviors
    Item Supply Behaviors
    
    Business Affiliates
    
    Business Affiliates -- Scenario Overview
    Business Affiliate Behaviors
    Business Role Behaviors
  - Resources
    
    Resources
    Facility Behaviors
    Kanban Card Behaviors
  - Procurement
    
    Procurement
    Procurement End-to-End Behaviors
    Order Queue Behaviors
    Purchase Order Behaviors
    Receiving Behaviors
  - Operations
    
    Operations
  - Fulfillment
    
    Fulfillment
  - Administration
    
    Administration
    Configuration Behaviors
    Identity and Access Management Behaviors
    Accounting and Cost Behaviors
  - Application
    
    Application
    Dashboard Behaviors
    Navigation Behaviors
  - Workflows and Integrations
    
    Workflows and Integrations
  - Unclassified
    
    Unclassified
- Cross-Cutting Concerns
- Releases
  - Releases
  - releases
    
    Overview
    Release 2026-02-20
- Publications
Domain
- Overview
- foundations
  - Overview
- general
- information-model
  - Overview
  - actions
    
    Overview
    Kanban Cards
  - assets
    
    Overview
    Business Affiliates
    Facilities
    Items
  - business
    
    Overview
  - common
    
    Overview
    Geographic Types
    Identity
    Primitives
    Time Types
    Value Objects
  - glossary
    
    Overview
  - meta
    
    Overview
    Arda Domain Name (ADN)
    Entities
    Entity References
    Journaled Entities
    Reference Data
    Value Types
  - operations
    
    Overview
  - system
    
    Overview
    Accounts
  - transactions
    
    Overview
    Item Mutation Qualifiers
    Purchase Orders
- systems
  - Overview
Current System
- Overview
- architecture
  - Overview
  - patterns
    
    Design Pattern Index
    
    api
    
    Query DSL
    
    API Design
    
    general
    
    Exception Handling
    Functional Programming at Arda
    Naming Conventions
    Observer and Notification Patterns
    
    Backend Implementation Patterns
    
    infrastructure
    
    Infrastructure Architecture Patterns
    IaC Functional Design
    
    persistence
    
    Overview
    Bitemporal Persistence
    Data Authority Module Pattern
    Exposed ORM Patterns
    Parent-Child Persistence
    Table Mappings
    Universe Design
    
    service
    
    Data Authority Limitations
    Data Authority Module Pattern
    
    user-interface
    
    Frontend Application Architecture
  - structure
    
    Architectural Design Framework
    Module Concept
    Viewpoint Mapping
  - user-interaction
    
    edit-lifecycle
    
    Edit Lifecycle
    Edit Lifecycle — Hierarchical Composition
    Edit Lifecycle — Type Catalog and Hook Reference
- artifacts
  - Overview
  - Repository Catalog
- context
- data-model
  - Overview
- functional
  - Overview
  - API Endpoint Catalog
  - authentication
    
    Overview
    Hybrid Authentication (Demo202509)
    OAuth2 Design Drafts and Notes
    OAuth2 UI Request Authentication
  - demo-specifics
    
    Item Enum Values (Demo202509)
    PDF Printing (Demo202509)
    Demo202509 Tenant and User Provisioning
  - Frontend Patterns
  - procurement
    
    Overview
    Order Creation
    Order Implementation Notes
    Order Lifecycle
    Order Line Management
    Purchase Order Implementation
  - reference-data
    
    Overview
    
    business-affiliate
    
    Business Affiliate Module
    
    item
    
    Item Module
    Amazon BFF Route — Import API
  - resources
    
    Overview
    Kanban Cards Module
  - shop-access
    
    PDF Render Module
  - system
    
    Overview
    Access Rules for UserAccounts and Tenants
    Customer Acquisition Channels
    Invite User to Tenant
    
    security
    
    Overview
    Cognito Application Endpoints
    Cognito Service
    JWT Payload
    OAuth2 API Endpoints
    Realms, Scopes, and Permissions
    
    User-Tenant Onboarding and Membership
- oam
  - Overview
  - configuration
    
    Configuration
    
    deployment
    
    Deployment
    Queued CI/CD
  - postmark-service
    
    Postmark Service
    Runbook: Postmark External Resource Provisioning
    Postmark API Observations
    Runbook: Sending Email via the Free Kanban Tool Postmark Server
  - security
    
    Secret Delivery Pattern
    Secrets Vault
  - Service Monitoring
- runtime
Vision
- Overview
- architecture
  - Overview
- artifacts
  - Overview
- context
  - Overview
- data-model
  - Overview
- functional
  - Functional Vision
- oam
  - Overview
- runtime
  - Overview
Roadmap
- Roadmap
- In Progress
- Backlog
  - requested
    
    demand-items-order-queue
    
    Overview
    Demand Item Design
    Order Queue Felxibility
    Use Case Updates
    
    hypothesis-mcp
    
    Simple Hypothesis MCP
    Hypothesis MCP — Specification
    
    inventory-procurement
    
    Simplified Procurement Domain Model
    Order Queue Felxibility
    
    sentry-integration
    
    Overview
    
    Overview
    Complexity Hotspot Remediation
    Frontend Test Coverage Improvements
    Item Delete -- Card State Propagation
    
    static-asset-repository
    
    12-upload-product-images
    
    Current State: Upload Product Images and Managed File Assets
    Decision Log: Upload Product Images and Managed File Assets
    Design Session 01: Upload Product Images and Managed File Assets
    Design Session 02: Upload Workflow (Write Path)
    Design Session 03: Item Module API Changes for Image Upload
    Static Asset Repository
    Upload Product Images and Managed File Assets
    
    Static Asset Repository
    
    use-case-definition
    
    Copyright Liability Consultation — User-Uploaded Images
    Round 1 Feedback — Entity Media Use Cases
    
    TypeScript Quality Tools -- Stryker and SonarJS
    
    ui-componentization
    
    Component Configuration Endpoint (common-module v6.6.0)
  - Overview
  - planned
    
    Overview
    SonarJS Complexity Metrics Integration
- Ideas
  - Overview
  - Architecture Explorations
  - Business Affiliate Design -- Suppliers Feature
  - Pull Request Review Guidelines
  - skills-mcp-server
    
    Design
    Goal
    Implementation Changes
    Kickoff
    
    plan
    
    Task Plan
    Team Split Assessment
    
    Requirements
    Specification
    Verification
- Completed
  - frontend-pipeline
    
    Frontend Pipeline — Staff Engineer Overview
    Frontend Deployment Pipeline — Design Analysis
    Frontend Pipeline — Development Blueprint
    Amplify App Provisioning — How It Works
    Amplify Current Configuration — Live AWS State
    
    phase-2-queued-prs
    
    Phase 2 — Queued PRs and Tiered Gates
    Phase 2 Design — Tiered Gates, Merge Queue, Deploy Quality Gate
    Phase 2 Decisions
    
    Overview
    
    implementation
    
    Pending Items — 2026-03-20 (updated)
    Drift Warnings — Manual Interventions Outside IaC
    
    run-1-infrastructure
    
    Run 1: Infrastructure — Changelog
    Run 1: Infrastructure — Completion Report
    Run 1: Infrastructure — Warnings and Insights for Future Runs
    
    run-2-workflows
    
    Run 2: Workflows — Completion Report
    
    run-3-validation
    
    Run 3: Validation — Completion Report
    GO/NO-GO Decision: Frontend Pipeline Cutover
    
    run-4-cutover
    
    Run 4: Production Cutover — Completion Report
    Post-Cutover Instructions
    Rollback Plan: Frontend Pipeline Cutover
    
    plan
    
    Choreography: Frontend Deployment Pipeline
    Goal: Arda Frontend Deployment Pipeline
    Requirements: Frontend Deployment Pipeline
    
    run-1-infrastructure
    
    Run 1: Infrastructure
    
    run-2-workflows
    
    Run 2: Workflows
    
    run-3-validation
    
    Run 3: Validation
    
    run-4-cutover
    
    Run 4: Production Cutover
    
    Specification: Frontend Deployment Pipeline
    Team Split Assessment
    Verification: Frontend Deployment Pipeline
  - integrate-agentation-hypothesis
    
    Integrate Agentation with Hypothesis
    
    plan
    
    Team Split Assessment
    
    run-1-hypothesis-mcp
    
    Run 1: hypothesis-mcp Extension
    
    run-2-ux-prototype
    
    Run 2: ux-prototype Bridge & Highlights
    
    Choreography: Agentation-Hypothesis Bridge
    Plan
    
    Agentation → Hypothesis Bridge Specification
    Summary and Byproducts
  - callil-branch-merge
    
    Branch Merge Analysis: callil/storybook-ia-refactor
    DSL Framework Migration Candidates
    Callil Branch Merge: Requirements
    Callil Branch Merge: Verification
    Callil Branch Merge: Project Plan
    Overview
  - item-image-upload
    
    Scoping
    
    ux-design
    
    components
    
    UI Components
    Canary Library Updates
    Follow-Up Work
    Component Implementation Specification
    
    implementation
    
    Image Upload Components — Alternatives Considered
    Image Upload Components — Changelog
    Image Upload Components — Learnings
    Image Upload Components — Skipped Items
    Image Upload Components — Post-Implementation Specification
    Image Upload Components — Suggestions
    
    Component Behavior Inconsistencies Audit
    
    plan
    
    Choreography: Image Upload Components
    Goal: Image Upload Component Implementation
    
    run-1-infrastructure
    
    Run 1: Infrastructure and Scaffolding
    
    run-2-foundation
    
    Run 2: Foundation Components
    
    run-3-composition
    
    Run 3: Composition Components
    
    run-4-grid-organism
    
    Run 4: Grid Atoms, Organism, and Integration
    
    Team Split Assessment
    
    use-cases
    
    Reviewer Guide: Image Upload Use Cases
    Use Case Stories Specification
    Overview
    
    implementation
    
    run-1-view-and-fallback
    
    Run 1 Session Log
    
    run-2-input-and-validation
    
    Run 2 Session Log
    
    run-3-preview-and-confirm
    
    Run 3 Session Log
    
    run-4-integration
    
    Run 4 Session Log
    
    run-5-cleanup
    
    Run 5 Session Log
    
    plan
    
    Choreography
    
    run-1-view-and-fallback
    
    Run 1: View and Fallback
    
    run-2-input-and-validation
    
    Run 2: Input and Validation
    
    run-3-preview-and-confirm
    
    Run 3: Preview and Confirm
    
    run-4-integration
    
    Run 4: Integration
    
    run-5-cleanup
    
    Run 5: Sidebar Clean-Up
    
    Team Split Assessment
    
    External Libraries Assessment
    Overview
    
    3-frontend-implementation
    
    implementation
    
    byproducts
    
    Changelog
    Learnings
    Suggestions
    Alternatives
    Skipped
    Post-Implementation Specification
    
    Implementation Log
    Implementation Tracker
    
    37-release
    
    Documentation Update Plan — current-system
    Specification: Phase 3.7 — Release
    
    3.1-api-proxy-publish
    
    Specification: Phase 3.1 — API Proxy Publish
    
    3.5-bff-routes
    
    Specification: Phase 3.5 — BFF Routes
    
    3.6-spa-integration
    
    Specification: Phase 3.6 — SPA Integration
    
    32-lifecycle-framework
    
    Specification: Phase 3.2 — Lifecycle Framework
    
    33-component-updates
    
    Specification: Phase 3.3 — Component Updates
    
    34-design-system-publish
    
    Specification: Phase 3.4 — Design System Publish
    
    36b-backend-validation
    
    Specification: Phase 3.6b — Backend Strict Validation
    
    36c-discovery-remediation
    
    Analysis: Phase 3.6c — Discovery Remediation
    Coverage Improvement Analysis — arda-frontend-app
    Implementation Plan: Documint CDN Image Signing
    
    Analysis: Frontend Implementation for Item Image Upload
    
    architectural-exploration
    
    Abstract Component Lifecycle Design
    Code Organization Options for arda-frontend-app
    Hierarchical Edit Lifecycle Exploration
    TanStack Query Adoption Exploration
    TanStack Query Component Binding Analysis
    UX Prototype Architectural Review
    
    Audit 1: Frontend Implementation Document Review
    Audit 2: Post-Remediation Document Review
    Goal: Frontend Implementation for Item Image Upload
    
    plan
    
    Choreography: Frontend Implementation for Item Image Upload
    
    run-1-api-proxy-publish
    
    byproducts
    
    Run 1 Changelog: API Proxy Publish
    Run 1 Learnings: API Proxy Publish
    Run 1 Suggestions: API Proxy Publish
    
    Run 1: API Proxy Publish
    
    session
    
    Run 1 Session Log: API Proxy Publish
    
    run-2-lifecycle-framework
    
    Run 2: Lifecycle Framework
    
    run-3a-component-updates
    
    Run 3a: Component Updates
    
    run-3b-cors-integration
    
    Run 3b: CORS Integration
    
    run-4-design-system-publish
    
    Run 4: Design System Publish — Project Plan
    
    run-5-bff-routes
    
    Run 5: BFF Routes — Project Plan
    
    run-6-spa-integration
    
    Run 6: SPA Integration — Project Plan
    
    run-7-release
    
    Run 7: Release — Project Plan
    
    Team Split Assessment
    
    preparation
    
    API Proxy Update to Operations 2.21
    
    Requirements: Frontend Implementation for Item Image Upload
    Specification: Frontend Implementation for Item Image Upload
    Upload Component Backend Integration Analysis
    Verification: Frontend Implementation for Item Image Upload
    
    Overview
    Decision Log
    
    1-aws-infrastructure
    
    AWS Resource Diagram Conventions
    Design: AWS Infrastructure for Item Image Upload
    Goal: AWS Infrastructure for Item Image Upload
    
    implementation
    
    byproducts
    
    Alternatives
    Changelog
    Learnings
    Skipped
    Specification Post-Implementation Review
    Suggestions
    
    run2
    
    Task 2.18: Deploy to Alpha002/dev and Verify
    
    plan
    
    Choreography: AWS Infrastructure for Item Image Upload
    
    run-1-dns-foundation
    
    Run 1: DNS Foundation
    
    run-2-partition-resources
    
    Run 2: Partition Resources
    
    Team Split Assessment
    
    Specification: AWS Infrastructure for Item Image Upload
    Verification: AWS Infrastructure for Item Image Upload
    
    2-backend-services
    
    Analysis: Backend Services for Item Image Upload
    
    byproducts
    
    Changelog: Backend Services for Item Image Upload
    Learnings: Backend Services for Item Image Upload
    Suggestions: Backend Services for Item Image Upload
    
    Goal: Backend Services for Item Image Upload
    
    plan
    
    Choreography: Backend Services for Item Image Upload
    
    run-1-common-module
    
    Run 1: common-module Library
    
    session
    
    CI Observations: Run 1 common-module
    
    run-2-operations
    
    Run 2: operations Endpoints + Release
    
    Team Split Assessment: Backend Services
    
    Requirements: Backend Services for Item Image Upload
    Specification: Backend Services for Item Image Upload
    Verification: Backend Services for Item Image Upload
    
    previous-design-work
    
    Overview
    
    12-upload-product-images
    
    Current State: Upload Product Images and Managed File Assets
    Decision Log: Upload Product Images and Managed File Assets
    Design Session 01: Upload Product Images and Managed File Assets
    Design Session 02: Upload Workflow (Write Path)
    Design Session 03: Item Module API Changes for Image Upload
    Static Asset Repository
    Upload Product Images and Managed File Assets
    
    Static Asset Repository
    
    system-design
    
    Overview
    Kickoff
    
    results
    
    System Design Results
    System Design Audit
    AWS Specification
    Backend Specification
    BFF Specification
    CDN Access Control
    System Design
    OAM Requirements
    Implementation Observations
    Phasing
    Requirements
    Scenarios
    SPA Specification
    
    Risks and Assumptions
    
    use-case-definition
    
    Overview
    Copyright Liability Assessment
    Round 1 Feedback
  - list-view-component
    
    implementation
    
    List View Component: Execution Kickoff
    
    plan
    
    Overview
    Phase 0: Setup
    Phase 1: Shared Foundation
    Phase 2: Cell Atoms
    Phase 3: Data Grid Molecule
    Phase 4: Entity Data Grid
    Phase 5: Integration
    Phase 6: Report & Changelog
    Planning Questions
    
    Overview
    List View Component: Completion Report
    List View Component Design
    List View Component
    List View Component: Landscape Analysis
    List View Component: Design Completeness Assessment
    Redux State Management Analysis
  - hypothesis-mcp
    
    Overview
    Hypothesis MCP — Specification
  - Overview
  - Accounts Component -- common-module 6.x Migration
  - AG Grid Refactor
  - amazon-client-integration
    
    2-implementation
    
    bff
    
    byproducts
    
    BFF Stream — Changelog
    BFF Stream — Learnings
    BFF Stream — Task Plan (post-implementation)
    
    Task Plan: BFF Stream
    
    infrastructure
    
    byproducts
    
    Infrastructure Stream — Changelog
    Infrastructure Stream — Learnings
    Infrastructure Stream — Task Plan (post-implementation)
    
    Task Plan: Infrastructure Stream
    
    item-module
    
    byproducts
    
    Item-module Stream — Changelog
    Item-module Stream — Learnings
    Item-module Stream — Task Plan (post-implementation)
    
    Task Plan: Item Module Stream
    
    operator
    
    byproducts
    
    Operator Stream — Changelog
    Operator Stream — Learnings
    Operator Stream — Task Plan (post-implementation)
    
    Task Plan: Operator Stream
    
    3-deployment
    
    Deployment Plan: Amazon Client Integration
    
    Completion Report: Amazon Client Integration v1
    Context: v1 Decision Backing
    Goal: Amazon Client Integration
    Phases: Amazon Client Integration
  - api-proxy
    
    Decision Log: Arda API Proxy
    Goal: Arda API Proxy — Typed TypeScript Client
    
    implementation
    
    run-1-foundation
    
    Run 1 Foundation — Byproducts
    Run 1 Foundation — Implementation Summary
    
    run-2-proxies-and-publish
    
    Run 2 Proxies and Publish — Byproducts
    Run 2 Proxies and Publish — Implementation Summary
    
    planning
    
    Choreography: Arda API Proxy
    
    run-1-foundation
    
    Run 1: Foundation — Shared Infrastructure, Tenant Reference, CI/CD
    
    run-2-proxies-and-publish
    
    Run 2: Remaining Proxies, Polish, and Publish Preparation
    
    Team Split Assessment: Arda API Proxy
    
    Requirements: Arda API Proxy
    Specification: Arda API Proxy
    Type Hierarchy: Arda API Proxy
    Verification: Arda API Proxy
  - Business Affiliate Workflows
  - callil-consolidation
    
    Overview
    
    analysis
    
    Overview
    Canary Refactor Analysis
    Dependencies Analysis
    Grid Integration Analysis
    Primitives Placement Analysis
    Styles Consolidation Analysis
    Test & Story Coverage Analysis
    
    Callil Consolidation — Decision Log
    
    implementation
    
    run-0-branch-setup
    
    Run 0: Branch Setup — Byproducts
    Run 0: Branch Setup — Session Log
    Run 0: Branch Setup — Summary
    
    run-1-foundation
    
    Run 1 Foundation — Byproducts
    Run 1: Foundation — Session Log
    Run 1 Foundation — Implementation Summary
    
    run-2-visual-foundation
    
    Run 2: Visual Foundation — Byproducts Log
    Run 2: Visual Foundation — Session Log
    Run 2: Visual Foundation — Implementation Summary
    
    run-3-organism-port
    
    Run 3 Organism Port — Byproducts
    Run 3: Organism Port — Session Log
    Run 3 Organism Port — Implementation Summary
    
    run-4-cell-editor-upgrade
    
    Run 4: Cell Editor Upgrade — Byproducts
    Run 4: Cell Editor Upgrade — Session Log
    Run 4: Cell Editor Upgrade — Implementation Summary
    
    run-5-entity-grid-evolution
    
    Run 5 Entity-Grid Evolution — Byproducts Log
    Run 5: Entity-Grid Evolution — Session Log
    Run 5 Entity-Grid Evolution — Implementation Summary
    
    run-6-item-grid-integration
    
    Run 6: Item-grid Integration — Byproducts
    Run 6: Item-Grid Integration — Session Log
    Run 6: Item-grid Integration — Implementation Summary
    
    run-7-package-api
    
    Run 7 — Package API — Byproducts
    Run 7: Package API — Session Log
    Run 7 — Package API — Summary
    
    run-8-acceptance
    
    Run 8 Acceptance — Byproducts Log
    Run 8: Acceptance — Session Log
    Run 8 Acceptance — Implementation Summary
    
    run-9-canary-refactor
    
    Run 9 — canary-refactor Byproducts
    Run 9: canary-refactor Adaptation — Session Log
    Run 9 — canary-refactor Adaptation Summary
    
    plan
    
    Choreography: Callil Consolidation
    
    run-0-branch-setup
    
    Run 0: Branch Setup
    
    run-1-foundation
    
    Run 1: Foundation
    
    run-2-visual-foundation
    
    Run 2: Visual Foundation (Theme Migration)
    
    run-3-organism-port
    
    Run 3: Organism Port
    
    run-4-cell-editor-upgrade
    
    Run 4: Cell Editor Upgrade
    
    run-5-entity-grid-evolution
    
    Run 5: Entity-data-grid Evolution — Project Plan
    
    run-6-item-grid-integration
    
    Run 6: Item-grid Integration — Project Plan
    
    run-7-package-api
    
    Run 7: Package API — Project Plan
    
    run-8-acceptance
    
    Run 8: Acceptance — Project Plan
    
    run-9-canary-refactor
    
    Run 9: canary-refactor Adaptation — Project Plan
    
    Team Split Assessment
    
    Callil Consolidation — Project Blueprint
  - component-preparation
    
    1-legacy-cleanup
    
    Requirements: Legacy Cleanup
    Specification: Legacy Cleanup
    Verification: Legacy Cleanup
    
    2-utility-extraction
    
    Implementation Changes: Utility Extraction
    Requirements: Utility Extraction
    Specification: Utility Extraction
    Verification: Utility Extraction
    
    3-local-dev-tooling
    
    Requirements: Local Development Tooling
    Specification: Local Development Tooling
    Verification: Local Development Tooling
    
    Analysis: Component Preparation
    Goal: Component Preparation
  - Documentation Consolidation
  - extra-printing-options
    
    Goal
    
    implementation
    
    Extra Printing Options — Alternatives
    Extra Printing Options — Changelog
    Extra Printing Options — Learnings
    Extra Printing Options — Skipped
    Extra Printing Options — Post-Implementation Specification
    Extra Printing Options — Suggestions
    
    Implementation Plan
    Specification
    Verification
  - Item Delete Bug #782 -- PROPAGATE Fork Fix
  - multi-pdf-print-and-bugs
    
    Analysis: Multi-PDF Print and Bugs
    Decision Log: Multi-PDF Print and Bugs
    Goal
    
    implementation
    
    Implementation Log
    
    run-1-bug-fixes
    
    Run 1 Bug Fixes — Byproducts
    Run 1 Bug Fixes — Implementation Summary
    
    run-2-multi-template
    
    Run 2 Multi-Template — Byproducts
    Run 2 Multi-Template — Implementation Summary
    
    run-3-diagnostics
    
    Run 3 Print Diagnostics — Byproducts
    Run 3 Print Diagnostics — Implementation Summary
    
    run-4-api-tests
    
    Run 4 API Tests — Byproducts
    Run 4 API Tests — Implementation Summary
    
    run-5-api-proxy
    
    Run 5 API Proxy — Byproducts
    Run 5 API Proxy — Implementation Summary
    
    Implementation Tracker
    
    phase-1-bug-fixes
    
    Requirements: Phase 1 — Bug Fixes
    Specification: Phase 1 — Bug Fixes
    Verification: Phase 1 — Bug Fixes
    
    phase-2-multi-template
    
    Requirements: Phase 2 — Multi-Template Printing
    Specification: Phase 2 — Multi-Template Printing
    Verification: Phase 2 — Multi-Template Printing
    
    phase-3-diagnostics
    
    Requirements: Phase 3 — Print Diagnostics
    Specification: Phase 3 — Print Diagnostics
    Verification: Phase 3 — Print Diagnostics
    
    phase-4-api-tests
    
    Requirements: Phase 4 — API Tests
    Specification: Phase 4 — API Tests
    Verification: Phase 4 — API Tests
    
    phase-5-api-proxy
    
    Requirements: Phase 5 — API Proxy Update
    Specification: Phase 5 — API Proxy Update
    Verification: Phase 5 — API Proxy Update
    
    plan
    
    Choreography: Multi-PDF Print and Bugs
    
    run-1-bug-fixes
    
    Run 1: Bug Fixes
    
    run-2-multi-template
    
    Run 2: Multi-Template Printing
    
    run-3-diagnostics
    
    Run 3: Print Diagnostics
    
    run-4-api-tests
    
    Run 4: API Tests
    
    run-5-api-proxy
    
    Run 5: API Proxy Update
    
    Team Split Assessment
  - UX Prototype -- Agentation Adoption
Process
- Overview
- Development Activities
- APDS
- SRE/OAM
  - Overview
  - Runbooks
    
    Overview
    Runbook: Amazon Creators API Onboarding
- Design System Integration
- Engineering Craft
  - Overview
  - Configuration Management
    
    Overview
  - Analysis & Design
    
    Overview
    Complex Project Definition and Planning
    Project Decomposition
    Information Model Design
    
    Use-case to UX
    
    Use-case to UX
    CI Stabilization Patterns for Storybook Play Functions
    
    Templates
    
    Template: Application Conventions
    Template: Implementation Plan
    Template: Progress Tracker
    Template: Scope Analysis
    Template: Story Plan
    Template: Story Specification
    
    Examples
    
    Example: Individual Story Plan — Pagination
    Example: Scope Decisions (Business Affiliates)
    Example: Story Specification — Pagination
    Example: Wave Structure (Business Affiliates)
  - Discovery & Requirements
    
    Overview
  - Deployment & Release
    
    Overview
    AWS Account Creation
    Frontend PR Process
    mTLS Setup How-To
    Release Lifecycle
    Runtime Environment Configuration How-To
  - Documentation
    
    Overview
    Creating and Maintaining Skills
  - Implementation
    
    Overview
    Development Environment Setup
    Development Workflows
    Worktree Conventions
    How to Develop in the Front End
    Gradle Project Setup
    Implementation Task Workflow
    Kotlin Coding Standards
    Data Authority API Guide
    Data Authority Endpoint Guide
    Multi-Repository Gradle Development
    IDE and Tooling
    React Component Design
    Working with AI Agent Assistants
  - Maintenance & Evolution
    
    Overview
  - Operations & Monitoring
    
    Overview
    Accessing Arda APIs
    Inspecting Cluster Logs
    FullStory Analytics Integration
    PostgreSQL Access via kubectl Bastion
    Sentry Error Tracking Integration
  - Project Management
    
    Overview
    Process Patterns
    Project Planning Workflow
    Project Setup
  - Quality Assurance
    
    Overview
  - Retirement
    
    Overview
  - Security
    
    Overview
  - Verification & Validation
    
    Overview
    API Testing with Bruno
    Backend Testing
    Frontend and Backend Testing Patterns
    Running API Tests
Technology
- Overview
- ag-grid
- Astro & Starlight
- AWS CDK Infrastructure
- Cedar Authorization
- claude-context-mcp
  - Claude Context MCP Server
- Exposed
- Ktor
- Next.js
Legal
- Overview
Decisions
- Overview
- discussion
  - Overview
  - Release Pipeline Analysis: Design System to Production
- open
  - Overview
- record
  - Overview
  - Purchase Order V1 Decisions
About

Select theme

On this page

Overview

On this page

Overview

Overview

A point-in-time description of how Arda’s products are realized by combining software and hardware elements.

Previous
Overview Next
Overview

Copyright: © Arda Systems 2025-2026, All rights reserved