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
    
    Resources Features
    Kanban Card Notes
    Kanban Replenishment Loop
  - Operations
    
    Operations Features
    Demand Collation (Production Requests)
  - Procurement
    
    Procurement Features
    Order Management with Lifecycle
    Receiving-Readiness
    Supplier Binding on Orders
  - 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
    Demand
  - 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
    Money
    Primitives
    Quantity
    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
- artifacts
  - Overview
  - Repository Catalog
- context
- data-model
  - Overview
- functional
  - Overview
  - API Endpoint Catalog
  - demo-specifics
    
    Item Enum Values (Demo202509)
    PDF Printing (Demo202509)
    Demo202509 Tenant and User Provisioning
  - Frontend Patterns
  - fulfillment
    
    Fulfillment
    
    sales-orders
    
    Sales Orders
  - oam
    
    OAM
    
    accounting
    
    Accounting (Costs)
    
    configuration
    
    Configuration
    
    fault
    
    Fault
    
    performance
    
    Performance / Monitoring
    
    security
    
    Security / Authentication
    Authentication API (`auth.arda.cards`)
  - operations
    
    Operations
    
    demand
    
    Demand Module
    
    inventory
    
    Inventory
    
    material-flows
    
    Material Flows
  - procurement
    
    Overview
    
    order-queue
    
    Order Queue
    
    orders
    
    Orders Module
    
    q2-2026
    
    Purchase Orders (Q2 2026)
    Order Creation
    Order Implementation Notes
    Order Lifecycle
    Order Line Management
  - receiving
    
    Receiving
    
    receivers
    
    Receivers
  - reference-data
    
    Overview
    
    business-affiliate
    
    Business Affiliate Module
    
    q2-2026
    
    Business Affiliate Module
    
    item
    
    Item Module
    
    q2-2026
    
    Item Module
    Amazon BFF Routes
    Amazon BFF Integration Guide (SPA)
  - resources
    
    Overview
    
    facilities
    
    Facilities
    
    inventory-items
    
    Inventory Item Module
    
    kanban-cards
    
    Kanban Cards Module
    
    q2-2026
    
    Kanban Cards Module
    
    loops
    
    Loops
    
    operators
    
    Operators
    
    processing-network
    
    Processing Network Module
    
    stations
    
    Stations
  - shipping
    
    Shipping
    
    shipments
    
    Shipments
  - shop-access
    
    Overview
    
    email
    
    Email
    Email — API Reference
    Email — Domain Model
    Email — Configuration Lifecycle
    Email — Provisioning & Sending
    Email — Webhook Ingestion
    
    PDF Render Module
    
    print
    
    Print
    
    scan
    
    Scan
  - system
    
    Overview
    Access Rules for UserAccounts and Tenants
    Customer Acquisition Channels
    Invite User to Tenant
    
    messaging
    
    Overview
    
    system-email
    
    System Email
    Integrating with System Email
    
    security
    
    Overview
    Cognito Application Endpoints
    Cognito Service
    Hybrid Authentication (Demo202509)
    JWT Payload
    OAuth2 API Endpoints
    OAuth2 Design Drafts and Notes
    OAuth2 UI Request Authentication
    Realms, Scopes, and Permissions
    
    Service Users
    User-Tenant Onboarding and Membership
  - workflows-and-integrations
    
    Workflows & Integrations
- oam
  - Overview
  - configuration
    
    Configuration
    
    deployment
    
    Deployment
    Queued CI/CD
  - postmark-service
    
    Postmark Service
    Runbook: Email Encryption-Key Rotation
    Runbook: Email Module (Runtime)
    Runbook: Postmark External Resource Provisioning
    Postmark API Observations
    Runbook: Sending Email via the Free Kanban Tool Postmark Server
    Runbook: System Email Server (Provisioning & Rotation)
  - security
    
    Secret Delivery Pattern
    Secrets Vault
  - Sentry Observability
  - Service Monitoring
- runtime
- user-interface
  - User Interface — Overview
  - Data Flow and Caching — Item-Cards Subsystem
  - editing-and-concurrency
    
    Editing and Concurrency — Overview
    Conflict Resolution
    Staleness Signal
  - Frontend Application Architecture
Vision
- Overview
- architecture
  - Overview
- artifacts
  - Overview
- context
  - Overview
- data-model
  - Overview
- functional
  - Functional Vision
- oam
  - Overview
- runtime
  - Overview
Roadmap
- Roadmap
- Functional Areas
  - Fulfillment
    
    Fulfillment
    
    sales-orders
    
    Sales Orders
  - OAM
    
    fault
    
    sentry-integration
    
    Sentry Integration
    
    Fault
    
    operations-sentry
    
    Operations Sentry — Project Goal
    
    byproducts
    
    Operations Sentry — Alternatives Considered
    Operations Sentry — Changelog
    Operations Sentry — Learnings
    Operations Sentry — Skipped Scope
    Operations Sentry — Specification Post
    Operations Sentry — Suggestions
    
    Completion Report: Operations Sentry
    Operations Sentry — Decision Log
    Operations Sentry — Project Goal
    
    plan
    
    Operations Sentry — Project Plan
    
    specification
    
    Operations Sentry — Analysis
    Operations Sentry — Requirements
    Operations Sentry — Specification
    Operations Sentry — Verification
    
    sentry-iac
    
    Checkpoint: Sentry Configuration as Code
    Decision Log: Sentry Configuration as Code
    Design: Sentry Configuration as Code
    Goal: Sentry Configuration as Code
    
    OAM
    
    accounting
    
    Accounting (Costs)
    
    configuration
    
    Configuration
    
    feature-flags
    
    Spike PDEV-679 — Feature Flag System
    Feature Flags — Code Sketch
    Feature Flags — Spike Analysis
    
    performance
    
    Performance / Monitoring
    
    product-slow-fe
    
    Product Slow — Front-End Items Page Performance
    Goal: Product Slow — Front-End Items Page Performance
    Implementation Plan: Product Slow — Front-End Items Page Performance
    Specification: Product Slow — Front-End Items Page Performance
    
    product-slow-responses
    
    Product Slow Responses
    
    analysis
    
    PDEV-442 — Backend log inspection
    PDEV-442 — Code dig of arda-frontend-app for BFF slowness and N+1 root causes
    PDEV-479 — Aurora DB configuration: parameter group, slow-query logging, prod sizing
    PDEV-498 — postgres-database-initializer changes for pg_stat_statements
    PDEV-442 — First-pass findings: product slow responses
    PDEV-442 — Infrastructure changes scope
    PDEV-442 — Operations + common-module code dig
    PDEV-442 — Operations pod capacity (EKS / Fargate)
    PDEV-442 — Sentry organisation configuration for Arda services
    
    Goal: Product Slow Responses
    
    pdev-479
    
    implementation
    
    infrastructure
    
    PDEV-479 — Aurora cluster configuration: implementation plan
    PDEV-479 — Aurora cluster CDK changes: detailed specification
    
    pdev-490
    
    Goal: PDEV-490 Operations Performance Improvements
    
    plan
    
    Implementation Plan: PDEV-490 Operations Performance Improvements
    
    specification
    
    Analysis: PDEV-490 Operations Performance Improvements
    Requirements: PDEV-490 Operations Performance Improvements
    Specification: PDEV-490 Operations Performance Improvements
    Verification: PDEV-490 Operations Performance Improvements
    
    Work-in-progress — design surface migration
  - Operations
    
    Operations
    
    inventory
    
    Inventory
    
    material-flows
    
    Material Flows
  - Procurement
    
    purchase-orders
    
    orders-with-lifecycle
    
    Overview
    Goal
    Design
    Decisions
    Atlas
    
    Purchase Orders
    
    direct-email-send
    
    Direct Email Send
    Direct-Send Composer — Harmonization Plan (Email Order adopts OrderSheet)
    Purchase Order UI — Direct Send Design
    Direct-Send Composer — Shared-Component Audit
    
    po-lite-zero-backend
    
    PO Lite Zero Backend
    PO-Lite Zero Back End — Implementation Plan
    
    purchase-order-v1
    
    Purchase Order V1
    Purchase Order V1 — Implementation Plan
    Order Sidebar Panel Plan
    Simplified PO Spec V1
    
    order-queue
    
    demand-items-order-queue
    
    Demand Items — Order Queue
    Demand Item Design
    Order Queue Felxibility
    Use Case Updates
    
    inventory-procurement
    
    Simplified Procurement Domain Model
    Order Queue Felxibility
    Inventory Procurement
    
    Order Queue
    
    direct-email-send
    
    Direct Email Sending for Email Orders
    Decision Log: Direct Email Send Integration
    Design: Direct Email Send Integration
    Email Order UI — Direct Send Design
    Goal: Direct Email Sending for Email Orders
    
    plan
    
    Implementation Changes: Direct Email Send (Email Orders)
    Requirements: Direct Email Send (Email Orders)
    Specification: Direct Email Send (Email Orders)
    Verification: Direct Email Send (Email Orders)
    
    UI Implementation Analysis: Direct Email Send (arda-frontend-app)
    
    Procurement
  - Receiving
    
    Receiving
    
    receivers
    
    Receivers
  - Reference Data
    
    item
    
    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
    
    Item Image Upload
    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
    
    scan-to-item
    
    Scan to Item
    Scan to Item — Backend
    Scan to Item — Frontend and UX
    Bind a QR to an Item
    Adapters and source authority
    Evaluation and acceptance
    
    Item
    
    add-items-from-amazon
    
    Add Items From Amazon
    Auto-Fill Field Indicators
    
    upc-fallback
    
    UPC Fallback for Amazon Search
    Implementation Changes — UPC Fallback for Amazon Search
    Scope Definition — Strengthening ID Identification
    
    amazon-client-integration
    
    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
    
    amazon-import-search
    
    Amazon Import — Free-Text Search BFF Route
    Goal: Amazon Import — Free-Text Search BFF Route
    Amazon Import — Query Relaxation and Zero-Result Augmentation Exploration
    Amazon Import — Specification Analysis
    Amazon Import — Task Plan
    
    Canonical Supply Reconciliation & Heal-on-Write
    
    connect-supply-to-supplier
    
    Connect Item.Supply to Business Affiliate References
    Decision Log: Connect Item.Supply to Business Affiliate References
    Design: Connect Item.Supply to Business Affiliate References
    Goal: Connect Item.Supply to Business Affiliate References
    Project Plan: Connect Item.Supply to Business Affiliate References
    
    filter-sort-project
    
    Spike #855 — Item List Filter & Sort
    Item Filter & Sort — Architecture Reference
    Item Filter & Sort — Implementation Notes
    Spike #855 — Item List Filter & Sort: Proposal (Historical)
    Spike #855 — Item Filter & Sort: Summary
    Item Filter & Sort — Visual Architecture
    
    inventory-v00
    
    Inventory v00
    Analysis: Inventory v00
    Goal: Inventory v00
    Implementation Changes: Inventory v00
    Requirements: Inventory v00
    Specification: Inventory v00
    Verification: Inventory v00
    
    Item Delete Bug #782 -- PROPAGATE Fork Fix
    
    item-identifiers
    
    Item Identifiers
    Decision Log: Item Identifiers
    Design: Item Identifiers
    Goal: Item Identifiers
    Project Plan: Item Identifiers
    
    manufacturer-field
    
    Item Manufacturer Field
    Decision Log: Item Manufacturer Field
    Design: Item Manufacturer Field
    Goal: Item Manufacturer Field
    Project Plan: Item Manufacturer Field
    
    Reference Data
    
    business-affiliate
    
    Business Affiliate
    Business Affiliate Design -- Suppliers Feature
    Business Affiliate Workflows
    
    vendor-page-and-standard-layout
    
    Vendor Page and Standard Layout
    Design: ConnectedDataGrid & the Bulk-Edit Write Path
    Phase 2: Standardized AG Grid
    Phase 3: Vendor Page — Field Inventory
    Decision Log: Rich Cell Data Types
    Design: Rich Cell Data Types
  - Resources
    
    Resources
    
    facilities
    
    Facilities
    
    inventory-items
    
    Inventory Items
    
    kanban-cards
    
    Kanban Cards
    Item Delete -- Card State Propagation
    
    kanban-cards-with-deleted-items
    
    Kanban Cards With Deleted Items
    
    phase-1
    
    Goal: Kanban Cards with Deleted Items — Phase 1 (backend)
    Specification: Kanban Cards with Deleted Items — Phase 1 (backend)
    Verification: Kanban Cards with Deleted Items — Phase 1 (backend)
    
    loops
    
    Loops
    
    operators
    
    Operators
    
    stations
    
    Stations
  - Shipping
    
    Shipping
    
    shipments
    
    Shipments
  - Shop Access
    
    Shop Access
    
    email
    
    Email
    
    email-integration
    
    Email Integration -- Project Goal
    
    1-external-resources
    
    Phase 1 -- External Resources Provisioning -- Analysis
    Phase 1 -- External Resources Provisioning -- Exports
    
    implementation
    
    Phase 1 -- Implementation Alternatives
    Phase 1 -- Implementation Changelog
    Phase 1 -- Implementation Learnings
    Phase 1 -- Implementation Skipped
    Phase 1 -- Specification Post-Implementation
    Phase 1 -- Implementation Suggestions
    
    plan
    
    Phase 1 -- External Resources Provisioning -- Task Plan
    
    Phase 1 -- External Resources Provisioning -- Requirements
    Phase 1 -- External Resources Provisioning -- Specification
    Phase 1 -- External Resources Provisioning -- Verification
    
    2-root-updates
    
    Phase 2 -- Root Updates -- Analysis
    Phase 2 -- Root Updates -- Exports
    
    implementation
    
    Phase 2 -- Implementation Alternatives
    Phase 2 -- Implementation Changelog
    Phase 2 -- Implementation Learnings
    Phase 2 -- Implementation Skipped
    Phase 2 -- Specification Post-Implementation
    Phase 2 -- Implementation Suggestions
    
    plan
    
    Phase 2 -- Root Updates -- Task Plan
    
    Phase 2 -- Root Updates -- Requirements
    Phase 2 -- Root Updates -- Specification
    Phase 2 -- Root Updates -- Verification
    
    3-corporate-updates
    
    Phase 3 -- Corporate Updates -- Analysis
    Phase 3 -- Corporate Updates -- Exports
    
    implementation
    
    Phase 3 -- DQ-R1-009 Placement Divergence and Resolution
    Phase 3 -- Implementation Learnings
    Phase 3 -- Phase B Deploy Log
    Phase 3 -- Implementation Suggestions
    
    Phase 3 -- Operator Checklist: Postmark Domain Verification
    
    plan
    
    Phase 3 -- Corporate Updates -- Task Plan
    
    Phase 3 -- Corporate Updates -- Requirements
    Phase 3 -- Corporate Updates -- Specification
    Phase 3 -- Corporate Updates -- Verification
    
    4-runtime-platform-updates
    
    design
    
    Phase 4 -- Runtime Platform Updates -- Analysis
    Design: Per-Partition Email Server-Token Encryption Key
    Phase 4 -- Runtime Platform Updates -- Exports
    Phase 4 Design Quality Review (round 1)
    Phase 4 -- Runtime Platform Updates -- Requirements
    Phase 4 -- Runtime Platform Updates -- Specification
    Phase 4 -- Runtime Platform Updates -- Verification
    
    Goal: Email Integration Phase 4 -- Runtime Platform Updates
    
    plan
    
    Phase 4 — Run Choreography
    Phase 4 — Planning Shape Evaluation
    
    runs
    
    Phase 4 Runs
    
    run-1-workspace-refactors
    
    Phase 4 — Run 1: Workspace Refactors (G-A)
    
    run-2-dev-rollout
    
    Run-2 Plan Review 1
    Phase 4 — Run 2: dev Partition Rollout (G-B+C+D)
    
    run-3-operator-cascade
    
    Phase 4 — Run 3: Operator Cascade Execution Log
    Phase 4 — Run 3: Operator Cascade (dev → stage and demo → prod)
    
    run-6-drift-workflow
    
    Phase 4 — Run 6: runtime-platform-drift Workflow (G-E)
    
    run-7-documentation
    
    Phase 4 — Run 7: Documentation Deliverables (G-F)
    
    5a-component-library-updates
    
    design
    
    Design: Email Integration Phase 5a -- Component Library Updates
    Design: Idempotency Helpers (Phase 5a)
    
    Goal: Email Integration Phase 5a -- Component Library Updates
    Task Plan: Email Integration Phase 5a
    
    5b-email-module
    
    Phase 5b — Email Module
    Phase 5b — Pre-Go-Live Design Corrections
    Phase 5b -- Pre-Existing Decisions
    
    Email Integration -- Architecture Overview (Revision 1)
    Email Integration -- Cross-Cutting Design (Revision 1)
    Email Integration -- Current-System Documentation Retrofit (Revision 1)
    Decision Log: Email Integration
    
    exploration
    
    Email Integration -- Architectural Scenarios
    Email Integration -- Dependency Analysis
    Email Integration -- Functional Design
    Email Integration -- Infrastructure Design
    Email Integration -- Phased Design Requirements
    Email Integration -- Postmark Service Design
    Email Integration -- Exploration & Handoff
    Email Integration -- Runtime Design
    Email Integration -- Code Reconciliation Tasks
    
    Email Integration -- Project Goal
    Email Integration -- Revision 1: Phase Structure
    
    reviews
    
    R1
    
    Phase 0 Infrastructure PR Review (PR #445)
    Runtime documentation -- design review and update proposal
    Phase 0 PR Review -- Scratch / Action Notes
    
    print
    
    Print
    
    extra-printing-options
    
    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
    
    multi-pdf-print-and-bugs
    
    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
    
    scan
    
    Scan
  - System
    
    System
    Accounts Component -- common-module 6.x Migration
    
    messaging
    
    Messaging
    
    invitation-mail-server
    
    1-sending-library
    
    Requirements: Sending Library (Phase 1)
    Specification: Sending Library (Phase 1)
    Verification: Sending Library (Phase 1)
    
    2-partition-provisioning
    
    Requirements: Partition Provisioning (Phase 2)
    Specification: Partition Provisioning (Phase 2)
    Verification: Partition Provisioning (Phase 2)
    
    3-operations-wiring
    
    Requirements: Operations Wiring (Phase 3)
    Specification: Operations Wiring (Phase 3)
    Verification: Operations Wiring (Phase 3)
    
    4-rollout
    
    Specification: Rollout and Release (Phase 4)
    
    Decision Log: Invitation Mail Server
    Design: Invitation Mail Server
    Goal: Invitation Mail Server
    Project Plan: Invitation Mail Server
    
    security
    
    Security
    
    static-asset-repository
    
    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
  - Workflows & Integrations
    
    Workflows & Integrations
- Engineering
  - agentic-tooling
    
    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
    
    hypothesis-mcp
    
    Hypothesis MCP
    Hypothesis MCP — Specification
    
    Agentic Tooling
    
    skills-mcp-server
    
    Skills MCP Server
    Design
    Goal
    Implementation Changes
    Kickoff
    
    plan
    
    Task Plan
    Team Split Assessment
    
    Requirements
    Specification
    Verification
    
    UX Prototype -- Agentation Adoption
  - ci-cd
    
    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
    
    Frontend Pipeline
    
    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
    
    CI/CD
    
    queued-cicd-adoption
    
    Queued CI/CD Adoption
    Decision Log: Queued CI/CD Adoption
    Design: Queued CI/CD Adoption
    Goal: Queued CI/CD Adoption
    Requirements: Queued CI/CD Adoption
  - frontend-platform
    
    components-ph-II
    
    Canary Component Gap Analysis — arda-frontend-app
    Components Phase II
    
    button-audit
    
    Button Style Audit — Vendored Frontend
    Button Standardization — Project Status
    
    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
    
    List View Component
    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
    
    update-ba-stories-to-components
    
    Business Affiliates Stories — Canary Refactoring Specification
    Update BA Stories To Components
    
    Frontend Platform
    AG Grid Refactor
    
    api-proxy
    
    Arda API Proxy — Typed TypeScript Client
    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
    
    component-preparation
    
    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
    
    ui-componentization
    
    UI Componentization
    Component Configuration Endpoint (common-module v6.6.0)
  - process
    
    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
    Callil Branch Merge
    
    Process
    Architecture Explorations
    
    callil-consolidation
    
    Callil Consolidation
    
    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
    
    doc-search-ranking
    
    Doc Search Ranking
    Front-Page Dual Search
    Goal: Doc Search Ranking
    Options: Doc Search Ranking
    
    doc-update
    
    Doc Update
    Documentation Update Analysis
    
    Documentation Consolidation
    Pull Request Review Guidelines
  - Engineering
  - backend-platform
    
    Backend Platform
    
    settings-library
    
    Tenant & User Settings Library
    Decision Log: Tenant & User Settings Library
    Design: Tenant & User Settings Library
  - quality
    
    Quality
    
    acceptance-test-failures
    
    Acceptance Test Failures
    
    pdev-610
    
    Design: PDEV-610 Cross-User Staleness Signal
    Goal: PDEV-610 — Stale-Data Banner Cross-User Signal
    Implementation Plan: PDEV-610 Cross-User Staleness Signal
    Investigation: PDEV-610 Stale-Data Banner Cross-User Signal
    
    Complexity Hotspot Remediation
    Frontend Test Coverage Improvements
    
    operations-api-tests
    
    Operations API Tests (TypeScript)
    
    design
    
    Operations API Tests — Design
    Operations API Tests — Design Log
    Operations API Tests — Goal
    Operations API Tests — Verification
    
    work-in-progress
    
    Decision Log: Operations API Tests
    Design: Operations API Tests — Structure and Layering
    Goal: Operations API Tests (TypeScript)
    Porting Plan: Bruno → TypeScript Suite
    
    SonarJS Complexity Metrics Integration
    TypeScript Quality Tools -- Stryker and SonarJS
Process
- Overview
- Development Activities
- APDS
- SRE/OAM
  - Overview
  - Runbooks
    
    Overview
    Runbook: Amazon Creators API Onboarding
    Runbook: Incident Response
    Runbook: JVM Profiling — JFR and Heap Dumps
- 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 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
About

Select theme

On this page

Overview
Documents
Sections

On this page

Overview
Documents
Sections

Component Preparation

Roadmap project documentation for Component Preparation.

Documents

Section titled “Documents”

Analysis
Goal

Sections

Section titled “Sections”

1 Legacy Cleanup
2 Utility Extraction
3 Local Dev Tooling

Previous
Verification: Arda API Proxy Next
Requirements: Legacy Cleanup

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