┌─────────────────────────────────────────────────────────────┐
│                  Quality Attribute Scenario                  │
├──────────────┬──────────────────────────────────────────────┤
│ Source       │ Who/what generates the stimulus              │
├──────────────┼──────────────────────────────────────────────┤
│ Stimulus     │ The event or condition                       │
├──────────────┼──────────────────────────────────────────────┤
│ Artifact     │ What part of system is affected              │
├──────────────┼──────────────────────────────────────────────┤
│ Environment  │ Under what conditions                        │
├──────────────┼──────────────────────────────────────────────┤
│ Response     │ How the system should respond                │
├──────────────┼──────────────────────────────────────────────┤
│ Measure      │ How we measure the response                  │
└──────────────┴──────────────────────────────────────────────┘

Availability Tactics
├── Detect Faults
│   ├── Ping/Echo
│   ├── Heartbeat
│   ├── Voting (redundant components)
│   ├── Exception Handling
│   └── Self-Test
├── Recover from Faults
│   ├── Active Redundancy (hot standby)
│   ├── Passive Redundancy (warm standby)
│   ├── Spare (cold standby)
│   ├── Rollback
│   ├── Retry
│   └── Ignore Faulty Behavior
└── Prevent Faults
    ├── Removal from Service
    ├── Transactions
    ├── Process Monitor
    └── Exception Prevention

Performance Tactics
├── Control Resource Demand
│   ├── Manage Sampling Rate
│   ├── Limit Event Response
│   ├── Prioritize Events
│   ├── Reduce Overhead
│   └── Bound Execution Times
├── Manage Resources
│   ├── Increase Resources
│   ├── Introduce Concurrency
│   ├── Maintain Multiple Copies (caching)
│   └── Bound Queue Sizes
└── Arbitrate Resources
    ├── Scheduling Policy
    └── Load Balancing

Security Tactics
├── Detect Attacks
│   ├── Intrusion Detection
│   └── Monitoring/Logging
├── Resist Attacks
│   ├── Authenticate Actors
│   ├── Authorize Actors
│   ├── Maintain Data Confidentiality
│   ├── Maintain Data Integrity
│   ├── Limit Exposure
│   └── Limit Access
├── React to Attacks
│   ├── Revoke Access
│   ├── Lock Account
│   └── Inform Actors
└── Recover from Attacks
    ├── Audit Trail
    └── Restore State

Modifiability Tactics
├── Reduce Size of Module
│   └── Split Module
├── Increase Cohesion
│   └── Increase Semantic Coherence
├── Reduce Coupling
│   ├── Encapsulate
│   ├── Use an Intermediary
│   ├── Restrict Dependencies
│   └── Abstract Common Services
└── Defer Binding
    ├── Compile Time
    ├── Build Time
    ├── Deployment Time
    ├── Startup Time
    └── Runtime

For each critical use case:
1. Identify relevant quality attributes
2. Write quality attribute scenarios
3. Prioritize scenarios (high/medium/low)
4. Get stakeholder sign-off on priorities

For each high-priority scenario:
1. Review applicable tactics
2. Evaluate trade-offs with other scenarios
3. Select tactics that balance requirements
4. Document decisions (ADRs)

Apply selected tactics to architecture:
1. Choose patterns that embody tactics
2. Design components and interactions
3. Validate against scenarios
4. Review trade-offs with stakeholders

Ensure quality attributes are achieved:
1. Define SLIs/SLOs for each attribute
2. Implement monitoring and alerting
3. Conduct architecture evaluations (ATAM)
4. Iterate based on production data

CORE ATTRIBUTES
├── Availability  → Uptime, fault tolerance
├── Performance   → Response time, throughput
├── Security      → Confidentiality, integrity, authentication
├── Modifiability → Change cost, extensibility
├── Testability   → Observability, controllability
└── Usability     → Learnability, efficiency

SCENARIO TEMPLATE
[Source] → [Stimulus] → [Artifact] in [Environment]
    → [Response] measured by [Metric]

COMMON TRADE-OFFS
Security ←→ Performance (encryption overhead)
Availability ←→ Cost (redundancy expense)
Performance ←→ Modifiability (optimization complexity)

DESIGN APPROACH
1. Write measurable scenarios
2. Prioritize with stakeholders
3. Select appropriate tactics
4. Accept and document trade-offs
5. Validate in production