low-level-design

Files (3)

• SKILL.md
• diagram-examples.md · references/
• subskills.md

SKILL.md (first lines)

# Low-Level Design

Create detailed design artifacts for implementation planning with end-to-end traceability.

## Purpose

Produce implementation-ready technical designs that map directly to architecture decisions and requirement intent.

## When to Use

- Post-architecture component design
- Sprint-level implementation decomposition
- Engineering handoff for build/test teams

## Inputs Required

- Approved architecture references
- FSD and user story set
- NFR and security constraints

## Outputs Produced

- LLD section set with component/runtime detail
- Sequence/state/data/API artifacts
- ASST and Well-Architected checks
- Requirement-to-test traceability matrix

## LLD Coverage for Enterprise Architecture Change

Every LLD must align to the Architecture-Change-Definition and include:

1. Component decomposition and responsibilities
2. API/action contracts and validation rules
3. Data model details and persistence mappings
4. Sequence/state flows for primary and exception paths
5. Error handling, retries, and compensations
6. Security controls at component boundary level
7. Performance, scalability, and capacity constraints
8. Deployment/runtime dependencies and operational hooks
9. Testability design and verification points
10. Traceability links to requirements, architecture sections, and test artifacts

## ASST Aspects for LLD

- **Availability**: redundancy, retry/timeout, graceful degradation, recovery behavior
- **Security**: authentication/authorization, data protection, secrets handling, audit events
- **Scalability**: concurrency model, partitioning, bottleneck controls, throughput targets
- **Traceability**: IDs and mappings from requirement to module/API/DB/test

## Well-Architected Principle Checks (LLD)

Ensure each LLD section addresses:

- Design for Scalability
- Design for Resiliency
- Design for Efficiency
- Design for Interoperability and Modularity

## Traceability Matrix Requirements

Produce or update a traceability matrix with at least these links:

- Requirement ID → LLD component/module
- Requirement ID → API/action contract
- Requirement ID → Data entity/table
- Requirement ID → Sequence/state diagram reference
- Requirement ID → Test case/quality gate


## LLD Output Sections (Required)

1. LLD scope and assumptions
2. Component/module catalog
3. API/action contract catalog
4. Data model and persistence details
5. Interaction diagrams (sequence/state)
6. ASST assessment
7. Well-Architected alignment table
8. Traceability matrix aligned to architecture and tests

## Integration with UI/UX Design

When designing systems with user interfaces, use UI/UX designer outputs:

| UI/UX Output | LLD Use |
|--------------|---------|
| User journeys | Sequence diagram actors and flows |
| Wireframes | UI component interactions |
| Figma specs | Frontend component structure |
| User flows | State machine transitions |

### UI Interaction Sequence

Include UI layer in sequence diagrams when relevant:

```mermaid
sequenceDiagram
    actor User
    participant UI as Frontend
    participant API as API Gateway
    participant Svc as Service
    participant DB as Database
    
    User->>UI: Click "Submit"
    UI->>UI: Validate form
    UI->>UI: Show loading state
    UI->>API: POST /orders
    API->>Svc: createOrder()
    Svc->>DB: INSERT order
    DB-->>Svc: order record
    Svc-->>API: OrderDTO
    API-->>UI: 201 Created
    UI->>UI: Hide loading
    UI-->>User: Show success message
```

### UI State Machine

Map UI states from user journeys:

From x1chg956/sdlc-skills, Apache-2.0.

More from x1chg956/sdlc-skills