diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
new file mode 100644
index 0000000..bb1dd86
--- /dev/null
+++ b/.github/workflows/tests.yml
@@ -0,0 +1,28 @@
+name: Tests
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+
+jobs:
+  unit-tests:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install -r requirements.txt
+
+      - name: Run unit tests
+        run: pytest -q tests
diff --git a/.gitignore b/.gitignore
index 7c1be10..41a342a 100644
--- a/.gitignore
+++ b/.gitignore
@@ -2,3 +2,4 @@
 __pycache__/
 *.pyc
 database/*.db
+.env
diff --git a/.vscode/settings.json b/.vscode/settings.json
index ba2a6c0..c9ebf2d 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -1,4 +1,3 @@
 {
-    "python-envs.defaultEnvManager": "ms-python.python:system",
-    "python-envs.pythonProjects": []
+    "python-envs.defaultEnvManager": "ms-python.python:system"
 }
\ No newline at end of file
diff --git a/AI_EXPERIMENT.md b/AI_EXPERIMENT.md
new file mode 100644
index 0000000..8ddc632
--- /dev/null
+++ b/AI_EXPERIMENT.md
@@ -0,0 +1,426 @@
+# 🤖 AURORA - Scenario Simulation Experiment
+
+**Branch:** `aura-ai-prototype`  
+**Status:** 🧪 Experimental - In Active Development  
+**Created:** April 1, 2026
+
+---
+
+## 🎯 Vision
+
+Transform ressourcenplanner from a **resource tracking tool** into an **AI-powered workforce optimization platform** that predicts the impact of management decisions.
+
+**Key Question:** Instead of asking "What are our resources?", ask "What happens if...?"
+
+---
+
+## 💡 What This Does
+
+### Available Scenarios
+
+#### 1. **Hiring Delay Impact Simulator** ✅
+```
+"If we delay hiring for Component X by 60 days, what happens to our timeline and budget?"
+
+Input:
+  - Component to delay
+  - Delay duration (days)
+  - Component criticality
+
+Output:
+  - Predicted timeline delay
+  - Budget impact (€)
+  - Risk increase (%)
+  - AI recommendation + alternatives
+```
+
+#### 2. **Employee Impact Analyzer** ✅
+```
+"What happens if we add Jane (Senior Dev) to our team?"
+
+Input:
+  - New employee details
+  - Assigned components
+  - Start date
+  - Salary
+
+Output:
+  - Key risk reductions
+  - Timeline improvements
+  - Budget implications
+  - Knock-on effects
+  - Hire/No Hire recommendation
+```
+
+#### 3. **Component Risk Assessment** ✅
+```
+"How risky is Component X right now?"
+
+Input:
+  - Component name
+  - Current vs required staffing
+
+Output:
+  - Risk score (0-100)
+  - Single point of failure assessment
+  - Months until critical
+  - Priority hiring needed
+  - Alternatives to hiring
+```
+
+#### 4. **Hiring Priority Optimizer** ✅
+```
+"We can hire 3 people with €180K. Which components first?"
+
+Input:
+  - Budget available
+  - Max hires allowed
+
+Output:
+  - Optimal hiring sequence (by priority)
+  - Cost breakdown
+  - Risk reduction by sequence
+  - Why this sequence wins
+```
+
+#### 5. **Knowledge Transfer Success Predictor** ✅
+```
+"Will the KT succeed if Alex leaves in 120 days?"
+
+Input:
+  - Departing person
+  - KT duration (weeks)
+  - Assigned replacement (optional)
+
+Output:
+  - Success probability
+  - KT plan phases
+  - Critical tasks
+  - Budget for external help
+  - Contingency if KT fails
+```
+
+---
+
+## 🔧 Technical Stack
+
+### AI Model
+- **Groq - Mixtral 8x7B** (Free & Lightning Fast, but only used for exprimenting)
+  - State-of-the-art open model
+  - Perfect for business scenario analysis
+  - **100% FREE** - no payment required
+  - Ultra-fast inference (< 1 second)
+- Final version will have custom trained models from Siemens internal platform- Siemens Xcelerator tom increase data safety and accurate decisions.
+
+### Additional Libraries
+```python
+groq==0.9.0           # Groq API client
+streamlit>=1.28.0     # Already included
+pandas>=2.0.0         # Already included
+plotly>=5.0.0         # Already included
+```
+
+---
+
+## 🚀 How to Use
+
+### Step 1: Get FREE API Key
+
+1. Visit [console.groq.com](https://console.groq.com)
+2. Sign up for free (takes 1 minute)
+3. Copy your API key (starts with `gsk_`)
+
+### Step 2: Set Environment Variable
+
+```bash
+# macOS/Linux
+export GROQ_API_KEY=gsk-your-key-here
+
+# Windows (PowerShell)
+$env:GROQ_API_KEY='gsk-your-key-here'
+
+# Or add to .env file (then load with python-dotenv)
+```
+
+### Step 3: Install Dependencies
+
+```bash
+pip install -r requirements.txt
+```
+
+### Step 4: Run the App
+
+```bash
+streamlit run app.py
+```
+
+### Step 5: Navigate to Scenario Analysis
+
+In the sidebar, click: **🤖 Scenario Analysis AI**
+
+---
+
+## 💰 Cost Estimation
+
+### API Pricing (Anthropic Claude 3.5 Sonnet)
+- **Input:** $3 per 1M tokens
+- **Output:** $15 per 1M tokens
+
+### Usage Estimates
+| Scenario Type | Avg Tokens | Cost |
+|---------------|-----------|------|
+| Hiring Delay | ~800 | $0.06 |
+| Employee Impact | ~900 | $0.07 |
+| Component Risk | ~700 | $0.05 |
+| Hiring Priority | ~1,200 | $0.09 |
+| KT Success | ~1,000 | $0.08 |
+
+**Monthly Budget (1000 scenarios):** ~$50-75
+
+---
+
+## 📚 Example Workflows
+
+### Workflow 1: Hiring Decision Support
+```
+Manager: "Should we hire now or wait?"
+
+1. Go to: Hiring Delay Impact Simulator
+2. Enter: Component, 60-day delay, criticality level
+3. AI predicts: Timeline delay, budget impact, risk increase
+4. Result: Clear recommendation + alternatives
+```
+
+### Workflow 2: New Hire Evaluation
+```
+HR: "Is Jane a good hire for our team?"
+
+1. Go to: Employee Impact Analyzer
+2. Enter: Jane's role, components, salary, start date
+3. AI predicts: Risk reductions, impact on critical components
+4. Result: Recommendation + alternative scenarios
+```
+
+### Workflow 3: Annual Planning
+```
+Executive: "Where should we focus hiring this year?"
+
+1. Go to: Hiring Priority Optimizer
+2. Enter: Total budget, max number of hires
+3. AI analyzes: All components, all risks, all opportunities
+4. Result: Optimal sequenced hiring plan with ROI
+```
+
+---
+
+## 🧠 How the AI Works
+
+### Scenario Engine Architecture
+
+```
+┌─────────────────────────────────────────┐
+│  1. User Input (Scenario + Constraints) │
+└──────────────┬──────────────────────────┘
+               ↓
+┌─────────────────────────────────────────┐
+│  2. Build Context (Current State Data)  │
+│     - Team roster                       │
+│     - Component assignments             │
+│     - Exit dates, KT status             │
+│     - Budget constraints                │
+└──────────────┬──────────────────────────┘
+               ↓
+┌─────────────────────────────────────────┐
+│  3. Craft Intelligent Prompt            │
+│     - Business context                  │
+│     - Decision scenario                 │
+│     - Constraints & rules               │
+│     - Output format (JSON)              │
+└──────────────┬──────────────────────────┘
+               ↓
+┌─────────────────────────────────────────┐
+│  4. Call Claude API                     │
+│     - Stream reasoning                  │
+│     - Generate structured output        │
+│     - Provide alternatives              │
+└──────────────┬──────────────────────────┘
+               ↓
+┌─────────────────────────────────────────┐
+│  5. Parse & Display Results             │
+│     - Metrics (timeline, budget, risk)  │
+│     - Recommendation                    │
+│     - Confidence score                  │
+│     - Alternative approaches            │
+└─────────────────────────────────────────┘
+```
+
+### Key Intelligence Points
+
+1. **Context Awareness:** AI understands team size, criticality, constraints
+2. **Risk Modeling:** Predicts cascading effects of decisions
+3. **Business Logic:** Considers hiring timelines, ramp-up periods, KT duration
+4. **Alternative Generation:** Always suggests Plan B and Plan C
+5. **Confidence Scoring:** AI rates its own certainty (0-100%)
+
+---
+
+## 🔬 Experiment Log
+
+### Phase 1: Foundation (This Sprint)
+- ✅ Created scenario_engine.py with Claude integration
+- ✅ Built Scenario_Analysis.py UI
+- ✅ Implemented 5 core scenarios
+- ⏳ Testing with real data
+- ⏳ Validating accuracy of predictions
+
+### Phase 2: Refinement (Next Sprint)
+- [ ] Add more scenario templates
+- [ ] Integrate with database for historical accuracy
+- [ ] Add visualization for complex scenarios
+- [ ] Build scenario comparison (side-by-side)
+- [ ] Add scenario saving/loading
+
+### Phase 3: Production (Q2)
+- [ ] Fine-tune prompts based on feedback
+- [ ] Add cost model validation
+- [ ] Implement scenario analytics
+- [ ] Build recommendation confidence calibration
+- [ ] Merge to main branch with docs
+
+---
+
+## 🧪 Testing the AI
+
+### Quick Test 1: Hiring Delay Impact
+```
+1. Go to Scenario Analysis
+2. Select "Hiring Impact: Delay hiring"
+3. Component: Any component
+4. Delay: 30 days
+5. Criticality: standard
+6. Click "Simulate"
+```
+
+Expected: Should show reasonable timeline/budget impacts
+
+### Quick Test 2: Employee Impact
+```
+1. Select "Employee Impact: Add new hire"
+2. Name: "Test Employee"
+3. Role: "Developer"
+4. Level: "mid"
+5. Components: Any 2 components
+6. Cost: €5000/month
+7. Click "Simulate"
+```
+
+Expected: Should show risk reduction and budget impact
+
+### Quick Test 3: Risk Assessment
+```
+1. Select "Component Risk"
+2. Component: Any component
+3. Click "Analyze Risk"
+```
+
+Expected: Should provide risk score and recommendations
+
+---
+
+## 📊 Success Criteria
+
+We'll consider this successful when:
+
+- [ ] AI predictions match manager expectations
+- [ ] API cost < €100/month for reasonable usage
+- [ ] Response time < 10 seconds per scenario
+- [ ] Users prefer AI recommendations > manual analysis
+- [ ] Scenarios actually improve hiring decisions
+
+---
+
+## 🐛 Known Limitations
+
+1. **Historical Context:** AI doesn't have access to past decisions/outcomes
+2. **Real-time Data:** Uses snapshot at time of analysis
+3. **Complexity:** Simplified model of workforce dynamics
+4. **Confidence:** AI may be overly confident about uncertain predictions
+5. **Edge Cases:** Unusual scenarios may produce unreliable results
+
+---
+
+## 🔮 Future Ideas
+
+### V2 Features
+- **Scenario Comparison:** Compare Option A vs Option B side-by-side
+- **Scenario Saving:** Save/share scenarios with team
+- **Historical Validation:** Compare AI predictions to actual outcomes
+- **Batch Analysis:** Analyze multiple scenarios at once
+- **Drill-Down:** Explain *why* AI made each prediction
+
+### V3 Features
+- **ML Model Integration:** Use historical data to train custom models
+- **Monte Carlo Simulation:** Run 1000 scenarios with uncertainty ranges
+- **Portfolio Optimization:** Optimize entire hiring portfolio simultaneously
+- **Sensitivity Analysis:** "What happens if X becomes 50% worse?"
+- **Slack Integration:** Ask AI scenarios via Slack
+
+---
+
+## 📝 Development Guide
+
+### Adding a New Scenario
+
+1. **Add method to `AurorAI` engine:**
+```python
+def my_new_scenario(self, param1, param2, ...):
+    """Describe what this scenario does."""
+    prompt = f"""
+    [Build intelligent prompt]
+    """
+    return self._call_claude_scenario(prompt, "my_scenario")
+```
+
+2. **Add UI section to `Scenario_Analysis.py`:**
+```python
+elif scenario_type == "My New Scenario":
+    # Collect user inputs
+    # Call simulator method
+    # Display results
+```
+
+3. **Test with real data**
+
+### Improving Prompts
+
+Prompts are in `AurorAI` methods. To improve:
+1. Try different wording
+2. Add/remove context
+3. Change output format
+4. Test with edge cases
+5. Iterate based on results
+
+---
+
+## 📞 Support & Questions
+
+For issues or suggestions:
+1. Check if API key is configured correctly
+2. Verify components/team data exists
+3. Check API quota at console.anthropic.com
+4. Review error message in Streamlit
+
+---
+
+## 🎓 References
+
+- Claude Model Card: https://www-cdn.anthropic.com/de8ba9b01c9ab7cbabf5c33b80b090fdee56ec1ee6b38a973b515e87e91fee53/Model_Card_Claude_3.pdf
+- Anthropic API Docs: https://docs.anthropic.com/
+- Prompt Engineering Guide: https://docs.anthropic.com/claude/docs/how-to-use-system-prompts
+
+---
+
+**Last Updated:** April 1, 2026  
+**Branch:** aura-ai-prototype  
+**Author:** AURA Development Team
+
diff --git a/AURA_ARCHITECTURE_DIAGRAMS.md b/AURA_ARCHITECTURE_DIAGRAMS.md
new file mode 100644
index 0000000..9350908
--- /dev/null
+++ b/AURA_ARCHITECTURE_DIAGRAMS.md
@@ -0,0 +1,692 @@
+# 🏗️ AURA: Architecture Diagrams (AURORA Engine) & Visual Analysis
+
+This document contains detailed architecture diagrams for the AURORA system.
+
+---
+
+## 1. SYSTEM ARCHITECTURE (3-Layer Model)
+
+```
+┌─────────────────────────────────────────────────────────────────────┐
+│                     PRESENTATION LAYER                              │
+│                      (Streamlit Web UI)                             │
+│                                                                      │
+│  ┌──────────────┬──────────────┬─────────┬────────┬──────────────┐ │
+│  │   Executive  │   Stammdaten │ Project │Budget  │ 🤖 AURORA   │ │
+│  │  Dashboard   │  Management  │ Alloc.  │ Mgmt   │  AI Engine  │ │
+│  │              │              │         │        │             │ │
+│  │ • Team stats │ • Add/edit   │• Timeline│• Cost  │• Hiring     │ │
+│  │ • KPIs       │ • Components │• Capacity│ charts │  delay      │ │
+│  │ • Alerts     │ • Budgets    │• Gantt  │• Budget│• Employee   │ │
+│  │              │              │         │        │  addition   │ │
+│  └──────────────┴──────────────┴─────────┴────────┴──────────────┘ │
+│                             △                                        │
+│                    (State management                                 │
+│                    via session_state)                               │
+└─────────────────────────────┬───────────────────────────────────────┘
+                              │
+┌─────────────────────────────┴───────────────────────────────────────┐
+│                      LOGIC LAYER                                    │
+│                (Business Logic & Services)                          │
+│                                                                      │
+│  ┌──────────────┬──────────┬───────────┬─────────┬──────────────┐  │
+│  │  AURORA      │  Team    │ Finance   │Allocation│Visualiz.   │  │
+│  │  Engine      │ Service  │ Service   │Service   │Service     │  │
+│  │              │          │           │          │            │  │
+│  │ • Scenario   │• Compute │• Calc     │• Allocate│• Plotly    │  │
+│  │   analysis   │  derived │  costs    │  capacity│ • Charts   │  │
+│  │ • Multi-dim. │  fields  │• Budget   │• Validate│ • Gauges   │  │
+│  │   impact     │• Priority│  forecasts│  utiliz. │ • Heatmaps │  │
+│  │ • Reasoning  │• KT      │           │          │            │  │
+│  │   prompts    │  status  │           │          │            │  │
+│  └──────────────┴──────────┴───────────┴─────────┴──────────────┘  │
+│                              △                                       │
+│                     (Full data access,                              │
+│                     query building)                                 │
+└─────────────────────────────┬───────────────────────────────────────┘
+                              │
+┌─────────────────────────────┴───────────────────────────────────────┐
+│                    DATA ACCESS LAYER                                │
+│                   (Repository Pattern)                              │
+│                                                                      │
+│  ┌──────────────┬──────────────┬────────────┬──────────┬─────────┐ │
+│  │    Team      │   Finance    │Allocation  │ Settings │ Session │ │
+│  │ Repository   │ Repository   │Repository  │Resources │  Store  │ │
+│  │              │              │            │          │        │ │
+│  │ • Get members│ • Get budgets │• Get alloc │• Get    │• Persist│ │
+│  │ • Add member │ • Set budgets │• Add alloc │  rates  │ • Load  │ │
+│  │ • Update     │ • Calc costs  │• Check     │• Set    │  state  │ │
+│  │ • Delete     │               │  capacity  │  rates  │        │ │
+│  └──────────────┴──────────────┴────────────┴──────────┴─────────┘ │
+│                              △                                       │
+│                        (SQL queries                                 │
+│                         to SQLite)                                  │
+└─────────────────────────────┬───────────────────────────────────────┘
+                              │
+┌─────────────────────────────┴───────────────────────────────────────┐
+│                    PERSISTENCE LAYER                                │
+│                   (SQLite Database)                                 │
+│                                                                      │
+│  ┌──────────────────────────────────────────────────────────────┐  │
+│  │ Tables:                                                      │  │
+│  │  ├─ team_members (employees, roles, components)             │  │
+│  │  ├─ budget_settings (cost per employee type)                │  │
+│  │  ├─ employee_settings (individual rates)                    │  │
+│  │  ├─ project_allocations (capacity assignments)              │  │
+│  │  └─ app_config (application configuration)                  │  │
+│  │                                                              │  │
+│  │ File: ressourcenplanner.db (local SQLite file)              │  │
+│  └──────────────────────────────────────────────────────────────┘  │
+└─────────────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## 2. AURORA ENGINE WORKFLOW (AURA's AI Brain)
+
+```
+┌──────────────────────────────────────────────────────────────┐
+│           USER INTERACTION                                  │
+│  (Select scenario + Parameters)                             │
+└──────────────────┬───────────────────────────────────────────┘
+                   │
+    ┌──────────────▼────────────────┐
+    │ AURORA ENGINE INIT (AURA Board)│
+    │                               │
+    │ • Load company context        │
+    │ • Initialize Groq client      │
+    │ • Prepare prompt templates    │
+    └──────────────┬────────────────┘
+                   │
+    ┌──────────────▼────────────────────────────────┐
+    │ DATA GATHERING & CONTEXT BUILDING             │
+    │                                               │
+    │ _build_context() {                            │
+    │   • Query team_members table                  │
+    │   • Query budget_settings table               │
+    │   • Query project_allocations table           │
+    │   • Calculate derived metrics                 │
+    │   • Identify planned exits                    │
+    │   • Assess component complexity               │
+    │ }                                             │
+    │                                               │
+    │ Output: Rich context document (~500 tokens)   │
+    └──────────────┬────────────────────────────────┘
+                   │
+    ┌──────────────▼────────────────────────────────┐
+    │ PROMPT CONSTRUCTION                           │
+    │                                               │
+    │ Template: "You are an expert consultant..."   │
+    │ + Context: (Company data)                     │
+    │ + Scenario: (User's what-if question)         │
+    │ + Instructions: (Analysis task)               │
+    │ + Format: (JSON structure expected)           │
+    │ + Constraints: (Domain rules)                 │
+    │                                               │
+    │ Output: Complete prompt (~2K tokens)          │
+    └──────────────┬────────────────────────────────┘
+                   │
+    ┌──────────────▼────────────────────────────────┐
+    │ LLM API CALL (Groq)                           │
+    │                                               │
+    │ POST /openai/v1/chat/completions {            │
+    │   model: "llama-3.3-70b-versatile",           │
+    │   messages: [prompts...],                     │
+    │   max_tokens: 2000,                           │
+    │   temperature: 0.7                            │
+    │ }                                             │
+    │                                               │
+    │ Latency: 5-30 seconds typical                │
+    └──────────────┬────────────────────────────────┘
+                   │
+    ┌──────────────▼────────────────────────────────┐
+    │ RESPONSE PARSING                              │
+    │                                               │
+    │ • Extract JSON from response                  │
+    │ • Validate JSON structure                     │
+    │ • Type-check all fields                       │
+    │ • Capture reasoning text                      │
+    │ • Build ScenarioResult object                 │
+    └──────────────┬────────────────────────────────┘
+                   │
+    ┌──────────────▼────────────────────────────────┐
+    │ RESULT STORAGE                                │
+    │                                               │
+    │ st.session_state.scenario_results = {         │
+    │   "scenario_type": "hiring_delay",            │
+    │   "timeline_impact_days": 45,                 │
+    │   "budget_impact_euros": 120000,              │
+    │   "risk_increase_percent": 25,                │
+    │   "recommendation": "RECONSIDER",             │
+    │   "confidence_score": 82,                     │
+    │   ...                                         │
+    │ }                                             │
+    └──────────────┬────────────────────────────────┘
+                   │
+    ┌──────────────▼────────────────────────────────┐
+    │ UI RENDERING                                  │
+    │                                               │
+    │ • Display metrics (4-column layout)           │
+    │ • Show AURORA Reasoning (expandable)          │
+    │ • Generate visualizations                     │
+    │ • Display recommendations                     │
+    │ • Show alternatives                           │
+    │ • Highlight key insights                      │
+    └──────────────────────────────────────────────┘
+```
+
+---
+
+## 3. DATA FLOW DIAGRAM (AURA System)
+
+```
+                    ┌──────────────────┐
+                    │   AURA UI        │
+                    │   (5 Pages)      │
+                    └────────┬─────────┘
+                             │
+        ┌────────────────────┼────────────────────┐
+        │                    │                    │
+   ┌────▼──────┐      ┌─────▼────┐       ┌──────▼──┐
+   │Dashboard  │      │Dashboard │       │ AURORA  │
+   │ Page      │      │ Logic    │       │ Engine  │
+   │           │      │          │       │         │
+   │ (Reads    │      │ Queries  │       │ (Reads) │
+   │  reports)◄──────── repos   ◄────────── Repos
+   │           │      │          │       │ & calls │
+   └───────────┘      └────┬─────┘       │ Groq    │
+                           │              └────┬────┘
+                           │                   │
+      ┌────────────────────┼───────────────────┘
+      │                    │
+      │    ┌───────────────▼─────────────────┐
+      │    │    Repositories                 │
+      │    │                                 │
+      │    │ • team_repository               │
+      │    │ • finance_repository            │
+      │    │ • allocation_repository         │
+      │    │ • settings_repository           │
+      │    │ • session_store                 │
+      │    └──────────────┬──────────────────┘
+      │                   │
+      │    ┌──────────────▼──────────────────┐
+      │    │  SQL Layer                      │
+      │    │                                 │
+      │    │  SELECT * FROM team_members ... │
+      │    │  WHERE ... ORDER BY ...         │
+      │    └──────────────┬──────────────────┘
+      │                   │
+      └───────────────────┼──────────────────┐
+                          │                  │
+                    ┌─────▼────────┐  ┌──────▼──────┐
+                    │ SQLite DB    │  │Groq API     │
+                    │              │  │             │
+                    │ Tables:      │  │ (External)  │
+                    │ • team_m     │  │             │
+                    │ • budget_s   │  │ LLM Model   │
+                    │ • allocat_a  │  │ Reasoning   │
+                    └──────────────┘  └─────────────┘
+```
+
+---
+
+## 4. SCENARIO FLOWCHART (AURORA Analysis Example: Hiring Delay)
+
+```
+START (User selects "Hiring Delay" scenario)
+│
+├─ INPUT COLLECTION
+│  ├─ Component name: "Backend Services"
+│  ├─ Delay duration: "30 days"
+│  ├─ Criticality: "important"
+│  └─ Budget constraint: "€200,000"
+│
+├─ DATA GATHERING
+│  ├─ Query: current team for "Backend Services"
+│  │         Result: 3 people (need 5)
+│  ├─ Query: component details
+│  │         Result: 60-day KT needed
+│  ├─ Query: planned exits in next 12 months
+│  │         Result: 1 person leaving in 6 months
+│  └─ Query: budget settings
+│          Result: avg cost €4,500/person/month
+│
+├─ CONTEXT BUILDING
+│  │
+│  COMPONENT INFO:
+│  ├─ Name: Backend Services
+│  ├─ Criticality: important
+│  ├─ Current staffing: 3/5 (60% capacity)
+│  ├─ Staffing gap: 2 people
+│  ├─ Responsible: Alice Schmidt, Bob Mueller
+│  └─ KT time needed: 60 days
+│  │
+│  TEAM CONTEXT:
+│  ├─ Total team: 15 people
+│  ├─ Exits planned (12 mo): 1 person
+│  ├─ Team capacity: 78% of target
+│  └─ Recent hires: 2 in last 6 months
+│  │
+│  BUSINESS CONTEXT:
+│  ├─ Industry: Siemens
+│  ├─ Avg hiring time: 60-90 days
+│  └─ Strategic importance: high
+│
+├─ PROMPT CONSTRUCTION
+│  │
+│  "You are an expert workforce consultant.
+│   
+│   COMPONENT: Backend Services
+│   - Criticality: important
+│   - Current: 3/5 staffing
+│   - Gap: 2 people needed
+│   - KT: 60 days required
+│   
+│   SCENARIO: Delay hiring by 30 days
+│   
+│   Predict: timeline, budget, risk impacts..."
+│
+├─ GROQ API CALL (llama-3.3-70b-versatile)
+│  │
+│  LLM Reasoning:
+│  "If we delay 30 days:
+│   - Hiring starts day 30 instead of day 0
+│   - Person arrives day 90 (assuming 60 day process)
+│   - KT takes additional 60 days
+│   - Component will run understaffed for 150 days
+│   - Risk: delayed feature delivery, higher burnout
+│   - Budget: saves €9k (1 month salary deferred)
+│   - BUT: risk is high given 1 person leaving soon"
+│
+├─ RESPONSE PARSING
+│  │
+│  LLM Output (JSON):
+│  {
+│    "timeline_impact_days": 45,
+│    "budget_impact_euros": -9000,
+│    "risk_increase_percent": 35,
+│    "recommendation": "RECONSIDER",
+│    "alternatives": [
+│      {
+│        "option": "Hire externally (contractor, faster",
+│        "timeline_impact": 15,
+│        "budget_impact": 20000,
+│        "effectiveness": 90
+│      }
+│    ],
+│    "confidence_score": 78
+│  }
+│
+├─ RESULT STORAGE
+│  └─ st.session_state.scenario_results ← result
+│
+├─ VISUALIZATION GENERATION
+│  ├─ Chart 1: Timeline impact (45 days)
+│  ├─ Chart 2: Budget gauge (-€9k saves)
+│  ├─ Chart 3: Risk gauge (↑35% MEDIUM-HIGH)
+│  └─ Chart 4: Confidence (78% HIGH)
+│
+└─ END (Display results to user)
+```
+
+---
+
+## 5. DATABASE RELATIONSHIP DIAGRAM
+
+```
+┌─────────────────────────────────────────┐
+│       DATABASE RELATIONSHIPS            │
+└─────────────────────────────────────────┘
+
+                team_members
+                ┌─────────────────┐
+                │ id (PK)         │
+                │ name            │────────────┐
+                │ role            │            │
+                │ employee_type   │─┐          │
+                │ components      │ │          │
+                │ start_date      │ │          │
+                │ planned_exit    │ │          │
+                │ dob             │ │          │
+                └─────────────────┘ │          │
+                        ▲            │         │
+                        │            │         │
+                        │ FK         │ FK      │
+                 1:N    │            │          │ Name (1:N)
+                        │           ▼          │
+              ┌─────────────────┐   ┌─────────────────────┐
+              │budget_settings  │   │employee_settings    │
+              ├─────────────────┤   ├─────────────────────┤
+              │employee_type(PK)│   │employee_name (PK)   │
+              │monthly_cost     │   │hourly_rate          │
+              │yearly_budget    │   │weekly_hours         │
+              │hourly_rate      │   └─────────────────────┘
+              │weekly_hours     │
+              └─────────────────┘
+
+                project_allocations
+                ┌─────────────────────────┐
+                │ id (PK)                 │
+                │ employee (FK) ◄─────────┼─── team_members.name
+                │ project                 │
+                │ start_date              │
+                │ end_date                │
+                │ percentage              │
+                └─────────────────────────┘
+
+                app_config
+                ┌─────────────────────────┐
+                │ key (PK)                │
+                │ value_json (JSON)       │
+                └─────────────────────────┘
+```
+
+**Key Relationships:**
+- `team_members.employee_type` → `budget_settings.employee_type` (Many-to-One)
+- `project_allocations.employee` → `team_members.name` (Many-to-One)
+- `employee_settings` keyed by employee name for individual overrides
+
+---
+
+## 6. REQUEST/RESPONSE CYCLE
+
+```
+USER REQUEST CYCLE
+│
+├─ REQUEST (User actions in UI)
+│  ├─ Click button: "Analyze Hiring Delay"
+│  ├─ Select scenario parameters
+│  │  ├─ Component: Backend
+│  │  ├─ Delay: 30 days
+│  │  └─ Criticality: important
+│  │
+│  └─ Streamlit detects change → Full rerun
+│
+├─ PROCESSING (Backend execution)
+│  ├─ script_execution_context set
+│  ├─ session_state retrieved from browser
+│  ├─ Form values combined with stored state
+│  │
+│  ├─ Scenario method called:
+│  │  aurora.simulate_hiring_delay(
+│  │    component="Backend",
+│  │    delay_days=30,
+│  │    ...
+│  │  )
+│  │
+│  ├─ Repositories execute SQL queries
+│  │  ├─ SELECT * FROM team_members
+│  │  ├─ SELECT * FROM budget_settings
+│  │  └─ Results returned as Python dicts
+│  │
+│  ├─ AURORA engine builds context
+│  │  ├─ Format data into text
+│  │  ├─ Create specialized prompt
+│  │  └─ Groq API call
+│  │
+│  ├─ Groq processes request
+│  │  ├─ Tokenize prompt
+│  │  ├─ Run LLM inference (llama-3.3-70b)
+│  │  ├─ Generate response tokens
+│  │  └─ Return as text
+│  │
+│  ├─ Parse response
+│  │  ├─ Extract JSON
+│  │  ├─ Validate structure
+│  │  └─ Return ScenarioResult
+│  │
+│  └─ Store in session state
+│     session_state.scenario_results = result
+│
+├─ RENDERING (UI generation)
+│  ├─ Streamlit calls st.metric() for KPIs
+│  ├─ Visualizations generated from results
+│  │  ├─ Plotly chart functions called
+│  │  └─ Charts rendered as HTML/JSON
+│  │
+│  ├─ Page re-rendered with all widgets
+│  │  ├─ Form fields (with values)
+│  │  ├─ Result metrics
+│  │  ├─ Charts
+│  │  └─ Recommendations
+│  │
+│  └─ HTML sent to browser
+│
+└─ RESPONSE (Browser display)
+   ├─ Receives HTML/JSON/CSS
+   ├─ Renders UI elements
+   ├─ Displays charts via Plotly.js
+   ├─ Streamlit JS handles interactions
+   └─ User sees results
+
+[On user interaction: Restart from REQUEST]
+```
+
+---
+
+## 7. DEPLOYMENT ARCHITECTURE (Current vs Future)
+
+### Current (Prototype)
+
+```
+LOCAL MACHINE (Developer)
+│
+├─ Python 3.12 + venv
+├─ Streamlit (localhost:8501)
+├─ SQLite (local file)
+└─ .env with Groq API key
+│
+└─ streamlit run app.py
+   └─ launches web server
+      └─ user accesses via browser
+```
+
+### Future (Production)
+
+```
+CLOUD PROVIDER (AWS/GCP/Azure)
+│
+├─ Content Delivery Network (CDN)
+│  └─ Static assets (React build, CSS, JS)
+│
+├─ Load Balancer
+│  └─ Distributes traffic
+│
+├─ Kubernetes Cluster (App servers)
+│  ├─ FastAPI container (Python)
+│  ├─ Replica 1
+│  ├─ Replica 2
+│  ├─ Replica 3
+│  └─ Auto-scaling based on CPU/memory
+│
+├─ Managed PostgreSQL Database
+│  ├─ Primary instance
+│  ├─ Replica instance (read-only)
+│  ├─ Automated daily backups
+│  └─ Point-in-time recovery
+│
+├─ Redis Cache Layer
+│  ├─ Session storage
+│  ├─ API response cache
+│  └─ Rate limiting store
+│
+├─ Secrets Management (AWS Secrets Manager)
+│  ├─ Groq API key (encrypted)
+│  ├─ Database credentials
+│  └─ JWT signing keys
+│
+├─ Monitoring & Observability
+│  ├─ Prometheus (metrics)
+│  ├─ Grafana (dashboards)
+│  ├─ ELK Stack (logging)
+│  ├─ Sentry (error tracking)
+│  └─ DataDog (APM)
+│
+├─ S3 Storage (File storage)
+│  ├─ Backups
+│  ├─ Exports
+│  └─ Logs
+│
+└─ CI/CD Pipeline (GitHub Actions)
+   ├─ Run tests
+   ├─ Build container
+   ├─ Push to registry
+   └─ Deploy to Kubernetes
+```
+
+---
+
+## 8. COMPONENT INTERACTION DIAGRAM
+
+```
+┌────────────────────────────────────────────────────────────────┐
+│                      COMPONENT INTERACTIONS                     │
+└────────────────────────────────────────────────────────────────┘
+
+          ┌─────────────────────┐
+          │   Streamlit Pages   │
+          └────────┬────────────┘
+                   │
+        ┌──────────┼──────────────┐
+        │          │              │
+   ┌────▼────┐ ┌──▼────────┐ ┌───▼─────────┐
+   │Dashboard│ │Scenarios  │ │Data Mgmt    │
+   │         │ │           │ │             │
+   │ Calls   │ │ Calls     │ │ Calls       │
+   │Services │ │AURORA     │ │Repository   │
+   └─────────┘ └───────────┘ └─────────────┘
+       │             │              │
+       │             │              │
+       └─────┬───────┴──────┬───────┘
+             │              │
+        ┌────▼────────┐  ┌──▼────────────────┐
+        │  Services   │  │ AURORA Engine     │
+        │             │  │                   │
+        │ • Team      │  │ • scenario_engine │
+        │ • Finance   │  │ • visualization   │
+        │ • Allocat.  │  │ • prompt builder  │
+        │             │  │                   │
+        └────┬────────┘  └──────────┬────────┘
+             │                      │
+        ┌────▼───────────────────┬──▼──┐
+        │ Repositories           │     │
+        │                        │Groq │
+        │ • team_repo            │API  │
+        │ • finance_repo         │     │
+        │ • allocation_repo      │     │
+        └────┬────────────────────┴─────┘
+             │
+        ┌────▼──────────┐
+        │  SQLite DB    │
+        │               │
+        │ • team_mem... │
+        │ • budget_s... │
+        │ • project_a.. │
+        └───────────────┘
+```
+
+---
+
+## 9. STATE MANAGEMENT FLOW
+
+```
+STREAMLIT SESSION STATE LIFECYCLE
+
+1. INITIAL LOAD (Page refresh)
+   ├─ Browser: POST request to Streamlit
+   ├─ Server: Initialize empty session_state
+   ├─ Server: Run script top to bottom
+   ├─ Server: Render HTML
+   ├─ Browser: Display page
+   └─ State in memory for this tab
+
+2. USER INTERACTION (Click button, type in form)
+   ├─ Browser: Detects change
+   ├─ Browser: Sends delta to Streamlit
+   ├─ Server: Receives WebSocket message
+   ├─ Server: Update session_state[key]
+   ├─ Server: Re-run script (full execution)
+   ├─ Server: Find widget states from session
+   ├─ Server: Re-render HTML
+   └─ Browser: Update DOM
+
+3. SCENARIO EXECUTION
+   ├─ Form values extracted: st.session_state
+   ├─ AURORA engine called with form data
+   ├─ Result stored: st.session_state.scenario_results
+   ├─ st.rerun() called (force full re-execution)
+   ├─ Result displayed in UI
+   └─ State persists for navigation
+
+4. NAVIGATION
+   ├─ User clicks sidebar link
+   ├─ URL changes
+   ├─ Page reloads
+   ├─ NEW session_state initialized (!!! State lost)
+   ├─ Script runs from top
+   └─ User sees initial state
+
+5. PAGE REFRESH [BLOCKER]
+   ├─ User hits F5
+   ├─ Browser: Full page reload
+   ├─ Server: session_state garbage collected
+   ├─ Server: NEW session_state initialized
+   ├─ Script: Re-runs from scratch
+   ├─ UI: Reverts to initial state
+   └─ Results lost ❌
+```
+
+---
+
+## 10. AURORA DECISION TREE
+
+```
+                    Scenario Analysis Request
+                            │
+                ┌───────────┬┼┬───────────┐
+                │           ││            │
+         ┌──────▼──────┐    ││      ┌─────▼────────┐
+         │Hiring Delay?│    ││      │Employee Add? │
+         └──────┬──────┘    ││      └──────┬────────┘
+                │YES        ││             │YES
+         ┌──────▼──────────────┐          │
+         │ Query component     │          │
+         │ staffing level      │          │
+         └──────┬──────────────┘          │
+                │                ┌───────────▼────────┐
+                │               │ Assess hiring date │
+                │               │ vs project need    │
+                │               └────────┬───────────┘
+                │                        │
+                │           ┌────────────▼──────────────┐
+                │           │ Calculate timeline       │
+                │           │ + Budget + Risk impact   │
+                │           └────────┬─────────────────┘
+                │                    │
+                │      Recommendation Decision
+                │                    │
+         ┌──────┴───────────┬────────┴────────────────┐
+         │                  │                         │
+    ┌────▼────┐    ┌────────▼────────┐        ┌──────▼──────┐
+    │EXECUTE  │    │ RECONSIDER      │        │HOLD/AVOID   │
+    │         │    │                 │        │             │
+    │Timing   │    │Impact too high  │        │Risk critical│
+    │looks ok │    │or uncertain     │        │ or blocking │
+    └─────────┘    └─────────────────┘        └─────────────┘
+         │                  │                         │
+         │                  │                         │
+         └──────────────────┴─────────────────────────┘
+                         │
+                  ┌──────▼──────┐
+                  │ Present to  │
+                  │ User with   │
+                  │ confidence  │
+                  │ score       │
+                  └─────────────┘
+```
+
+---
+
+**Diagrams Version:** 1.0  
+**Date:** April 1, 2026
+
diff --git a/AURA_PROJECT_ANALYSIS.md b/AURA_PROJECT_ANALYSIS.md
new file mode 100644
index 0000000..73fc335
--- /dev/null
+++ b/AURA_PROJECT_ANALYSIS.md
@@ -0,0 +1,1425 @@
+# 🤖 AURA: Complete Project Analysis & Architecture Document
+
+**Project Name:** AURA (Ressourcenplanner) with AURORA AI Engine  
+**Status:** Prototype/MVP for Business Approval  
+**Technology Stack:** Python, Streamlit, SQLite, Groq LLM, Plotly  
+**Date:** April 1, 2026  
+
+---
+
+## 📋 TABLE OF CONTENTS
+
+1. [Project Overview](#project-overview)
+2. [System Architecture](#system-architecture)
+3. [Component Deep Dive](#component-deep-dive)
+4. [Data Flow Analysis](#data-flow-analysis)
+5. [AURORA Engine Mechanics](#aurora-engine-mechanics)
+6. [Technology Stack](#technology-stack)
+7. [Database Schema](#database-schema)
+8. [Integration Points](#integration-points)
+9. [Prototype Assessment](#prototype-assessment)
+10. [Roadmap to Production](#roadmap-to-production)
+
+---
+
+## PROJECT OVERVIEW
+
+### What is AURA?
+
+**AURA** is a comprehensive workforce resource planning dashboard. **AURORA** is its AI-powered decision engine that answers strategic "what-if" questions using advanced AI reasoning.
+
+### Core Problem Solved
+
+- **Before:** Managers make hiring/allocation decisions with static data and manual analysis (days/weeks)
+- **After:** AURORA provides instant AI-driven insights with multi-dimensional impact assessment (seconds)
+
+### Key Innovation
+
+The AURORA engine (within AURA) combines:
+1. **Real-time LLM reasoning** on company-specific workforce data
+2. **Multi-dimensional impact analysis** (Timeline + Budget + Risk)
+3. **Structured, validated outputs** with confidence scoring
+4. **Domain-specific prompting** for workforce decisions
+
+### Business Value of AURORA Engine
+
+- **Speed:** 5-30 second recommendations vs. 2-week manual analysis
+- **Accuracy:** AI considers 20+ variables humans might miss
+- **Confidence:** Transparency in recommendations with confidence scores
+- **ROI Clarity:** Quantified budget/timeline/risk trade-offs
+
+---
+
+## SYSTEM ARCHITECTURE
+
+### High-Level Architecture Diagram
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│                     PRESENTATION LAYER (Streamlit)              │
+│  ┌───────────────┬─────────────────┬──────┬──────┬──────────┐   │
+│  │ Dashboard     │ Data Management │ Budget│Project│ AURORA  │   │
+│  │ (Executive)   │ (Stammdaten)    │ Mgmt  │Alloca │Scenarios│   │
+│  └───────────────┴─────────────────┴──────┴──────┴──────────┘   │
+└─────────────────────────────────────────────────────────────────┘
+                             △
+                             │ (State/Events)
+┌─────────────────────────────────────────────────────────────────┐
+│                      LOGIC LAYER (Business Logic)               │
+│  ┌──────────────┬──────────┬──────────┬─────────┬────────────┐  │
+│  │ AURORA Engine│Team      │Finance   │Allocation│Visualization│
+│  │(AI Scenarios)│Service   │Service   │Service   │Service      │
+│  └──────────────┴──────────┴──────────┴─────────┴────────────┘  │
+│                                  △                                │
+│                           (Query/Transform)                       │
+└─────────────────────────────────────────────────────────────────┘
+                             △
+                             │ (Data Access)
+┌─────────────────────────────────────────────────────────────────┐
+│                      DATA ACCESS LAYER                          │
+│  ┌──────────┬──────────┬──────────┬─────────┬──────────┐        │
+│  │Team      │Finance   │Allocation│Settings │Session   │        │
+│  │Repository│Repository│Repository│Resources│Store    │        │
+│  └──────────┴──────────┴──────────┴─────────┴──────────┘        │
+│                                  △                                │
+│                            (SQL Queries)                          │
+└─────────────────────────────────────────────────────────────────┘
+                             △
+                             │
+┌─────────────────────────────────────────────────────────────────┐
+│                      PERSISTENCE LAYER                          │
+│          SQLite Database (ressourcenplanner.db)                 │
+│  ┌─────────────────────────────────────────────────────────┐   │
+│  │ Tables: team_members, budget_settings, employee_settings,   │
+│  │ project_allocations, app_config                         │   │
+│  └─────────────────────────────────────────────────────────┘   │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+### External Integration
+
+```
+┌──────────────────────────────────────────────┐
+│        Ressourcenplanner (Python/Streamlit)  │
+│                                              │
+│    ┌──────────────────────────────────────┐  │
+│    │   AURORA Engine                      │  │
+│    │                                      │  │
+│    │  - Scenario Analysis                │  │
+│    │  - Multi-dimensional Impact         │  │
+│    │  - Recommendations                  │  │
+│    └──────────────────────────────────────┘  │
+└────────────────────┬─────────────────────────┘
+                     │
+                     ▼ (HTTP API)
+            ┌────────────────────┐
+            │  Groq Cloud API    │
+            │                    │
+            │ • llama-3.3-70b-   │
+            │   versatile        │
+            │ • Real-time LLM    │
+            │ • Fast inference   │
+            └────────────────────┘
+```
+
+---
+
+## COMPONENT DEEP DIVE
+
+### 1. PRESENTATION LAYER (Streamlit)
+
+**Location:** `app.py` + `pages/`
+
+#### Main Pages (AURA Dashboard)
+
+1. **Executive Dashboard** (`app.py`) - Main AURA page
+   - Strategic overview of workforce
+   - KPIs: team size, tenure, knowledge transfer status
+   - Timeline visualization
+   - Age distribution
+   - Budget summary
+   - Critical alerts
+
+2. **Stammdaten Management** (`pages/Stammdaten_Management.py`)
+   - Add/edit/delete team members
+   - Manage components
+   - Set budget configurations
+   - Configure employee-specific rates
+
+3. **Projekt Allocation** (`pages/Projekt_Allocation.py`)
+   - Assign employees to projects
+   - Visualize allocation timeline
+   - Track capacity utilization
+   - Gantt chart view
+
+4. **Finanzielle Verwaltung** (`pages/Finanzielle_Verwaltung.py`)
+   - Budget tracking and forecasting
+   - Cost analysis by employee type
+   - Monthly budget trends
+   - Year-to-date spending
+
+5. **🤖 AURORA Scenarios** (`pages/Scenario_Analysis.py`) - AURORA AI Engine
+   - Interactive scenario selector
+   - 5 AURORA scenario types
+   - Real-time AURORA analysis
+   - Visualizations with Plotly
+   - Recommendation display
+
+#### Key Features
+
+- **Responsive multi-page navigation** (5 pages)
+- **Real-time session state** management
+- **Interactive forms** with input validation
+- **Plotly visualizations** for insights
+- **German localization** (professional for Siemens)
+- **Theme consistency** across all pages
+
+---
+
+### 2. AURORA ENGINE (AURA's AI Logic Layer)
+
+**Location:** `logic/scenario_engine.py` (AURORA's core brain)
+
+#### Architecture
+
+```python
+class AurorAI:
+    """
+    Main AI engine for workforce scenario analysis
+    """
+    
+    def __init__(self, api_key: str = None):
+        """Initialize Groq API connection"""
+        # Connects to Groq Cloud API
+        # Model: llama-3.3-70b-versatile
+        
+    # PUBLIC SCENARIO METHODS
+    def simulate_hiring_delay()      # Scenario 1: Hiring postponements
+    def simulate_employee_addition() # Scenario 2: New hires
+    def analyze_component_risk()     # Scenario 3: Risk assessment
+    def recommend_hiring_priority()  # Scenario 4: Hiring sequence
+    def predict_kt_success()         # Scenario 5: Knowledge transfer
+    
+    # PRIVATE HELPER METHODS
+    def _build_hiring_context()      # Context builder
+    def _build_employee_context()    # Context builder
+    def _build_risk_context()        # Context builder
+    def _call_claude_scenario()      # LLM API caller
+```
+
+#### Scenario Types
+
+**1. Hiring Delay Simulation**
+```
+Input:
+  - Component name
+  - Delay duration (days)
+  - Current/required staffing
+  - Component criticality
+  - Budget constraints
+
+Output:
+  - Timeline impact (days)
+  - Budget impact (€)
+  - Risk increase (%)
+  - Recommendation (EXECUTE/RECONSIDER/AVOID)
+  - Alternative approaches
+  - Confidence score (0-100%)
+```
+
+**2. Employee Addition Analysis**
+```
+Input:
+  - Employee name & role
+  - Experience level (junior/mid/senior)
+  - Components assigned
+  - Start date
+  - Monthly salary cost
+
+Output:
+  - Timeline improvement (days)
+  - Total cost (€)
+  - Risk reduction (%)
+  - ROI assessment
+  - Knock-on effects
+  - Alternative approaches
+  - Confidence score
+```
+
+**3. Component Risk Analysis**
+```
+Input:
+  - Component name
+  - Staffing levels
+  - Responsible persons
+  - Knowledge transfer status
+
+Output:
+  - Risk score (0-100)
+  - Risk level (CRITICAL/HIGH/MEDIUM/LOW)
+  - Single point of failure flag
+  - Months until critical
+  - Immediate actions needed
+  - Priority hiring roles
+  - Alternatives to hiring
+```
+
+**4. Hiring Priority Recommendations**
+```
+Input:
+  - Available budget (€)
+  - Maximum hires allowed
+  - Current portfolio snapshot
+
+Output:
+  - Recommended hiring sequence
+  - Priority ranking (1st, 2nd, 3rd hire)
+  - Role specifications
+  - Cost per hire
+  - Risk reduction per hire
+  - Timeline impact
+  - Strategic rationale
+```
+
+**5. Knowledge Transfer Prediction**
+```
+Input:
+  - Component name
+  - Departing employee
+  - Replacement candidate
+  - Planned KT duration (weeks)
+
+Output:
+  - Success probability (%)
+  - Risk level
+  - What will be lost
+  - KT plan breakdown (phases)
+  - Budget for KT (€)
+  - Contingency plan
+```
+
+#### ScenarioResult TypedDict
+
+```python
+class ScenarioResult(TypedDict):
+    scenario_type: str                # Type of scenario analyzed
+    timeline_impact_days: int         # Days of delay/improvement
+    budget_impact_euros: float        # Cost impact (€)
+    risk_increase_percent: float      # Risk change (%)
+    recommendation: str               # Structured recommendation
+    reasoning: str                    # LLM reasoning explanation
+    alternatives: list[dict]          # Alternative approaches
+    confidence_score: float           # 0-100% confidence
+```
+
+#### Prompt Engineering Strategy
+
+Each scenario has a specialized prompt that:
+1. **Provides context** about the company
+2. **Specifies the decision** to analyze
+3. **Defines output format** (structured JSON)
+4. **Requests reasoning** for transparency
+5. **Asks for alternatives** for decision support
+6. **Includes constraints** (budget, timeline, risk thresholds)
+
+Example structure:
+```
+You are an expert workforce planning consultant. 
+
+CONTEXT:
+- Current team size
+- Component criticality
+- Industry benchmarks
+- Budget constraints
+
+SCENARIO:
+We delay hiring for [component] by [days]
+
+ANALYSIS REQUEST:
+Estimate timeline impact, budget implications, risk increase
+
+OUTPUT FORMAT:
+{
+  "timeline_impact_days": <int>,
+  "budget_impact_euros": <float>,
+  "risk_increase_percent": <float>,
+  "recommendation": "<EXECUTE|RECONSIDER|AVOID>",
+  ...
+}
+```
+
+---
+
+### 3. VISUALIZATION SERVICE
+
+**Location:** `logic/visualization_service.py`
+
+#### Chart Types (10+)
+
+1. **Timeline Impact Chart** - Bar chart of delay days
+2. **Budget Impact Gauge** - Gauge indicator with color coding
+3. **Risk Gauge Chart** - Risk level visualization (LOW→CRITICAL)
+4. **Confidence Gauge** - AI confidence percentage
+5. **Hiring Priority Chart** - Priority ranking bars
+6. **Hiring Timeline** - Project phase duration chart
+7. **Alternatives Comparison** - Multiple option comparison
+8. **Risk Heatmap** - Component risk overview
+9. **Knowledge Transfer Timeline** - KT phases breakdown
+10. **Budget vs Impact Scatter** - Trade-off analysis
+
+#### Design Principles
+
+- **Interactive** - Hover for details, zoom, pan
+- **Color-coded** - Red/yellow/green for quick assessment
+- **Responsive** - Mobile/desktop compatible
+- **Accessible** - Clear labels and legends
+- **Professional** - Consistent styling across charts
+
+---
+
+### 4. DATA ACCESS LAYER (Repositories)
+
+**Location:** `database/`
+
+Each repository follows the **Repository Pattern** for data isolation:
+
+```
+team_repository.py
+├─ get_all_team_members()
+├─ add_team_member()
+├─ update_team_member()
+└─ delete_team_member()
+
+finance_repository.py
+├─ get_budget_settings()
+├─ update_budget_for_type()
+└─ calculate_total_costs()
+
+allocation_repository.py
+├─ add_project_allocation()
+├─ get_employee_allocations()
+└─ check_capacity_conflicts()
+
+settings_repository.py
+├─ get_employee_rates()
+└─ update_employee_rates()
+
+session_store.py
+├─ ensure_session_state()
+├─ save_team_data()
+└─ load_persisted_state()
+```
+
+#### Advantages
+
+- Isolates database logic from business logic
+- Single responsibility principle
+- Easy to mock for testing
+- Centralized query management
+
+---
+
+### 5. PERSISTENCE LAYER (SQLite Database)
+
+**Location:** `database/ressourcenplanner.db`
+
+#### Schema
+
+```sql
+-- Core Team Data
+CREATE TABLE team_members (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    name TEXT NOT NULL,
+    role TEXT NOT NULL,
+    employee_type TEXT,
+    components TEXT,      -- Comma-separated list
+    start_date TEXT,      -- ISO format
+    planned_exit TEXT,    -- ISO format
+    knowledge_transfer_status TEXT,
+    priority TEXT,        -- High/Medium/Low (derived)
+    dob TEXT,             -- Birth of date
+    team TEXT,
+    manual_override INTEGER DEFAULT 0
+);
+
+-- Budget Configuration
+CREATE TABLE budget_settings (
+    employee_type TEXT PRIMARY KEY,
+    monthly_cost REAL,
+    yearly_budget REAL,
+    hourly_rate REAL,
+    weekly_hours REAL
+);
+
+-- Individual Employee Rates
+CREATE TABLE employee_settings (
+    employee_name TEXT PRIMARY KEY,
+    hourly_rate REAL,
+    weekly_hours REAL
+);
+
+-- Project/Component Allocations
+CREATE TABLE project_allocations (
+    id INTEGER PRIMARY KEY,
+    employee TEXT NOT NULL,
+    project TEXT NOT NULL,
+    start_date TEXT NOT NULL,
+    end_date TEXT NOT NULL,
+    percentage INTEGER DEFAULT 0  -- Allocation %
+);
+
+-- Application Configuration
+CREATE TABLE app_config (
+    key TEXT PRIMARY KEY,
+    value_json TEXT  -- JSON for complex values
+);
+```
+
+#### Key Features
+
+- **Foreign Key Constraints** enabled
+- **Default Values** for sensible defaults
+- **JSON Storage** for complex config
+- **Seed Data** on first run
+- **No Migrations** (prototype simplicity)
+
+---
+
+### 6. BUSINESS LOGIC LAYER (Services)
+
+#### Team Service (`logic/team_service.py`)
+
+Calculates derived values based on employee data:
+
+```python
+def calculate_priority_from_tenure(start_date):
+    """Derive priority based on years employed"""
+    < 6 months  → High priority (new, less stable)
+    6-24 months → Medium priority
+    > 24 months → Low priority
+
+def calculate_kt_status_from_tenure(start_date):
+    """Derive KT status based on tenure"""
+    < 6 months  → Not Started (still learning)
+    6-24 months → In Progress (ongoing knowledge building)
+    > 24 months → Completed (knowledge established)
+
+def build_team_dataframe(team_data):
+    """Create normalized DataFrame with calculated fields"""
+    - Converts dates to datetime
+    - Calculates age
+    - Calculates days until exit
+    - Calculates tenure days
+    - Returns clean, typed data
+```
+
+#### Finance Service (`logic/finance_service.py`)
+
+Calculates financial metrics:
+
+```python
+def calculate_employee_cost(employee):
+    """Total employment cost (salary, benefits, overhead)"""
+    
+def forecast_budget(team_data, months_ahead):
+    """Project budget needs for next N months"""
+    
+def calculate_component_cost(component_name):
+    """Cost of staffing a component"""
+```
+
+#### Allocation Service (`logic/allocation_service.py`)
+
+Manages project assignments:
+
+```python
+def assign_employee_to_project(employee, project, %, dates):
+    """Allocate employee capacity to project"""
+    
+def check_overallocation(employee, new_allocation):
+    """Verify employee isn't allocated > 100%"""
+    
+def get_utilization_report(date_range):
+    """Show capacity vs allocation"""
+```
+
+---
+
+## DATA FLOW ANALYSIS
+
+### Scenario Execution Flow
+
+```
+USER INTERACTION (Streamlit UI)
+│
+├─ User selects scenario type
+│  └─ e.g., "Hiring Delay for Component X"
+│
+├─ User enters parameters
+│  ├─ Component name
+│  ├─ Delay duration (days)
+│  ├─ Criticality level
+│  └─ Budget constraints
+│
+├─ [Click "Simulate Impact" button]
+│  │
+│  └─ AURORA ENGINE INVOCATION
+│
+├─ Data gathering from database
+│  ├─ Get team_members data via team_repository
+│  ├─ Get component details
+│  ├─ Get budget_settings via finance_repository
+│  └─ Normalize into DataFrames
+│
+├─ Context building
+│  ├─ Calculate staffing gaps
+│  ├─ Identify planned exits
+│  ├─ Assess component complexity
+│  └─ Build specialized prompt
+│
+├─ Groq API Call (LLM Inference)
+│  ├─ Send prompt with context to Groq
+│  ├─ Model: llama-3.3-70b-versatile
+│  ├─ Max tokens: 2000
+│  └─ Wait for response (5-30 seconds)
+│
+├─ Response parsing
+│  ├─ Extract JSON from LLM output
+│  ├─ Validate structure
+│  ├─ Type-check all fields
+│  └─ Return ScenarioResult object
+│
+├─ Store in session state
+│  └─ st.session_state.scenario_results ← result
+│
+├─ Visualization generation (Optional)
+│  ├─ Create timeline impact chart
+│  ├─ Create budget gauge chart
+│  ├─ Create risk gauge chart
+│  ├─ Create confidence gauge
+│  ├─ Create alternatives comparison
+│  └─ All powered by Plotly
+│
+└─ UI Rendering
+   ├─ Display metrics (4 columns)
+   ├─ Display AURORA Reasoning (expandable)
+   ├─ Display visualizations (2x2 grid)
+   ├─ Display recommendation (color-coded)
+   ├─ Display alternatives (expandable list)
+   └─ User can export as screenshot
+```
+
+### State Management Flow
+
+```
+Streamlit Session State (In-Memory, Per Browser Tab)
+│
+├─ scenario_results
+│  └─ Latest scenario output from AURORA
+│
+├─ team_data
+│  └─ Current team roster
+│
+├─ components_data
+│  └─ Component definitions
+│
+├─ budget_data
+│  └─ Budget configuration
+│
+├─ groq_api_key (optional)
+│  └─ User-entered API key (overrides .env)
+│
+└─ Various UI state flags
+   └─ Form values, expanded sections, etc.
+
+[On page refresh] → State lost (BLOCKER for production)
+[After POST-APPROVAL] → Use React + persistent backend state
+```
+
+---
+
+## AURORA ENGINE MECHANICS
+
+### Deep Dive: How the AI Works
+
+#### 1. Context Building
+
+Before asking the LLM, AURORA builds rich context:
+
+```python
+def _build_hiring_context(component_name, ...):
+    """Prepare context snapshot for LLM"""
+    
+    COMPONENT INFORMATION:
+    - Name, criticality, staffing gaps
+    - Knowledge transfer requirements
+    - Responsible persons & their tenure
+    
+    TEAM CONTEXT:
+    - Total team size
+    - Planned exits in next 12 months
+    - Current capacity vs target
+    
+    BUSINESS CONTEXT:
+    - Industry: Siemens
+    - Average hiring timeline: 60-90 days
+    - Strategic importance
+    
+    [Result: ~500 tokens of context]
+```
+
+#### 2. Prompt Structure
+
+```
+You are an expert workforce planning consultant.
+
+CONTEXT:
+[~500 tokens of company data]
+
+SCENARIO:
+"We delay hiring for Component X by 30 days"
+
+ANALYSIS TASK:
+Predict: timeline, budget, risk impacts
+
+OUTPUT FORMAT:
+{
+  "timeline_impact_days": <int>,
+  "budget_impact_euros": <float>,
+  "risk_increase_percent": <float>,
+  "recommendation": "<EXECUTE|RECONSIDER|AVOID>",
+  "reasoning": "<2-3 sentences>",
+  "alternatives": [
+    {
+      "option": "<string>",
+      "timeline_impact": <int>,
+      "budget_impact": <float>,
+      "effectiveness": <0-100>
+    }
+  ],
+  "confidence_score": <0-100>
+}
+
+CONSTRAINTS:
+- Be specific with numbers
+- Consider industry benchmarks
+- Think through risk cascades
+- Provide realistic alternatives
+```
+
+#### 3. API Invocation
+
+```python
+response = self.client.chat.completions.create(
+    model="llama-3.3-70b-versatile",
+    max_tokens=2000,
+    messages=[
+        {"role": "user", "content": prompt}
+    ]
+)
+
+response_text = response.choices[0].message.content
+```
+
+**Technical Details:**
+- **Model:** Llama 3.3 70B Versatile (optimized for reasoning)
+- **API:** Groq Cloud (fast inference, cheap)
+- **Latency:** 5-30 seconds typical
+- **Tolerance:** Handles ~2KB of context + reasoning
+
+#### 4. Response Parsing
+
+```python
+# Extract JSON from response
+json_start = response_text.find("{")
+json_end = response_text.rfind("}") + 1
+
+if json_start == -1:
+    raise ValueError("No JSON in response")
+
+json_str = response_text[json_start:json_end]
+result = json.loads(json_str)
+
+# Build ScenarioResult
+return {
+    "scenario_type": scenario_type,
+    "timeline_impact_days": result.get("timeline_impact_days", 0),
+    "budget_impact_euros": result.get("budget_impact_euros", 0),
+    ...
+    "reasoning": response_text[:json_start].strip()
+}
+```
+
+**Error Handling:**
+- Retries on JSON parse errors
+- Returns error object on API failure
+- Never crashes - degradation handled
+
+#### 5. Confidence Scoring
+
+AURORA includes a confidence score (0-100%):
+
+```
+100% = All information is clear, precedent exists
+ 80% = Good data, minor uncertainties
+ 60% = Some data gaps, reasonable estimates
+ 40% = Limited data, significant assumptions
+ 20% = Sparse data, highly speculative
+```
+
+**How it's evaluated:**
+- Data completeness
+- Historical precedent
+- Complexity of scenario
+- Uncertainty in inputs
+
+---
+
+## TECHNOLOGY STACK
+
+### Frontend
+
+| Technology | Purpose | Version |
+|------------|---------|---------|
+| **Streamlit** | Web UI framework | 1.28.1 |
+| **Plotly** | Interactive charts | 5.17.0 |
+| **Pandas** | Data manipulation | 2.1.3 |
+| **NumPy** | Numerical computing | 1.24.3 |
+
+### Backend
+
+| Technology | Purpose | Version |
+|------------|---------|---------|
+| **Python** | Core language | 3.12 |
+| **SQLite** | Database | Built-in |
+| **python-dotenv** | Config management | 1.0.0 |
+
+### External APIs
+
+| Service | Purpose | Tier |
+|---------|---------|------|
+| **Groq AI** | LLM inference | Free (generous limits) |
+| **Llama 3.3 70B** | Reasoning model | Via Groq |
+
+### Development
+
+| Tool | Purpose |
+|------|---------|
+| Git | Version control |
+| GitHub | Repository host |
+| Visual Studio Code | IDE |
+| Python virtual environment | Isolation |
+
+---
+
+## DATABASE SCHEMA
+
+### Detailed Schema Analysis
+
+#### team_members Table
+
+```sql
+CREATE TABLE team_members (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    display_order INTEGER NOT NULL DEFAULT 0,    -- Sort order in UI
+    name TEXT NOT NULL,                           -- Full name
+    role TEXT NOT NULL,                           -- Job title
+    employee_type TEXT NOT NULL,                  -- Staff type (LCE, external, etc.)
+    components TEXT,                              -- Comma-separated component list
+    start_date TEXT,                              -- ISO 8601 date (YYYY-MM-DD)
+    planned_exit TEXT,                            -- Exit date or NULL if indefinite
+    knowledge_transfer_status TEXT,               -- Not Started|In Progress|Completed
+    priority TEXT,                                -- High|Medium|Low (computed)
+    dob TEXT,                                     -- Birth date (ISO format)
+    team TEXT,                                    -- Team assignment
+    manual_override INTEGER NOT NULL DEFAULT 0    -- Flag: user manually set priority?
+);
+```
+
+**Relationships:**
+- `name` ← Foreign key to `employee_settings` (1:1)
+- `employee_type` → `budget_settings` (Many:1)
+- Component assignments are comma-delimited (denormalized for simplicity)
+
+#### Sample Data
+
+```
+id | name           | role         | start_date | planned_exit | components
+1  | Alice Schmidt  | Tech Lead    | 2024-01-15 | 2028-12-31   | Backend,API
+2  | Bob Mueller    | Developer    | 2023-06-01 | NULL         | Frontend,Tests
+3  | Carol Weber    | Architect    | 2022-03-20 | 2026-06-30   | Backend,Database
+```
+
+#### budget_settings Table
+
+```sql
+CREATE TABLE budget_settings (
+    employee_type TEXT PRIMARY KEY,               -- e.g., "LCE", "Contractor"
+    monthly_cost REAL NOT NULL DEFAULT 0,        -- Average monthly salary
+    yearly_budget REAL NOT NULL DEFAULT 0,       -- Annual budget allocation
+    hourly_rate REAL NOT NULL DEFAULT 0,         -- For contractors
+    weekly_hours REAL NOT NULL DEFAULT 0         -- Billable hours/week
+);
+```
+
+#### project_allocations Table
+
+```sql
+CREATE TABLE project_allocations (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    employee TEXT NOT NULL,        -- References team_members.name
+    project TEXT NOT NULL,         -- Project name
+    start_date TEXT NOT NULL,      -- ISO date
+    end_date TEXT NOT NULL,        -- ISO date
+    percentage INTEGER NOT NULL DEFAULT 0  -- Allocation percentage (0-100)
+);
+```
+
+**Multi-project allocation support:**
+- One employee can work multiple projects
+- Can be 1-100% on each
+- Query: "Is employee over 100% allocated?" checks sum of percentages
+
+---
+
+## INTEGRATION POINTS
+
+### Data Flow Diagram
+
+```
+┌─────────────────────────────────────────┐
+│     Streamlit UI (5 Pages)              │
+│                                         │
+│  ┌─────────────────────────────────┐   │
+│  │ Executive Dashboard             │   │
+│  │ ├─ Team overview                │   │
+│  │ ├─ KPIs                         │   │
+│  │ └─ Alerts                       │   │
+│  └──────────────────┬──────────────┘   │
+│                     │                   │
+│  ┌─────────────────────────────────┐   │
+│  │ Stammdaten Management           │   │
+│  │ ├─ Add/edit employees           │   │
+│  │ ├─ Manage components            │   │
+│  │ └─ Set budgets                  │   │
+│  └──────────────────┬──────────────┘   │
+│                     │                   │
+│  ┌─────────────────────────────────┐   │
+│  │ AURORA Scenario Analysis        │   │
+│  │ ├─ Hiring delay                 │   │
+│  │ ├─ Employee addition            │   ◄──── Main Innovation
+│  │ ├─ Risk analysis                │   │
+│  │ ├─ Hiring priority              │   │
+│  │ └─ KT prediction                │   │
+│  └──────────────────┬──────────────┘   │
+│                     │                   │
+└─────────────────────┼───────────────────┘
+                      │
+         ┌────────────┴────────────┐
+         │                         │
+    ┌────▼────────────┐     ┌──────▼──────────────┐
+    │  Repositories   │     │  Services           │
+    │                 │     │                     │
+    │ ┌─────────────┐ │     │ ┌────────────────┐  │
+    │ │team_repo    │ │     │ │team_service    │  │
+    │ ├─────────────┤ │     │ ├────────────────┤  │
+    │ │finance_repo │ │     │ │finance_service │  │
+    │ ├─────────────┤ │     │ ├────────────────┤  │
+    │ │allocation_r │ │     │ │allocation_serv │  │
+    │ └─────────────┘ │     │ └────────────────┘  │
+    └────────┬────────┘     └──────┬──────────────┘
+             │                     │
+             │                ┌────▼──────────────────┐
+             │                │  AURORA Engine       │
+             │                │                      │
+             │                │ ┌──────────────────┐ │
+             │                │ │Scenario types    │ │
+             │                │ │(5 types)         │ │
+             │                │ └────────┬─────────┘ │
+             │                │          │           │
+             │                │   ┌──────▼────────┐  │
+             │                │   │ Groq LLM API  │  │
+             │                │   └───────────────┘  │
+             │                │                      │
+             │                │ ┌──────────────────┐ │
+             │                │ │Visualization    │ │
+             │                │ │Service          │ │
+             │                │ └──────────────────┘ │
+             │                └──────────────────────┘
+             │
+      ┌──────▼────────────────┐
+      │   SQLite Database     │
+      │                       │
+      │  • team_members       │
+      │  • budget_settings    │
+      │  • allocations        │
+      │  • app_config         │
+      └───────────────────────┘
+```
+
+### Key Integration Points
+
+1. **Streamlit ↔ Repositories**
+   - All table access via repositories
+   - Single point of data modification
+   - Isolation of SQL logic
+
+2. **Repositories ↔ SQLite**
+   - Raw SQL queries
+   - Transactions for consistency
+   - Connection pooling (simple: 1 connection per request)
+
+3. **UI ↔ AURORA Engine**
+   - User selects scenario type
+   - AURORA queries data via repositories
+   - Returns ScenarioResult
+   - Visualizations generated from result
+
+4. **AURORA ↔ Groq API**
+   - HTTP REST API
+   - Environment variable for API key
+   - 5-30 second latency
+   - Rate limits enforced by Groq
+
+5. **Session State**
+   - Streamlit session holds all UI state
+   - Survives page navigation
+   - Lost on refresh (prototype limitation)
+
+---
+
+## PROTOTYPE ASSESSMENT
+
+### What Works Well ✅
+
+| Aspect | Rating | Notes |
+|--------|--------|-------|
+| **AURORA Engine** | 9/10 | Clever AI reasoning, well-designed |
+| **MVP Features** | 9/10 | All core scenarios implemented |
+| **Code Organization** | 8/10 | Good separation of concerns |
+| **User Experience** | 7/10 | Streamlit provides good baseline |
+| **Data Model** | 8/10 | Clean schema, appropriate normalization |
+| **Visualization** | 8/10 | Plotly charts are professional |
+| **Rapid Development** | 10/10 | Built fast with right tools for prototype |
+
+### Limitations for Production ⚠️
+
+| Issue | Impact | Mitigation (Post-Approval) |
+|-------|--------|---------------------------|
+| **Streamlit Reruns** | Poor UX on heavy data | Migrate to React |
+| **SQLite Scaling** | Max 50-100 concurrent users | Upgrade to PostgreSQL |
+| **No Tests** | Risk of regressions | Add 70%+ test coverage |
+| **Session State Loss** | Frustrating on refresh | Use persistent backend store |
+| **No RBAC** | Can't restrict access | Implement role-based control |
+| **Minimal Logging** | Hard to debug production issues | Add structured logging + Sentry |
+| **No API Rate Limiting** | Can burn Groq budget | Add rate limiting wrapper |
+
+### Innovation Summary 🚀
+
+**What's genuinely novel:**
+
+1. **Real-time LLM reasoning on company data** (5-30 sec vs 2-week manual)
+2. **Multi-dimensional impact assessment** (Time + Budget + Risk in one query)
+3. **Structured, validated AI output** (not just chatbot text)
+4. **Domain-specific prompt engineering** (workforce-optimized, not generic)
+5. **Confidence scoring** (transparency in recommendations)
+
+**Competitive positioning:**
+- 6-12 month head start vs competitors
+- First-mover advantage in LLM-driven HR
+- Defensible via trade secrets (prompting methodology)
+- Lower cost than enterprise HR platforms
+
+---
+
+## ROADMAP TO PRODUCTION
+
+### Phase 1: Stabilization (Weeks 1-4) — Before Approval
+
+**Goals:**
+- Fix critical bugs
+- Prepare for board presentation
+- Validate business case
+
+**Tasks:**
+- [ ] Write comprehensive README
+- [ ] Create demo scenarios (pre-populated data)
+- [ ] Test all 5 scenario types
+- [ ] Fix any visualization glitches
+- [ ] Prepare presentation materials
+
+**Deliverables:**
+- Approval document
+- Demo script
+- Screenshots for slides
+
+---
+
+### Phase 2: Foundation Hardening (Weeks 5-8) — After Approval
+
+**Goals:**
+- Prepare for user testing
+- Fix critical blockers
+- Add basic safety measures
+
+**Tasks:**
+- [ ] Add input validation (Pydantic)
+- [ ] Improve Groq error handling (retries, timeouts)
+- [ ] Implement API rate limiting (rate limiter middleware)
+- [ ] Add structured logging (Python logging module)
+- [ ] Write integration tests for AURORA scenarios
+- [ ] Set up GitHub Actions CI/CD
+- [ ] Add basic monitoring (error tracking with Sentry)
+
+**Technologies:**
+- Pydantic for validation
+- Python logging + Sentry
+- GitHub Actions for CI/CD
+- pytest for testing
+
+---
+
+### Phase 3: React Migration (Weeks 9-16) — Big Replatform
+
+**Goals:**
+- Replace Streamlit with production-grade frontend
+- Improve UX dramatically
+- Enable real-time updates
+
+**Architecture:**
+
+```
+Frontend (React/TypeScript)          Backend (FastAPI)
+├─ Dashboard page      ◄─────────────┐ GET /dashboard
+├─ Data management     ◄─────────────┐ GET/POST /team
+├─ Budget tracking     ◄─────────────┐ GET /budget
+├─ Project allocation  ◄─────────────┐ GET/POST /allocations
+└─ AURORA scenarios    ◄─────────────┐ POST /scenarios/analyze
+                                      │
+                            ┌─────────┴──────┐
+                            │                │
+                      Existing Python Logic │
+                      (No changes needed!)  │
+                      ├─ scenario_engine.py │
+                      ├─ Repositories       │
+                      └─ Services           │
+```
+
+**Tasks:**
+- Build React frontend (TypeScript)
+- Build FastAPI backend (Python)
+- Migrate data access to REST API
+- Wire up authentication
+- Switch from SQLite to PostgreSQL
+
+**Reusable Components:**
+- All business logic (scenario_engine, repositories, services) stays the same
+- Only presentation layer changes
+- Database layer upgraded
+
+---
+
+### Phase 4: Enterprise Features (Weeks 17-24) — After MVP Launch
+
+**Goals:**
+- Support multi-user scenarios
+- Add compliance/audit features
+- Integrate with SAP/HR systems
+
+**Tasks:**
+- [ ] Implement RBAC (Admin/Manager/Viewer)
+- [ ] Add audit logging (who changed what, when)
+- [ ] Implement multi-tenancy (multiple companies)
+- [ ] Add data export (PDF, Excel, CSV)
+- [ ] Implement scenario comparison
+- [ ] Add historical tracking
+- [ ] Create admin dashboard
+- [ ] Set up encryption at rest
+
+**Technologies:**
+- JWT for authentication
+- Audit table in database
+- S3 for exports storage
+- Kubernetes for deployment
+
+---
+
+### Phase 5: Advanced Analytics (Weeks 25+) — Ongoing
+
+**Tasks:**
+- [ ] Track prediction accuracy
+- [ ] Fine-tune AURORA prompts based on feedback
+- [ ] Add predictive alerts
+- [ ] Machine learning on historical decisions
+- [ ] Mobile app (React Native)
+- [ ] Slack/Teams integration
+- [ ] Advanced forecasting
+
+---
+
+## DEPLOYMENT ARCHITECTURE
+
+### For Prototype (Current)
+
+```
+Developer Laptop (Dev Container)
+├─ Python 3.12 + venv
+├─ Streamlit app
+├─ SQLite database (local file)
+└─ .env file with Groq API key
+
+On Demand:
+streamlit run app.py
+→ Launches on localhost:8501
+```
+
+### For Production (Post-Approval)
+
+```
+Cloud Deployment (AWS/GCP/Azure)
+│
+├─ Load Balancer
+│  └─ Routes traffic to app instances
+│
+├─ React Frontend (CDN + S3)
+│  ├─ TypeScript components
+│  ├─ State management (Redux)
+│  └─ Cached static assets
+│
+├─ FastAPI Backend (Kubernetes)
+│  ├─ Multiple replicas
+│  ├─ Auto-scaling
+│  └─ Health checks
+│
+├─ PostgreSQL Database (Managed)
+│  ├─ Primary + replica
+│  ├─ Automated backups
+│  └─ Point-in-time recovery
+│
+├─ Redis Cache
+│  ├─ Session state
+│  ├─ API response caching
+│  └─ Rate limiting
+│
+├─ Monitoring Stack
+│  ├─ Prometheus metrics
+│  ├─ Grafana dashboards
+│  ├─ Sentry error tracking
+│  └─ ELK stack (logging)
+│
+└─ Backup & DR
+   ├─ Daily database snapshots
+   ├─ Cross-region replication
+   └─ Disaster recovery plan
+```
+
+---
+
+## TESTING STRATEGY
+
+### Current State (Prototype)
+
+```
+Unit Tests: 0%
+Integration Tests: 0%
+E2E Tests: 0%
+Coverage: 0%
+
+Validation: Manual QA only
+```
+
+### Post-Approval Plan
+
+```
+Phase 1 (Weeks 5-8):
+├─ Unit tests for AURORA scenarios
+├─ Unit tests for services
+├─ Unit tests for data access
+└─ Target: 60% coverage
+
+Phase 2 (Weeks 9-16):
+├─ Integration tests (UI + API + DB)
+├─ E2E tests for critical paths
+├─ Performance tests
+└─ Target: 80% coverage
+
+Ongoing:
+├─ Regression testing
+├─ Load testing
+├─ Security testing
+└─ User acceptance testing
+```
+
+### Test Pyramid
+
+```
+            /\
+           /  \  E2E Tests (UI + Full Stack)
+          /────\ ~10% of tests
+         /      \
+        /────────\
+       /  Service \  Integration Tests
+      /    Tests   \ ~30% of tests
+     /──────────────\
+    /                \  Unit Tests (AURORA, Services)
+   /    Unit Tests    \ ~60% of tests
+  /____________________\
+```
+
+---
+
+## SECURITY CONSIDERATIONS
+
+### Current Prototype
+
+```
+API Key Management:
+✅ Stored in .env file
+✅ Added to .gitignore
+✅ Not exposed in code
+⚠️  No vault/secrets manager
+
+Data Protection:
+⚠️  SQLite (no encryption at rest)
+⚠️  No database-level access control
+⚠️  No audit logging
+
+Authentication:
+⚠️  No user authentication (prototype)
+⚠️  No access control (anyone with URL can use)
+⚠️  No session management beyond Streamlit
+
+API Security:
+⚠️  No rate limiting
+⚠️  No request validation beyond Streamlit
+⚠️  No API key rotation strategy
+```
+
+### Post-Approval Security Hardening
+
+**Week 1-2:**
+- [ ] Move API key to AWS Secrets Manager
+- [ ] Add input validation (Pydantic)
+- [ ] Implement rate limiting (3 requests/min/user)
+- [ ] Add request logging
+
+**Week 3-4:**
+- [ ] Add JWT authentication
+- [ ] Implement RBAC (role-based access)
+- [ ] Enable database encryption
+- [ ] Add audit logging table
+
+**Week 5-8:**
+- [ ] Implement TLS/SSL
+- [ ] Add CORS policy
+- [ ] Implement API key rotation
+- [ ] Security audit by third party
+
+---
+
+## COST ANALYSIS
+
+### Current Running Costs (Prototype)
+
+| Component | Cost (Monthly) | Notes |
+|-----------|------|-------|
+| **Groq API** | $0 | Free tier (generous limits) |
+| **Development** | $0 | Personal project |
+| **Hosting** | $0 | Local or free Streamlit Cloud |
+| **Storage** | $0 | SQLite (local file) |
+| **Database** | $0 | SQLite (no service) |
+| **Total** | **$0** | Zero-cost prototype |
+
+### Estimated Production Costs (After Approval)
+
+| Component | Cost (Monthly) | Notes |
+|-----------|---|---|
+| **Groq API** | $500-2,000 | Based on usage (10K-50K scenarios/month) |
+| **Cloud Hosting** (AWS) | $2,000-5,000 | Kubernetes, load balancer, CDN |
+| **PostgreSQL Database** | $500-2,000 | Managed AWS RDS, daily backups |
+| **Redis Cache** | $100-300 | Session management, rate limiting |
+| **Monitoring (Datadog/New Relic)** | $500-1,000 | APM + log aggregation |
+| **Security (Vault, WAF)** | $200-500 | HashiCorp Vault, URL WAF |
+| **Backups & Disaster Recovery** | $300-500 | Cross-region replication |
+| **DevOps/SRE** | $8,000-12,000 | Team salary (0.25 FTE) |
+| **Total** | **~$12,000-23,000/month** | Per 100 concurrent users |
+
+**ROI Calculation:**
+- Assumes 30 min/decision = 2 decisions/day
+- 200 employees = 400 decisions/month
+- 30 min × 400 = 200 labor hours saved/month
+- @ $150/hr = $30,000 value/month
+- **Payback period: < 1 month**
+
+---
+
+## CONCLUSION
+
+### Summary
+
+AURORA is a **genuinely innovative prototype** that combines:
+- Real-time LLM reasoning
+- Company-specific workforce data
+- Multi-dimensional impact analysis
+- Structured, transparent recommendations
+
+### Strengths
+
+✅ Novel approach to workforce decision-making  
+✅ Clean code architecture (easy to scale)  
+✅ Fast development cycle (prototype in weeks)  
+✅ Strong business case (clear ROI)  
+✅ Reusable logic layer (no rewrite needed post-approval)  
+
+### Limitations
+
+⚠️ Streamlit foundation (limits user experience)  
+⚠️ SQLite scalability (max ~100 concurrent users)  
+⚠️ No production hardening (testing, monitoring, security)  
+⚠️ Session state loss on refresh (prototype trade-off)  
+
+### Next Steps
+
+**For Approval Meeting (This Week):**
+1. Create 5-minute demo with prepared data
+2. Show 3 compelling scenarios (good decisions + bad ones)
+3. Present ROI calculation
+4. Clarify: this is prototype, production needs 3-4 months
+
+**After Approval (Next Month):**
+1. Stabilize and harden (input validation, error handling)
+2. Write tests and documentation
+3. Begin React migration planning
+
+**Then Scale (Months 2-6):**
+1. Build React frontend
+2. Migrate to PostgreSQL
+3. Implement enterprise features
+4. Launch to production
+
+---
+
+## APPENDIX: TECHNOLOGY GLOSSARY
+
+| Term | Definition | In AURORA |
+|------|-----------|-----------|
+| **LLM** | Large Language Model | Llama 3.3 70B via Groq |
+| **Groq** | Fast inference platform | API for AURORA scenarios |
+| **Streamlit** | Python web framework | UI layer |
+| **Repository Pattern** | Data access abstraction | Team/Finance/Allocation repos |
+| **Scenario** | "What-if" analysis | 5 strategic questions |
+| **Prompt Engineering** | Crafting LLM instructions | AURORA's prompts |
+| **Session State** | In-memory per-user data | Streamlit session_state |
+| **ScenarioResult** | Structured output type | AURORA's answer format |
+| **TypedDict** | Python type hint for dicts | Ensures data structure |
+| **Confidence Score** | 0-100% trust in result | AURORA's transparency metric |
+
+---
+
+**Document Version:** 1.0  
+**Date:** April 1, 2026  
+**Author:** AURORA Development Team  
+**Status:** Approved for presentation
+
+---
+
diff --git a/CODE_REVIEW.md b/CODE_REVIEW.md
new file mode 100644
index 0000000..dd537f9
--- /dev/null
+++ b/CODE_REVIEW.md
@@ -0,0 +1,771 @@
+# 📊 RESSOURCENPLANNER - COMPREHENSIVE CODE REVIEW
+
+**Review Date:** April 2026  
+**Branch:** main  
+**Status:** Prototype → Production-Ready with improvements
+
+---
+
+## 🎯 PROJECT RATING & SUMMARY
+
+### Overall Rating: **7.2/10** ⭐⭐⭐⭐⭐⭐⭐
+
+| Category | Score | Notes |
+|----------|-------|-------|
+| **Architecture** | 7.5 | Clean 3-layer separation, but needs refinement |
+| **Code Quality** | 6.8 | Good practices, but repetition and inconsistencies |
+| **Feature Completeness** | 8.0 | Core features solid, bulk import recently added |
+| **Documentation** | 4.5 | README minimal, no docstrings, comments sparse |
+| **Testing** | 2.0 | **NO TESTS** - Critical gap |
+| **DevOps/Deployment** | 3.0 | No CI/CD, no requirements.txt, no config management |
+| **User Experience** | 8.2 | Good UI/UX, intuitive, German localization |
+| **Performance** | 7.8 | Acceptable for small teams, Gantt chart renders well |
+
+### **Verdict:**
+✅ **Solid prototype with good UX and architecture**  
+⚠️ **Needs testing, documentation, and deployment setup before production**  
+🚀 **High potential for becoming a powerful resource management tool**
+
+---
+
+## 🔴 CRITICAL ISSUES
+
+### 1. **NO TEST COVERAGE** (Critical)
+- **Impact:** High - Zero automated tests means high regression risk
+- **Severity:** 🔴 Critical
+- **Current State:** No test files, no testing framework
+- **Recommendation:**
+  ```
+  MUST ADD:
+  - Unit tests for business logic (allocation_service, finance_service, team_service)
+  - Integration tests for database persistence
+  - UI tests for Streamlit pages
+  - Target: 70%+ coverage
+  ```
+
+### 2. **NO REQUIREMENTS.TXT / DEPENDENCIES MANIFEST** (Critical)
+- **Impact:** High - Cannot reproduce environment or deploy
+- **Severity:** 🔴 Critical
+- **Current State:** .venv exists but no requirements.txt
+- **Recommendation:**
+  ```
+  Create requirements.txt with all dependencies:
+  streamlit>=1.28.0
+  pandas>=2.0.0
+  plotly>=5.0.0
+  numpy>=1.24.0
+  ```
+
+### 3. **NO DEPLOYMENT/CI-CD PIPELINE** (High)
+- **Impact:** High - Manual deployments only, no automated checks
+- **Severity:** 🔴 High
+- **Recommendation:**
+  - Add GitHub Actions for automated testing
+  - Add pre-commit hooks for code quality (flake8, black)
+  - Docker containerization for reproducible deployments
+
+---
+
+## 🟡 CODE DUPLICATION & UNNECESSARY PARTS
+
+### 1. **Page Configuration Boilerplate** (4 instances)
+**Location:** `app.py`, `pages/Projekt_Allocation.py`, `pages/Stammdaten_Management.py`, `pages/Finanzielle_Verwaltung.py`
+
+```python
+# REPEATED in ALL 5 files:
+st.set_page_config(...)
+ensure_session_state()
+load_theme()
+render_sidebar_navigation()
+```
+
+**Action:** Create a helper function `initialize_page()` to eliminate this boilerplate
+
+```python
+# pages/utils.py
+def initialize_page(title: str, icon: str, layout: str = "wide"):
+    """Initialize common page setup (config, state, theme, nav)."""
+    st.set_page_config(
+        page_title=title,
+        page_icon=icon,
+        layout=layout,
+    )
+    ensure_session_state()
+    load_theme()
+    render_sidebar_navigation()
+```
+
+**Result:** Reduces 200 lines of boilerplate, increases consistency
+
+### 2. **Wrapper Functions in app.py** (Unnecessary)
+**Location:** `app.py` lines 43-49, 127-129
+
+```python
+# Unnecessary wrappers in app.py
+def get_colors():
+    return shared_get_colors()
+
+def load_theme():
+    shared_load_theme()
+
+def render_sidebar_navigation() -> None:
+    shared_render_sidebar_navigation()
+```
+
+**Issue:** These are thin wrappers that add no value  
+**Action:** Remove and use imports directly
+
+**Impact:** Removes ~20 lines of dead code
+
+### 3. **Duplicate `parse_component_names()` Function**
+**Location:** `app.py:54` AND `pages/Stammdaten_Management.py:43`
+
+```python
+# DUPLICATE implementation in 2 files
+def parse_component_names(value):
+    if isinstance(value, (list, tuple, set)):
+        raw_items = value
+    else:
+        raw_items = str(value or "").split(",")
+    return [str(item).strip() for item in raw_items if str(item).strip()]
+```
+
+**Action:** Move to `logic/string_utils.py` and import everywhere  
+**Impact:** Single source of truth, easier maintenance
+
+### 4. **Legacy app_legacy.py** (Dead Code)
+**Location:** `archive/app_legacy.py` (1200+ lines)
+
+**Issue:** Old implementation still in repository, unused  
+**Action:** 
+- Remove from repository or put in proper archive folder
+- Clean up `.gitignore` to exclude archive/
+
+**Impact:** Reduces confusion, smaller repo size
+
+### 5. **Redundant Data Synchronization**
+**Location:** `app.py:67-96` - `sync_master_data_to_legacy_state()`
+
+**Issue:** Manually syncing between `products_data` and component maps is error-prone  
+**Better Approach:**
+```python
+# Instead of manual sync, use a single source of truth
+# Store in products_data, derive component_map on demand
+component_map = {
+    comp['component_name']: comp['responsible_persons']
+    for comp in st.session_state.components_data
+}
+```
+
+---
+
+## 🟢 ARCHITECTURE STRENGTHS
+
+### ✅ 1. **Clean 3-Layer Architecture**
+- **Presentation:** `pages/*.py` (Streamlit UI)
+- **Business Logic:** `logic/*.py` (allocation_service, finance_service, team_service)
+- **Persistence:** `database/*.py` (repositories + SQLite)
+- **UI Theme:** `ui/*.py` (centralized styling)
+
+**Status:** Well-organized, follows Django-like pattern ✅
+
+### ✅ 2. **Good Separation of Concerns**
+- Business logic extracted from Streamlit pages
+- Database layer abstracted behind repository pattern
+- Theme/styling centralized
+
+**Example:**
+```python
+# pages/Projekt_Allocation.py imports from business layer
+from logic.allocation_service import check_overallocation
+from database.session_store import ensure_session_state
+```
+
+### ✅ 3. **Database Persistence Layer**
+- SQLite with proper schema
+- Repository pattern for data access
+- Transaction handling
+- Type hints for clarity
+
+### ✅ 4. **Recent Improvements (Last Commits)**
+- ✅ Bulk import feature (CSV/Excel)
+- ✅ Dynamic product/color assignment in Gantt
+- ✅ Default products auto-initialization
+- ✅ Master data management page
+
+---
+
+## 🟠 ARCHITECTURE WEAKNESSES
+
+### ⚠️ 1. **State Management Inconsistency**
+**Problem:** Mix of session state, database persistence, and in-memory state
+
+```python
+# Sometimes saved to DB:
+st.session_state.team_data → save_team_data()
+
+# Sometimes in app_config table as JSON:
+st.session_state.products_data → save_component_state()
+
+# Sometimes transient:
+st.session_state.component_map (derived, not persisted directly)
+```
+
+**Fix:** Create a unified state manager:
+```python
+class AppState:
+    """Single source of truth for app state."""
+    
+    @staticmethod
+    def load_all():
+        return {
+            'team': load_team_members(),
+            'products': load_products(),  # NEW
+            'components': load_components(),  # NEW
+            'allocations': load_project_allocations(),
+            'budget': load_budget_data(),
+        }
+    
+    @staticmethod
+    def save_all(state):
+        save_team_members(state['team'])
+        save_products(state['products'])
+        save_components(state['components'])
+        # ... etc
+```
+
+### ⚠️ 2. **Error Handling is Minimal**
+**Problem:** Few try-catch blocks, no error recovery
+
+```python
+# app.py line 175 - no error handling
+for _, row in df.iterrows():
+    name = str(row.get('name', '')).strip()
+    comps_field = row.get('components', '') or ''
+    comps = [c.strip().lower() for c in str(comps_field).split(',') if c.strip()]
+    
+    try:  # ← This is present but inconsistent elsewhere
+        sd = pd.to_datetime(row['start_date'])
+    except Exception:
+        continue  # ← Silent failure
+    pe = pd.to_datetime(row.get('planned_exit'))  # ← No error handling!
+```
+
+**Fix:** Consistent error handling pattern + logging
+
+### ⚠️ 3. **No Input Validation at Entry Points**
+**Problem:** Streamlit form inputs aren't validated before DB save
+
+```python
+# pages/Stammdaten_Management.py - minimal validation
+if name and role:  # Only checks if truthy
+    st.session_state.team_data.append(...) # Saved without sanitization
+```
+
+**Fix:** Add a validation layer
+```python
+def validate_employee(emp_dict) -> tuple[bool, str]:
+    """Validate employee data with clear error messages."""
+    if not emp_dict.get('name') or len(str(emp_dict['name']).strip()) < 2:
+        return False, "Name must be at least 2 characters"
+    if emp_dict['employee_type'] not in ['Intern', 'Lead Cost Employee (LCE)', 'Extern']:
+        return False, f"Invalid employee type: {emp_dict['employee_type']}"
+    # ... more validations
+    return True, ""
+```
+
+### ⚠️ 4. **Database Schema Lacks Constraints**
+**Problem:** No foreign keys, unique constraints, or data validation in DB
+
+```python
+# database/schema.py - minimal constraints
+CREATE TABLE IF NOT EXISTS team_members (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    name TEXT NOT NULL,  # ← No UNIQUE constraint, duplicates possible
+    role TEXT NOT NULL,
+    # ... missing NOT NULL constraints on important fields
+);
+```
+
+**Fix:** Add proper constraints
+```sql
+CREATE TABLE IF NOT EXISTS team_members (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    name TEXT NOT NULL UNIQUE,  -- Prevent duplicate names
+    role TEXT NOT NULL,
+    start_date TEXT NOT NULL,
+    -- Add CHECK constraints for valid statuses
+    knowledge_transfer_status TEXT NOT NULL DEFAULT 'Not Started'
+        CHECK(knowledge_transfer_status IN ('Not Started', 'In Progress', 'Completed')),
+);
+```
+
+### ⚠️ 5. **No Logging**
+**Problem:** No audit trail, hard to debug issues in production
+
+```python
+# No logging anywhere - makes troubleshooting difficult
+# Add logs with timestamps for:
+# - Data imports
+# - State changes
+# - Errors
+# - User actions
+```
+
+**Fix:** Add Python logging
+```python
+import logging
+
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler('app.log'),
+        logging.StreamHandler()
+    ]
+)
+
+my_logger = logging.getLogger(__name__)
+```
+
+---
+
+## 📋 UNNECESSARY/DEAD CODE TO REMOVE
+
+| File | Lines | Issue | Action |
+|------|-------|-------|--------|
+| `archive/app_legacy.py` | 1200+ | Dead code, old implementation | Remove or archive properly |
+| `app.py:43-49` | 6 | Wrapper functions | Use imports directly |
+| `app.py:127-129` | 3 | Wrapper function | Use imports directly |
+| `pages/Stammdaten_Management.py:43-46` | 4 | Duplicate parse_component_names | Move to logic/ |
+| `app.py:54-60` | 7 | Duplicate parse_component_names | Move to logic/ |
+| `app.py:97-111` | 15 | Redundant sync logic | Simplify with unified state |
+
+**Total Dead Code:** ~50-100 lines of identifiable waste
+
+---
+
+## 🚀 SUGGESTED FEATURES TO REACH NEXT LEVEL
+
+### Tier 1: **CRITICAL** (0-2 weeks)
+These unlock major functionality gaps
+
+#### 1️⃣ **Unit Tests & CI/CD Pipeline**
+```
+Priority: HIGHEST
+Effort: 1-2 weeks
+Impact: Game changer for production readiness
+
+What to test:
+✅ allocation_service: check_overallocation(), validate_allocation_dates()
+✅ finance_service: calculate_employee_cost(), calculate_employee_fte()
+✅ team_service: build_team_dataframe(), calculate_priority_from_tenure()
+✅ Database repos: CRUD operations, persistence
+✅ Streamlit integration: form validation, state management
+
+Tools:
+- pytest (testing framework)
+- pytest-cov (coverage reporting)
+- GitHub Actions (CI/CD)
+```
+
+#### 2️⃣ **Requirements.txt & Deployment Guide**
+```
+Priority: CRITICAL
+Effort: 2 hours
+Impact: Enables reproducible deployments
+
+Content:
+- requirements.txt with pinned versions
+- Dockerfile for containerization
+- docker-compose.yml for local dev
+- Deployment guide (Heroku, Railway, CloudRun options)
+- Environment variable configuration
+```
+
+#### 3️⃣ **User Authentication & Multi-Tenant Support**
+```
+Priority: HIGH (if sharing with others)
+Effort: 1 week
+Impact: Multiple teams can use same instance
+
+Features:
+✅ User login (Google OAuth, email/password)
+✅ Role-based access control (Manager, HR, Employee)
+✅ Team isolation (only see your team's data)
+✅ Audit log (who did what, when)
+
+Implementation:
+- Streamlit-authenticator OR
+- NextAuth.js + FastAPI backend (if moving to React)
+```
+
+---
+
+### Tier 2: **HIGH VALUE** (2-4 weeks)
+These significantly improve usability
+
+#### 4️⃣ **Advanced Reporting & Export**
+```
+Features:
+✅ Custom report builder (select columns, filters, formatting)
+✅ Scheduled reports (weekly digest via email)
+✅ PDF export with charts and summaries
+✅ Power BI / Tableau connector
+✅ API endpoint for external BI tools
+
+Example:
+- Generate "Exit Risk Report" with employee names, roles, 
+  components, recommended KT plans
+- "Capacity Utilization" by product/month
+- "Budget Forecast" next 12 months
+```
+
+#### 5️⃣ **Knowledge Transfer Management**
+```
+Currently: Basic status tracker (Not Started, In Progress, Completed)
+
+New Features:
+✅ KT Plan Templates
+  - Checklist of activities needed
+  - Timeline with milestones
+  - Knowledge artifacts (docs, videos, links)
+
+✅ KT Progress Tracking
+  - Percentage complete calculation
+  - Blockers tracking
+  - Risk assessment
+  
+✅ Notifications
+  - Alert when KT > 60% but person exits < 60 days
+  - Reminders for KT activities due
+
+✅ KT Quality Metrics
+  - "How confident are you in this person's replacement?" (1-10)
+  - Post-exit success rate tracking
+```
+
+#### 6️⃣ **Component Dependency Management**
+```
+Problem: Components don't know their dependencies
+  
+New Features:
+✅ Component graph visualization
+  - Which components depend on which products?
+  - Impact analysis: "If Component X goes down, what breaks?"
+
+✅ Dependency rules
+  - "Component A requires Component B to be active"
+  - Conflict detection: "Both components can't be empty"
+
+✅ Risk scoring
+  - Single point of failure detection
+  - Criticality scores (1-10)
+  
+✅ Scenario analysis
+  - "What if I lose person X? Can I still run all components?"
+```
+
+#### 7️⃣ **Capacity Planning & Forecasting**
+```
+Problem: Only shows current state, no forward-looking
+
+New Features:
+✅ Demand forecast
+  - Project requirements over next 12 months
+  - Planned hiring needs
+  
+✅ Supply forecast
+  - Planned exits
+  - Returnees from projects
+  
+✅ Gap analysis
+  - Months when understaffed by product
+  - Planned vs actual capacity
+  
+✅ What-if scenarios
+  - "What if we hire 2 more devs in Q3?"
+  - "Impact of extending person X's exit date by 3 months"
+  
+Visualization:
+- Forecast chart overlaying historical data
+- Traffic light dashboard (Red/Yellow/Green by period)
+```
+
+#### 8️⃣ **Skill Matrix & Competency Tracking**
+```
+Current: Components assigned, but no skill levels
+
+New Features:
+✅ Skills inventory
+  - Per-employee: Python (Expert), React (Intermediate), etc.
+  - Certification tracking (AWS, Scrum Master, etc.)
+  
+✅ Component skill requirements
+  - "This component needs 2x Python Expert, 1x React Expert"
+  
+✅ Competency gap finder
+  - "Component X needs React Experts - current pool: 0"
+  - Recommended training initiatives
+  
+✅ Career development
+  - Track employee growth
+  - Identify mentorship opportunities
+```
+
+---
+
+### Tier 3: **NICE TO HAVE** (ongoing)
+Polish and optimization
+
+#### 9️⃣ **Mobile App / Responsive Design**
+```
+Current: Web-only via Streamlit
+Issues: Not mobile-friendly
+
+Options:
+✅ Streamlit on mobile (limited, not great UX)
+✅ React Native mobile app (fetches from FastAPI backend)
+✅ Progressive Web App (PWA)
+
+MVP: Responsive dashboard view optimized for tablets/phones
+```
+
+#### 🔟 **Integrations**
+```
+✅ Slack notifications
+  - "Alert: Component X at risk in 30 days"
+  - Weekly summary: "5 critical exits, 2 at-risk components"
+
+✅ Calendar integration
+  - Export exit dates to Outlook/Google Calendar
+  - KT milestones as calendar events
+
+✅ JIRA/Azure DevOps
+  - Link allocations to project management system
+  - Auto-calculate team velocity impact
+
+✅ HR Systems
+  - Import employee data from SAP/Workday
+  - Sync exit dates automatically
+```
+
+#### 1️⃣1️⃣ **Analytics & Insights**
+```
+✅ Historical analysis
+  - "Average KT time by component"
+  - "Exit date prediction accuracy"
+  - "Components with highest turnover"
+
+✅ Predictive analytics
+  - ML model: Predict if person will leave early based on patterns
+  - Attrition risk scoring
+  
+✅ Trend analysis
+  - "Capacity trend over 12 months"
+  - "Component risk trend"
+```
+
+---
+
+## 🎯 CODE QUALITY IMPROVEMENTS
+
+### Quick Wins (Today)
+
+1. **Add Type Hints** (30 mins)
+   ```python
+   # Before
+   def calculate_priority_from_tenure(start_date_str):
+       ...
+   
+   # After
+   def calculate_priority_from_tenure(start_date_str: str) -> str:
+       ...
+   ```
+
+2. **Add Docstrings** (1 hour)
+   ```python
+   def check_overallocation(
+       allocations: list[dict],
+       employee: str,
+       start_month: date,
+       end_month: date,
+       allocation_percentage: int,
+   ) -> tuple[bool, str | None, int]:
+       """
+       Check whether a new allocation would push an employee above 100%.
+       
+       Args:
+           allocations: List of existing allocation dictionaries
+           employee: Employee name
+           start_month: Start of allocation period
+           end_month: End of allocation period
+           allocation_percentage: Percentage being allocated (0-100)
+       
+       Returns:
+           Tuple of (is_overallocated, problem_month, total_allocation)
+       """
+   ```
+
+3. **Extract Page Initialization** (1 hour)
+   ```python
+   # Create pages/common.py
+   def init_page(title: str, icon: str):
+       st.set_page_config(title, icon, layout="wide")
+       ensure_session_state()
+       load_theme()
+       render_sidebar_navigation()
+   ```
+
+4. **Remove Dead Code** (30 mins)
+   - Delete `archive/app_legacy.py`
+   - Remove wrapper functions
+   - Consolidate duplicate functions
+
+### Medium Term (This Sprint)
+
+5. **Add Logging** (2 hours)
+   ```python
+   import logging
+   logger = logging.getLogger(__name__)
+   
+   logger.info(f"Importing {len(df)} employees")
+   logger.error(f"Failed to calculate cost for {emp_name}", exc_info=True)
+   ```
+
+6. **Input Validation Layer** (3-4 hours)
+   ```python
+   # logic/validators.py
+   @validate_employee
+   @validate_allocation
+   @validate_product
+   def validate_all_inputs(data_dict): ...
+   ```
+
+7. **Error Handling** (2-3 hours)
+   - Wrap database operations in try-catch
+   - Display user-friendly error messages
+   - Log stack traces for debugging
+
+8. **Configuration Management** (2 hours)
+   ```python
+   # config.py
+   DATABASE_PATH = os.getenv('DB_PATH', 'database/ressourcenplanner.db')
+   DEBUG = os.getenv('DEBUG', 'False').lower() == 'true'
+   MAX_EMPLOYEES = int(os.getenv('MAX_EMPLOYEES', '500'))
+   ```
+
+---
+
+## 📚 DOCUMENTATION GAPS
+
+### Missing Documentation
+
+| Document | Priority | Purpose |
+|----------|----------|---------|
+| **API Documentation** | HIGH | How to use each business logic function |
+| **Database Schema Docs** | MEDIUM | ER diagram, relationships, constraints |
+| **Deployment Guide** | HIGH | How to deploy to Heroku/Railway/CloudRun |
+| **User Guide** | MEDIUM | Screenshots, workflow walkthroughs |
+| **Architecture Decision Log (ADL)** | MEDIUM | Why we chose SQLite, Streamlit, etc. |
+| **Development Setup** | HIGH | How new devs get started locally |
+| **Testing Guide** | HIGH | How to write and run tests |
+
+**Action:** Create `docs/` folder with detailed guides
+
+---
+
+## 🔧 REFACTORING ROADMAP
+
+### Phase 1: Foundation (Weeks 1-2)
+```
+✅ Add tests + CI/CD
+✅ Create requirements.txt
+✅ Remove dead code
+✅ Add type hints
+✅ Extract page initialization
+```
+
+### Phase 2: Quality (Weeks 3-4)
+```
+✅ Add logging
+✅ Input validation
+✅ Error handling
+✅ Configuration management
+✅ Documentation
+```
+
+### Phase 3: Features (Weeks 5-8)
+```
+✅ Authentication
+✅ Advanced reporting
+✅ KT management
+✅ Capacity forecasting
+✅ Skill matrix
+```
+
+### Phase 4: Polish (Weeks 9+)
+```
+✅ Mobile optimization
+✅ Integrations
+✅ Analytics
+✅ Performance optimization
+```
+
+---
+
+## 📊 QUICK METRICS
+
+```
+Lines of Code (LOC):
+├── Total: ~2,800 lines
+├── Logic: ~500 lines (good ratio!)
+├── Pages: ~1,200 lines
+├── Database: ~400 lines
+└── UI: ~200 lines
+
+Functions: ~40 total
+├── Tested: 0 ❌
+├── Documented: ~5 (12%) ⚠️
+└── Type-hinted: ~20 (50%) 🟡
+
+Test Coverage: 0% ❌
+Code Duplication: ~50 lines
+Technical Debt: MEDIUM (manageable)
+```
+
+---
+
+## ✅ CONCLUSION
+
+### Strengths Summary ⭐
+- Clean architecture with good separation of concerns
+- Recent bulk import feature shows good iteration
+- Excellent UX/UI for resource planning
+- Dynamic product handling well implemented
+- Business logic properly extracted
+
+### Critical Gaps 🔴
+- **NO TESTS** - Must add before production
+- **NO REQUIREMENTS.TXT** - Limits reproducibility
+- **NO CI/CD** - Manual deployments only
+- **NO LOGGING** - Hard to debug production issues
+- **MINIMAL DOCUMENTATION** - Onboarding difficult
+
+### Path to Production ✅
+1. Add 70%+ test coverage
+2. Create requirements.txt + deployment guide
+3. Set up GitHub Actions CI/CD
+4. Add logging + error handling
+5. Create documentation
+6. Consider authentication for multi-user
+
+### Timeline
+- **4 weeks:** Production-ready (tests + docs + CI/CD)
+- **8 weeks:** Feature-rich (KT management + forecasting)
+- **12 weeks:** Enterprise-grade (auth + integrations)
+
+---
+
+**Recommendation:** This is a solid prototype with great UX. With 2-3 weeks of quality/testing work, it's ready to go production. Highly recommended to pursue the suggested Tier 1 + Tier 2 features for maximum impact.
+
diff --git a/QUICK_ACTION_PLAN.md b/QUICK_ACTION_PLAN.md
new file mode 100644
index 0000000..64edd95
--- /dev/null
+++ b/QUICK_ACTION_PLAN.md
@@ -0,0 +1,259 @@
+# 🎯 RESSOURCENPLANNER - ACTION ITEMS SUMMARY
+
+## Executive Summary
+**Rating: 7.2/10** - Good prototype, needs production-hardening and tests
+
+---
+
+## 🔴 CRITICAL (Do First - Week 1)
+
+### 1. Add Unit Tests
+```bash
+# Install
+pip install pytest pytest-cov pytest-streamlit
+
+# Create tests/ folder with:
+- test_allocation_service.py (overallocation logic)
+- test_finance_service.py (cost calculations)
+- test_team_service.py (dataframe building)
+
+# Target: 70%+ coverage
+```
+**Time:** 3-5 days  
+**Impact:** High - Prevents regressions in production
+
+---
+
+### 2. Create requirements.txt
+```bash
+streamlit==1.28.1
+pandas==2.1.3
+plotly==5.17.0
+numpy==1.24.3
+openpyxl==3.1.2  # For Excel export
+```
+**Time:** 15 minutes  
+**Impact:** Critical - Enables reproducible deployments
+
+---
+
+### 3. Add GitHub Actions CI/CD
+```yaml
+# .github/workflows/test.yml
+- Run linters (flake8, black)
+- Run unit tests
+- Check test coverage (min 70%)
+```
+**Time:** 2 hours  
+**Impact:** High - Automated quality gate
+
+---
+
+### 4. Remove Dead Code
+```
+✅ Delete: archive/app_legacy.py (1200 lines)
+✅ Delete: wrapper functions in app.py (lines 43-49, 127-129)
+✅ Consolidate: parse_component_names() (in 2 places)
+```
+**Time:** 30 minutes  
+**Impact:** Medium - Code clarity
+
+---
+
+## 🟡 HIGH PRIORITY (Week 2)
+
+### 5. Add Logging
+```python
+import logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler('app.log'),
+        logging.StreamHandler()
+    ]
+)
+```
+**Time:** 2 hours  
+**Impact:** High - Debugging production issues
+
+---
+
+### 6. Input Validation Layer
+```python
+# logic/validators.py
+def validate_employee(emp) -> tuple[bool, str]:
+    """Validate before saving to DB."""
+    if not emp.get('name'):
+        return False, "Name required"
+    # ... more checks
+    return True, ""
+```
+**Time:** 3 hours  
+**Impact:** High - Prevent data corruption
+
+---
+
+### 7. Error Handling
+```python
+try:
+    pe = pd.to_datetime(row.get('planned_exit'))
+except ValueError as e:
+    logger.error(f"Invalid date for {name}: {e}")
+    st.error(f"Invalid date format")
+    continue
+```
+**Time:** 2-3 hours  
+**Impact:** Medium - User experience
+
+---
+
+### 8. Database Constraints
+```sql
+CREATE TABLE team_members (
+    ...
+    name TEXT NOT NULL UNIQUE,  -- Prevent duplicates
+    knowledge_transfer_status TEXT NOT NULL 
+        CHECK(knowledge_transfer_status IN ('Not Started', 'In Progress', 'Completed'))
+);
+```
+**Time:** 1 hour  
+**Impact:** Medium - Data integrity
+
+---
+
+## 🟢 NICE TO HAVE (Weeks 3-4)
+
+### 9. Advanced Features (Pick 2-3)
+- [ ] **User Authentication** (OAuth, role-based access) - 1 week
+- [ ] **Knowledge Transfer Management** (plans, checklists, tracking) - 1 week
+- [ ] **Capacity Forecasting** (demand/supply, what-if scenarios) - 2 weeks
+- [ ] **Skill Matrix** (competency tracking, gaps) - 1 week
+- [ ] **Advanced Reporting** (custom reports, PDF export) - 1 week
+
+---
+
+## 📋 DUPLICATE CODE TO REMOVE
+
+| File | Duplicate | Lines | Fix |
+|------|-----------|-------|-----|
+| app.py + Stammdaten_Management.py | parse_component_names() | 7 | Move to logic/utils.py |
+| All 5 pages | Page config boilerplate | ~20 | Create init_page() helper |
+| app.py:67-96 | sync_master_data_to_legacy_state() | 30 | Simplify with unified state |
+
+**Total Cleanup: ~50-100 lines**
+
+---
+
+## 📊 CONFIGURATION CHECKLIST
+
+- [ ] requirements.txt created ✅
+- [ ] .gitignore updated (add .env, logs/, __pycache__/) 
+- [ ] config.py with env variables (DB_PATH, LOG_LEVEL, DEBUG)
+- [ ] Dockerfile for containerization
+- [ ] docker-compose.yml for local dev
+- [ ] .env.example file for reference
+
+---
+
+## 📚 DOCUMENTATION CHECKLIST
+
+- [ ] README.md expanded with setup, features, architecture
+- [ ] API documentation (docstrings on all functions)
+- [ ] Database schema diagram (ER diagram)
+- [ ] Deployment guide (Heroku/Railway/CloudRun)
+- [ ] Contributing guide (for team development)
+- [ ] User guide (workflow screenshots)
+- [ ] Architecture Decision Log
+
+---
+
+## 🚀 PRODUCTION READINESS CHECKLIST
+
+- [ ] 70%+ unit test coverage
+- [ ] All linting passes (flake8, black)
+- [ ] CI/CD pipeline working
+- [ ] Logging implemented
+- [ ] Error handling in place
+- [ ] Database backups automated
+- [ ] Environment variables configured
+- [ ] Documentation complete
+- [ ] No dead code
+- [ ] Code review completed
+
+**Status:** ⚠️ 0/10 currently (Work in Progress)
+
+---
+
+## 💡 QUICK WINS (Today - 30 mins each)
+
+```
+Quick Win #1: Add type hints
+- Add return type annotations to all functions
+- Improves IDE autocomplete and catches bugs
+
+Quick Win #2: Add one test
+- Test allocation_service.check_overallocation()
+- Validates core logic works
+
+Quick Win #3: Create requirements.txt
+- Run: pip freeze > requirements.txt
+- Update package versions manually
+
+Quick Win #4: Document main flow
+- Create ARCHITECTURE.md explaining layers
+- Helps new developers onboard faster
+```
+
+---
+
+## 📈 IMPROVEMENT TRAJECTORY
+
+```
+Week 1:    ████░░░░░░  40% (Tests + requirements)
+Week 2:    ██████░░░░  60% (Logging + validation)
+Week 3:    ████████░░  80% (Error handling + docs)
+Week 4:    ██████████ 100% (Production ready)
+```
+
+---
+
+## 🎓 KEY INSIGHTS FROM REVIEW
+
+**What's Working Well:**
+✅ Architecture is clean and well-organized  
+✅ Recent features (bulk import, dynamic colors) well-executed  
+✅ Business logic properly extracted  
+✅ Database persistence layer is solid  
+✅ UI/UX is intuitive and polished  
+
+**What Needs Work:**
+❌ No tests (highest risk area)  
+❌ No deployment/CI-CD  
+❌ Minimal documentation  
+❌ Some code duplication  
+❌ Sparse error handling  
+
+**Immediate Action:**
+🎯 Tests + requirements.txt (Week 1)  
+🎯 Logging + error handling (Week 2)  
+🎯 Documentation (Week 2-3)  
+🎯 New features (Week 4+)  
+
+---
+
+## 📞 NEXT STEPS
+
+1. **Review** this document with your team
+2. **Prioritize** which Tier 1 features matter most
+3. **Assign** tasks from critical section (2-3 people, 4 weeks)
+4. **Create** GitHub issues for each task
+5. **Set** up weekly code review cadence
+6. **Define** definition of done (tests, docs, code review)
+
+**Estimated Timeline to Production:** 4-6 weeks
+
+---
+
+
+
diff --git a/README.md b/README.md
index eb0ce86..07a2c6c 100644
--- a/README.md
+++ b/README.md
@@ -1,3 +1,170 @@
-# ressourcenplanner
-Resource analytics Tool Prototype with Streamlit. When approved, will be developed with react and python for better User experience and scalability.
-update: seperated the whole code into the three standard layers for data persistence and better functionality
+# 🏢 AURA (Automated Resource Analysis) - AI-Powered Resource Planning & Workforce Management
+
+**AURA** is an intelligent workforce resource planning platform powered by **AURORA**, an advanced AI scenario analysis engine.
+
+## What is AURA?
+
+**AURA** (Executive Dashboard) provides comprehensive resource planning across:
+- Team management & organizational structure
+- Project allocation & capacity tracking
+- Budget forecasting & financial planning
+- **AURORA** AI-driven scenario analysis
+
+## What is AURORA?
+
+**AURORA** is the AI-powered decision engine within AURA that answers critical "what-if" workforce questions in seconds:
+
+- What if we delay hiring for this component?
+- What if we add a new team member?
+- Where should we prioritize new hires?
+- What's our knowledge transfer risk?
+- How will decisions affect budget & timeline?
+
+**AURORA** combines:
+- Real-time LLM reasoning (Groq's Llama 3.3 70B)
+- Company-specific workforce data analysis
+- Multi-dimensional impact assessment (Timeline + Budget + Risk)
+- Transparent confidence scoring
+
+## Quick Start
+
+### Prerequisites
+- Python 3.12+
+- Groq API key (free at https://console.groq.com)
+
+### Setup
+
+```bash
+python -m venv .venv
+source .venv/bin/activate  # On Windows: .venv\Scripts\activate
+pip install -r requirements.txt
+
+# Create .env file
+echo "GROQ_API_KEY=gsk_YOUR_KEY_HERE" > .env
+
+# Run AURA
+streamlit run app.py
+```
+
+AURA will open at `http://localhost:8501`
+
+## Documentation
+
+- **[AURA_PROJECT_ANALYSIS.md](AURA_PROJECT_ANALYSIS.md)** - Complete technical analysis
+- **[AURA_ARCHITECTURE_DIAGRAMS.md](AURA_ARCHITECTURE_DIAGRAMS.md)** - System architecture & diagrams
+
+## Architecture
+
+### AURA Platform (5 Pages)
+
+1. **🏠 Executive Dashboard** - Strategic overview & KPIs
+2. **🛠️ Stammdaten Management** - Team, components, budgets
+3. **📅 Projekt Allocation** - Capacity & project assignments
+4. **💰 Finanzielle Verwaltung** - Budget forecasting
+5. **🤖 AURORA Scenarios** - AI-powered what-if analysis
+
+### AURORA Engine (AI Core)
+
+```
+User Scenario → Context Building → Prompt Construction → 
+Groq LLM (5-30s) → Response Parsing → Results & Visualizations
+```
+
+**Scenario Types:**
+- Hiring Delay Impact
+- Employee Addition Analysis
+- Component Risk Assessment
+- Hiring Priority Optimization
+- Knowledge Transfer Prediction
+
+## 💡 Key Features
+
+✅ **Real-time AI Analysis** - Get insights in seconds, not weeks  
+✅ **Multi-dimensional Impact** - Timeline + Budget + Risk assessment  
+✅ **Transparent Reasoning** - See why AURORA recommends something  
+✅ **Confidence Scoring** - Know how certain the AI is (0-100%)  
+✅ **Alternative Suggestions** - Explore different approaches  
+✅ **Interactive Visualizations** - Plotly charts for insights  
+✅ **German Localization** - Native language support  
+
+## 📈 Business Value
+
+- **Speed:** 5-30 seconds vs 2-week manual analysis
+- **Accuracy:** AI considers 20+ variables simultaneously
+- **ROI:** Saves ~€30K/month in decision-making time
+- **Confidence:** Transparent scoring builds trust
+
+## Tech Stack
+
+| Layer | Technology |
+|-------|-----------|
+| **Frontend** | Streamlit 1.28.1, Plotly 5.17.0 |
+| **Backend** | Python 3.12, SQLite |
+| **AI Engine** | Groq API, Llama 3.3 70B (AURORA) |
+| **Deployment** | Local/Cloud |
+
+## Project Structure
+
+```
+ressourcenplanner/
+├── app.py                          # Main AURA dashboard
+├── pages/
+│   ├── Stammdaten_Management.py   # Team management
+│   ├── Projekt_Allocation.py      # Project allocation
+│   ├── Finanzielle_Verwaltung.py # Budget management
+│   └── Scenario_Analysis.py       # AURORA scenarios
+├── logic/
+│   ├── scenario_engine.py         # AURORA AI engine
+│   ├── team_service.py            # Team logic
+│   ├── finance_service.py         # Finance logic
+│   ├── allocation_service.py      # Allocation logic
+│   └── visualization_service.py   # Chart generation
+├── database/
+│   ├── connection.py              # SQLite connection
+│   ├── schema.py                  # Database schema
+│   ├── team_repository.py         # Team data access
+│   ├── finance_repository.py      # Finance data access
+│   ├── allocation_repository.py   # Allocation data access
+│   └── session_store.py           # State persistence
+├── ui/
+│   └── theme.py                   # Streamlit theming
+├── .env                           # Configuration (add Groq API key)
+└── requirements.txt               # Python dependencies
+```
+
+## Security
+
+- API keys stored in `.env` (not in version control)
+- `.env` added to `.gitignore`
+- No hardcoded secrets
+- Groq API key validated on startup
+
+## Status
+
+**Current:** Prototype/MVP (8/10 ready for approval)
+
+**For Production:**
+- ✅ Logic layer (reusable)
+- ⚠️ Frontend (Streamlit → React migration needed)
+- ⚠️ Database (SQLite → PostgreSQL scaling needed)
+- ⚠️ Testing (add comprehensive test coverage)
+
+## Roadmap (Post-Approval)
+
+**Phase 1 (Weeks 1-4):** Stabilization & approval presentation  
+**Phase 2 (Weeks 5-8):** Input validation & error handling  
+**Phase 3 (Weeks 9-16):** React migration & PostgreSQL  
+**Phase 4 (Weeks 17-24):** Enterprise features (RBAC, audit logs)  
+**Phase 5 (Ongoing):** Advanced analytics & ML  
+
+## 📧 Contact & Support
+
+Created: April 2026  
+Status: Prototype for Business Approval  
+Maintained by: Tushar Tyagi
+
+---
+
+**Remember:** 
+- **AURA** = The complete resource planning platform
+- **AURORA** = The AI scenario analysis engine within AURA
diff --git a/app.py b/app.py
index 93428a2..9fa00c6 100644
--- a/app.py
+++ b/app.py
@@ -4,6 +4,13 @@
 from datetime import datetime, timedelta
 import plotly.graph_objects as go
 import numpy as np
+import os
+from pathlib import Path
+from dotenv import load_dotenv
+
+# Load environment variables from .env file
+env_path = Path(__file__).parent / ".env"
+load_dotenv(dotenv_path=env_path)
 
 from database.session_store import (
     ensure_session_state,
@@ -60,6 +67,12 @@ def parse_component_names(value):
     return [str(item).strip() for item in raw_items if str(item).strip()]
 
 
+def required_with_backup(component: dict) -> int:
+    """Return required headcount including backup coverage if enabled."""
+    base_required = int(component.get("required_resources", 1) or 1)
+    return base_required + 1 if component.get("backup_available", False) else base_required
+
+
 def sync_master_data_to_legacy_state():
     """Keep experimental master-data records in sync with legacy dashboard state."""
     st.session_state.setdefault("products_data", [])
@@ -81,7 +94,7 @@ def sync_master_data_to_legacy_state():
         responsible_people = parse_component_names(component.get("responsible_persons", []))
         component_map[component_name] = responsible_people
         component_products[component_name] = component.get("product_name", "Unknown")
-        component_requirements[component_name] = int(component.get("required_resources", 1))
+        component_requirements[component_name] = required_with_backup(component)
         component_transfer_times[component_name] = int(component.get("knowledge_transfer_time_needed", 6))
 
     st.session_state.component_map = component_map
@@ -163,6 +176,10 @@ def main():
             responsible_list = responsible if isinstance(responsible, (list, tuple)) else [responsible]
             comp_key = component.strip().lower()
             active_count = 0
+            component_details = next(
+                (item for item in st.session_state.get("components_data", []) if item.get("component_name") == component),
+                {},
+            )
 
             for _, row in df.iterrows():
                 name = str(row.get('name', '')).strip()
@@ -181,6 +198,10 @@ def main():
                 if assigned and started and not_left:
                     active_count += 1
 
+            # A flagged backup is treated as explicit additional coverage.
+            if component_details.get("backup_available", False):
+                active_count += 1
+
             required = int(st.session_state.component_requirements.get(component, 1))
             if active_count == 0:
                 status = "UNBESETZT"
@@ -263,6 +284,117 @@ def main():
         <p style="margin: 0;"><b>Heute priorisieren:</b> {urgent_cases} hochkritische Fälle unter 90 Tagen.</p>
     </div>
     """, unsafe_allow_html=True)
+
+    executive_focus = st.toggle(
+        "Executive Focus (kompakte Management-Sicht)",
+        value=True,
+        help="Zeigt eine kompakte C-Level Ansicht und blendet operative Detailblöcke aus.",
+    )
+
+    if executive_focus:
+        st.markdown("---")
+        st.markdown('<h3 class="section-header">⚡ Executive Decision Queue</h3>', unsafe_allow_html=True)
+
+        decision_items = []
+        if urgent_cases > 0:
+            decision_items.append(
+                (
+                    "SOFORT",
+                    f"{urgent_cases} kritische Exits in den nächsten 90 Tagen absichern",
+                    "Owner: Team Leads • Ziel: Risiko innerhalb von 7 Tagen senken",
+                )
+            )
+
+        if not comp_df.empty:
+            unstaffed_count = len(comp_df[comp_df["Status"] == "UNBESETZT"])
+            single_count = len(comp_df[comp_df["Status"] == "UNTERBESETZT - SINGLE"])
+            under_count = len(comp_df[comp_df["Status"] == "UNTERBESETZT"])
+
+            if unstaffed_count > 0:
+                decision_items.append(
+                    (
+                        "HOCH",
+                        f"{unstaffed_count} Komponenten sind aktuell unbesetzt",
+                        "Owner: Staffing • Maßnahme: sofortige Vertretung oder externe Kapazität",
+                    )
+                )
+            if single_count > 0:
+                decision_items.append(
+                    (
+                        "HOCH",
+                        f"{single_count} Komponenten haben Single-Point-of-Failure",
+                        "Owner: Engineering Manager • Maßnahme: Backup-Ressource innerhalb 30 Tage",
+                    )
+                )
+            if under_count > 0:
+                decision_items.append(
+                    (
+                        "MITTEL",
+                        f"{under_count} Komponenten sind unterbesetzt",
+                        "Owner: Delivery • Maßnahme: Priorisierung gegen Quartalsziele prüfen",
+                    )
+                )
+
+        if not decision_items:
+            st.success("✅ Keine unmittelbaren Eskalationen. Portfolio ist aktuell stabil.")
+        else:
+            for priority, title, action in decision_items[:3]:
+                color = colors["error"] if priority == "SOFORT" else (colors["warning"] if priority == "HOCH" else colors["info"])
+                st.markdown(
+                    f"""
+                    <div style="border-left: 5px solid {color}; background: #ffffff; border-radius: 10px; padding: 0.85rem 1rem; margin-bottom: 0.6rem; box-shadow: 0 1px 4px rgba(0,0,0,0.08);">
+                        <p style="margin: 0; color: {color}; font-weight: 700;">{priority}</p>
+                        <p style="margin: 0.2rem 0 0.15rem 0; font-weight: 600;">{title}</p>
+                        <p style="margin: 0; color: {colors['text_secondary']};">{action}</p>
+                    </div>
+                    """,
+                    unsafe_allow_html=True,
+                )
+
+        st.markdown("---")
+        st.markdown('<h3 class="section-header">🧭 Portfolio Risk View</h3>', unsafe_allow_html=True)
+
+        delivery_risk_index = min(100, (urgent_cases * 8) + (critical_cases * 4) + (staffing_gap_count * 12))
+        risk_col1, risk_col2, risk_col3 = st.columns(3)
+        with risk_col1:
+            st.metric("Delivery Risk Index", f"{delivery_risk_index}/100")
+        with risk_col2:
+            st.metric("Kritische Exits (<90d)", urgent_cases)
+        with risk_col3:
+            st.metric("Komponenten mit Gap", staffing_gap_count)
+
+        if not comp_df.empty:
+            status_weight = {
+                "UNBESETZT": 100,
+                "UNTERBESETZT - SINGLE": 85,
+                "UNTERBESETZT": 65,
+                "OK": 15,
+            }
+            executive_comp_df = comp_df.copy()
+            executive_comp_df["Risiko-Score"] = executive_comp_df["Status"].map(status_weight).fillna(50)
+            executive_comp_df = executive_comp_df.sort_values(["Risiko-Score", "Komponente"], ascending=[False, True])
+
+            def status_style(val):
+                if val == "UNBESETZT":
+                    return "background-color: #ff4d4f; color: white; font-weight: bold"
+                if val == "UNTERBESETZT - SINGLE":
+                    return "background-color: #d46b08; color: white; font-weight: bold"
+                if val == "UNTERBESETZT":
+                    return "background-color: #faad14; color: #1f1f1f; font-weight: bold"
+                return "background-color: #52c41a; color: white; font-weight: bold"
+
+            st.dataframe(
+                executive_comp_df[["Komponente", "Aktive Ressourcen", "Benötigt", "Risiko-Score", "Status"]]
+                .style
+                .applymap(status_style, subset=["Status"]),
+                use_container_width=True,
+                height=320,
+            )
+        else:
+            st.info("ℹ️ Noch keine Komponenten verfügbar.")
+
+        st.caption("Für operative Detailansicht den Toggle oben deaktivieren.")
+        return
     
     # CRITICAL ALERTS SECTION  
     st.markdown("---")
@@ -696,6 +828,8 @@ def status_style(val):
                 responsible_list = responsible if isinstance(responsible, (list, tuple)) else [responsible]
                 complexity_score = int(details.get("complexity_score", 5))
                 required_people = int(details.get("required_resources", st.session_state.component_requirements.get(component, 1)))
+                if details.get("backup_available", False):
+                    required_people += 1
                 transfer_time_months = int(details.get("knowledge_transfer_time_needed", st.session_state.component_transfer_times.get(component, 6)))
                 documentation_status = details.get("documentation_status", "Nicht bewertet")
                 backup_available = "Ja" if details.get("backup_available", False) else "Nein"
diff --git a/logic/scenario_engine.py b/logic/scenario_engine.py
new file mode 100644
index 0000000..a72c859
--- /dev/null
+++ b/logic/scenario_engine.py
@@ -0,0 +1,858 @@
+"""
+🌟 AURORA - AI-powered scenario simulation engine for workforce planning.
+Uses Groq's Mixtral/Llama models to predict impact of management decisions.
+
+AURORA helps workforce managers answer critical what-if questions:
+- What if we delay hiring for this component?
+- What if we add a new team member?
+- Where should we prioritize new hires?
+- What's our knowledge transfer risk?
+- How will our budget be affected?
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from datetime import datetime, timedelta
+from typing import TypedDict
+
+from groq import Groq
+
+
+class ScenarioResult(TypedDict):
+    """Structure for scenario analysis results."""
+    scenario_type: str
+    timeline_impact_days: int
+    budget_impact_euros: float
+    risk_increase_percent: float
+    recommendation: str
+    reasoning: str
+    alternatives: list[dict]
+    confidence_score: float  # 0-100%
+
+
+class AurorAI:
+    """
+    AURORA: AI-powered scenario simulator using Claude's decision reasoning.
+    
+    Analyzes workforce management what-if scenarios to predict:
+    - Timeline impacts
+    - Budget consequences
+    - Risk changes
+    - Recommended alternatives
+    """
+    
+    def __init__(self, api_key: str = None):
+        """Initialize Groq API client."""
+        self.api_key = api_key or os.getenv("GROQ_API_KEY")
+        if not self.api_key:
+            raise ValueError(
+                "GROQ_API_KEY not set. "
+                "Set via environment variable or pass to __init__"
+            )
+        self.client = Groq(api_key=self.api_key)
+        self.model = "llama-3.3-70b-versatile"  # Groq's available fast model
+    
+    def simulate_hiring_delay(
+        self,
+        component_name: str,
+        delay_days: int,
+        current_staffing: int,
+        required_staffing: int,
+        component_criticality: str,  # "critical", "important", "standard"
+        budget_remaining_euros: float,
+        team_data: list[dict],
+        components_data: list[dict],
+    ) -> ScenarioResult:
+        """
+        Simulate impact of delaying hiring for a component.
+        
+        Args:
+            component_name: Name of component
+            delay_days: How many days to delay hiring start
+            current_staffing: Current number of people
+            required_staffing: Required number for component
+            component_criticality: How critical is this component
+            budget_remaining_euros: Budget available
+            team_data: Current team roster
+            components_data: Component definitions
+        
+        Returns:
+            ScenarioResult with predicted impacts and recommendations
+        """
+        
+        context = self._build_hiring_context(
+            component_name,
+            current_staffing,
+            required_staffing,
+            component_criticality,
+            team_data,
+            components_data,
+        )
+        
+        prompt = f"""
+You are an expert workforce planning consultant. Analyze this scenario:
+
+{context}
+
+SCENARIO: We delay hiring for {component_name} by {delay_days} days.
+This means the hiring process starts {delay_days} days later than originally planned.
+
+Based on industry standards and best practices, provide your analysis in JSON format:
+
+{{
+  "timeline_impact_days": <estimated project delay in days>,
+  "budget_impact_euros": <additional costs (negative = savings)>,
+  "risk_increase_percent": <increase in failure risk 0-100>,
+  "recommendation": "<brief recommendation: EXECUTE, RECONSIDER, or AVOID>",
+  "reasoning": "<2-3 sentences explaining your analysis>",
+  "alternatives": [
+    {{
+      "option": "<alternative approach>",
+      "timeline_impact": <days>,
+      "budget_impact": <euros>,
+      "pros": "<benefits>",
+      "cons": "<drawbacks>"
+    }},
+    ...
+  ],
+  "confidence_score": <0-100>
+}}
+
+Be specific with numbers. Consider:
+- Current staffing gaps
+- Component criticality
+- Budget constraints
+- Industry standard hiring timelines (60-90 days)
+- Knowledge transfer requirements
+"""
+        
+        return self._call_claude_scenario(prompt, "hiring_delay")
+    
+    def simulate_employee_addition(
+        self,
+        employee_name: str,
+        employee_role: str,
+        employee_level: str,  # "junior", "mid", "senior"
+        components_assigned: list[str],
+        start_date: str,
+        budget_impact_monthly_euros: float,
+        team_data: list[dict],
+        components_data: list[dict],
+    ) -> ScenarioResult:
+        """
+        Simulate impact of adding a new employee.
+        
+        Args:
+            employee_name: Name of new hire
+            employee_role: Role/position
+            employee_level: Experience level
+            components_assigned: Components this person will work on
+            start_date: When they start
+            budget_impact_monthly_euros: Monthly salary cost
+            team_data: Current team
+            components_data: Component definitions
+        
+        Returns:
+            ScenarioResult with predicted impacts
+        """
+        
+        context = self._build_employee_context(
+            employee_name,
+            employee_role,
+            employee_level,
+            components_assigned,
+            team_data,
+            components_data,
+        )
+        
+        prompt = f"""
+You are an expert workforce planning consultant. Analyze this hiring decision:
+
+{context}
+
+NEW EMPLOYEE:
+- Name: {employee_name}
+- Role: {employee_role}
+- Level: {employee_level}
+- Start date: {start_date}
+- Monthly cost: €{budget_impact_monthly_euros:,.0f}
+- Assigned to: {', '.join(components_assigned)}
+
+Provide your analysis in JSON format:
+
+{{
+  "timeline_impact_days": <timeline improvement in days (negative = delays)>,
+  "budget_impact_euros": <total cost including salary, training, ramp-up>,
+  "risk_decrease_percent": <reduction in failure risk 0-100>,
+  "recommendation": "<HIRE, CONDITIONAL, or HOLD>",
+  "reasoning": "<2-3 sentences on ROI and impact>",
+  "knock_on_effects": [
+    "<unexpected consequences or benefits>"
+  ],
+  "alternatives": [
+    {{
+      "option": "<alternative approach>",
+      "pros": "<benefits>",
+      "cons": "<drawbacks>",
+      "cost": <euros>
+    }}
+  ],
+  "confidence_score": <0-100>
+}}
+
+Consider:
+- Component dependencies
+- Ramp-up time for level
+- Knowledge transfer burden on team
+- Total cost of employment (salary + training + ramp-up)
+- Impact on other team members
+"""
+        
+        return self._call_claude_scenario(prompt, "employee_addition")
+    
+    def analyze_component_risk(
+        self,
+        component_name: str,
+        current_staffing: int,
+        required_staffing: int,
+        responsible_persons: list[str],
+        knowledge_transfer_status: str,
+        components_data: list[dict],
+        team_data: list[dict],
+    ) -> dict:
+        """
+        Analyze risk for a specific component.
+        
+        Returns risk assessment with recommendations.
+        """
+        
+        context = self._build_risk_context(
+            component_name,
+            current_staffing,
+            required_staffing,
+            responsible_persons,
+            knowledge_transfer_status,
+            components_data,
+            team_data,
+        )
+        
+        prompt = f"""
+You are an expert risk analyst. Assess the risk for this component:
+
+{context}
+
+Provide JSON analysis:
+
+{{
+  "risk_score": <0-100, where 100 is complete failure>,
+  "risk_level": "<CRITICAL, HIGH, MEDIUM, LOW>",
+  "single_point_of_failure": <true/false>,
+  "months_until_critical": <estimated months before crisis>,
+  "immediate_actions": [
+    "<action required NOW>"
+  ],
+  "priority_hiring": [
+    {{
+      "role": "<role to hire>",
+      "urgency": "<IMMEDIATE, 30 days, 60 days>",
+      "reason": "<why this role>"
+    }}
+  ],
+  "alternatives_to_hiring": [
+    {{
+      "approach": "<alternative>",
+      "cost": <euros>,
+      "effectiveness": <0-100%>
+    }}
+  ]
+}}
+
+Be specific. Consider:
+- Current vs required staffing
+- Knowledge transfer status
+- Exit dates in next 24 months
+- Component criticality
+- Industry benchmarks
+"""
+        
+        return self._call_claude_scenario(prompt, "risk_analysis")
+    
+    def recommend_hiring_priority(
+        self,
+        available_budget_euros: float,
+        max_hires: int,
+        components_data: list[dict],
+        team_data: list[dict],
+    ) -> dict:
+        """
+        Use AI to recommend optimal hiring priority given constraints.
+        
+        Answers: "We can hire 2 people with €180K. Which components first?"
+        """
+        
+        context = self._build_hiring_priority_context(
+            components_data,
+            team_data,
+        )
+        
+        prompt = f"""
+You are an expert workforce optimizer. I have constraints:
+- Budget available: €{available_budget_euros:,.0f}
+- Maximum hires allowed: {max_hires}
+
+Current portfolio:
+
+{context}
+
+Recommend the optimal hiring sequence to:
+1. Minimize overall risk
+2. Protect critical path components
+3. Maximize ROI
+4. Stay within budget
+
+Provide JSON response:
+
+{{
+  "recommended_sequence": [
+    {{
+      "priority": 1,
+      "component": "<component name>",
+      "hire_count": <number of people>,
+      "role": "<specific role>",
+      "level": "<junior/mid/senior>",
+      "cost": <monthly salary>,
+      "rationale": "<why hire this first>",
+      "risk_reduction": <0-100%>,
+      "timeline_impact": "<improves by X months or avoids Y month delay>"
+    }},
+    ...
+  ],
+  "total_cost": <euros>,
+  "why_this_sequence": "<key reasoning>",
+  "risks_if_not_followed": [
+    "<risk if not followed>"
+  ],
+  "confidence_score": <0-100>
+}}
+
+Be strategic. This is the company's hiring roadmap.
+"""
+        
+        return self._call_claude_scenario(prompt, "hiring_priority")
+    
+    def predict_kt_success(
+        self,
+        component_name: str,
+        departing_person: dict,
+        replacement_person: dict = None,
+        planned_kt_weeks: int = 8,
+        team_data: list[dict] = None,
+        components_data: list[dict] = None,
+    ) -> dict:
+        """
+        Predict success probability of knowledge transfer scenario.
+        """
+        
+        replacement_info = (
+            f"Replacement: {replacement_person['name']} "
+            f"({replacement_person.get('role', 'Unknown')})"
+            if replacement_person
+            else "Replacement: Not yet assigned"
+        )
+        
+        prompt = f"""
+You are an expert in knowledge transfer assessment.
+
+SCENARIO:
+- Component: {component_name}
+- Departing: {departing_person['name']} ({departing_person.get('role', 'Unknown')})
+- {replacement_info}
+- Planned KT duration: {planned_kt_weeks} weeks
+
+Predict knowledge transfer success in JSON:
+
+{{
+  "success_probability": <0-100%>,
+  "risk_level": "<CRITICAL, HIGH, MEDIUM, LOW>",
+  "loss_assessment": "<what will definitely be lost>",
+  "kt_plan": [
+    {{
+      "phase": "<phase name>",
+      "weeks": <duration>,
+      "activities": ["<activity>", ...],
+      "critical_tasks": ["<must cover>", ...],
+      "success_metrics": ["<how to measure>", ...]
+    }},
+    ...
+  ],
+  "budget_for_kt": <euros for training, external help, etc>,
+  "contingency_plan": "<if KT fails, then...>",
+  "confidence_score": <0-100>
+}}
+
+Be realistic about what can be transferred in {planned_kt_weeks} weeks.
+"""
+        
+        return self._call_claude_scenario(prompt, "kt_prediction")
+    
+    def ask_custom_question(
+        self,
+        question: str,
+        team_data: list[dict] = None,
+        components_data: list[dict] = None,
+        budget_data: dict = None,
+        analysis_type: str = "standard",
+    ) -> dict:
+        """
+        Free-form custom question mode.
+        
+        Allows users to ask any workforce-related question without predefined scenarios.
+        AURORA reasons through company context and provides structured analysis.
+        
+        Args:
+            question: User's question (e.g., "Can we deliver Q3 roadmap with 20% fewer developers?")
+            team_data: Current team roster
+            components_data: Project/component definitions
+            budget_data: Budget information
+            analysis_type: "standard" (direct answer), "sensitivity" (explore ranges), 
+                          "comparative" (compare options), "hypothesis" (validate theory)
+        
+        Returns:
+            Dictionary with answer, reasoning, confidence, and recommendations
+        """
+        
+        # Build company context
+        context = self._build_custom_context(team_data, components_data, budget_data)
+        
+        # Different prompts based on analysis type
+        if analysis_type == "comparative":
+            prompt = self._build_comparative_prompt(question, context)
+        elif analysis_type == "sensitivity":
+            prompt = self._build_sensitivity_prompt(question, context)
+        elif analysis_type == "hypothesis":
+            prompt = self._build_hypothesis_prompt(question, context)
+        else:  # standard
+            prompt = self._build_standard_prompt(question, context)
+        
+        return self._call_custom_question_api(prompt, analysis_type)
+    
+    def _build_standard_prompt(self, question: str, context: str) -> str:
+        """Build standard open-ended reasoning prompt - simplified for reliability."""
+        return f"""
+You are a workforce planning expert. Answer this question:
+
+CONTEXT:
+{context}
+
+QUESTION: {question}
+
+Respond with ONLY this JSON (no markdown, no extra text):
+
+{{
+  "answer": "Direct answer to the question",
+  "reasoning": "Why you think this is the answer",
+  "recommendation": "What should be done",
+  "risk": "Key risks to consider",
+  "timeline": "Expected timeline or duration",
+  "confidence_score": 75
+}}
+
+Keep all text concise. DO NOT use quotes or backslashes inside field values.
+"""
+    
+    def _build_comparative_prompt(self, question: str, context: str) -> str:
+        """Build prompt for comparing multiple options - simplified."""
+        return f"""
+You are a workforce planning expert comparing options.
+
+CONTEXT:
+{context}
+
+QUESTION: {question}
+
+Respond with ONLY this JSON (no markdown):
+
+{{
+  "option_a": "First option name",
+  "option_a_pros": "Advantages of option A",
+  "option_a_cons": "Disadvantages of option A",
+  "option_b": "Second option name",
+  "option_b_pros": "Advantages of option B", 
+  "option_b_cons": "Disadvantages of option B",
+  "recommendation": "Which option is better and why",
+  "timeline_impact": "How it affects your timeline",
+  "budget_impact": "Cost implications",
+  "confidence_score": 75
+}}
+
+Keep text concise. No quotes or backslashes in values.
+"""
+    
+    def _build_sensitivity_prompt(self, question: str, context: str) -> str:
+        """Build prompt for sensitivity/what-if analysis - simplified."""
+        return f"""
+You are a workforce planning expert. Analyze sensitivity/what-if scenarios.
+
+CONTEXT:
+{context}
+
+QUESTION: {question}
+
+Respond with ONLY this JSON (no markdown):
+
+{{
+  "best_case": "Most optimistic outcome",
+  "best_case_conditions": "When this would happen",
+  "base_case": "Most likely outcome",
+  "worst_case": "Most pessimistic outcome",
+  "worst_case_conditions": "When this would happen",
+  "most_critical_variable": "What matters most",
+  "why_critical": "Why this variable is important",
+  "recommendation": "Which scenario should you plan for",
+  "confidence_score": 72
+}}
+
+Keep text concise. No quotes or backslashes in values.
+"""
+    
+    def _build_hypothesis_prompt(self, question: str, context: str) -> str:
+        """Build prompt for validating user hypotheses/theories - simplified."""
+        return f"""
+You are a workforce planning expert. Validate the user's hypothesis.
+
+CONTEXT:
+{context}
+
+HYPOTHESIS: {question}
+
+Respond with ONLY this JSON (no markdown):
+
+{{
+  "hypothesis": "The hypothesis restated clearly",
+  "is_likely": true,
+  "confidence_score": 68,
+  "supporting_evidence": "Evidence that supports this hypothesis",
+  "contradicting_evidence": "Evidence that contradicts this hypothesis",
+  "conditions_needed": "What conditions must be true for this to work",
+  "key_risks": "Main risks if you proceed with this assumption",
+  "recommendation": "What you should do based on this analysis"
+}}
+
+Replace true/false for is_likely. Keep text concise. No special characters in values.
+"""
+    
+    def _build_custom_context(
+        self,
+        team_data: list[dict],
+        components_data: list[dict],
+        budget_data: dict,
+    ) -> str:
+        """Build general company context for custom questions."""
+        
+        # Team summary
+        team_summary = f"Current team: {len(team_data or [])} people" if team_data else "Team data: Not available"
+        
+        # Components summary
+        if components_data:
+            comp_summary = f"{len(components_data)} components/projects"
+            comp_names = [c.get("component_name", "Unknown") for c in components_data[:5]]
+            comp_summary += f": {', '.join(comp_names)}"
+        else:
+            comp_summary = "No component data available"
+        
+        # Budget summary
+        if budget_data:
+            total_budget = budget_data.get("total_budget_euros", 0)
+            spent = budget_data.get("spent_euros", 0)
+            remaining = total_budget - spent
+            budget_summary = (
+                f"Budget: €{total_budget:,.0f} total, "
+                f"€{spent:,.0f} spent, "
+                f"€{remaining:,.0f} remaining"
+            )
+        else:
+            budget_summary = "Budget data: Not available"
+        
+        return f"""
+ORGANIZATION:
+- {team_summary}
+- {comp_summary}
+- {budget_summary}
+
+Please consider this context when answering the user's question.
+"""
+    
+    def _call_custom_question_api(self, prompt: str, analysis_type: str) -> dict:
+        """Call Groq API for custom questions - with robust JSON parsing."""
+        
+        try:
+            response = self.client.chat.completions.create(
+                model=self.model,
+                max_tokens=3000,
+                messages=[{"role": "user", "content": prompt}],
+            )
+            
+            response_text = response.choices[0].message.content
+            
+            # Extract JSON from response
+            json_start = response_text.find("{")
+            json_end = response_text.rfind("}") + 1
+            
+            if json_start == -1 or json_end <= json_start:
+                return self._create_error_response(
+                    "No JSON found in response. AURORA couldn't format its answer properly.",
+                    analysis_type
+                )
+            
+            json_str = response_text[json_start:json_end]
+            
+            # Aggressive JSON cleaning
+            json_str = self._clean_json_string(json_str)
+            
+            # Try to parse
+            try:
+                result = json.loads(json_str)
+                result["analysis_type"] = analysis_type
+                result["full_response"] = response_text
+                return result
+            except json.JSONDecodeError as je:
+                # If parsing still fails, return the raw text as fallback
+                return self._create_fallback_response(response_text, analysis_type, str(je))
+        
+        except Exception as e:
+            return self._create_error_response(str(e), analysis_type)
+    
+    def _clean_json_string(self, json_str: str) -> str:
+        """Aggressively clean JSON string to fix escape issues."""
+        import re
+        
+        # Remove tabs and carriage returns
+        json_str = json_str.replace('\t', ' ').replace('\r', '')
+        
+        # Fix: Remove backslashes before non-escape characters
+        # Valid escapes in JSON: \", \\, \/, \b, \f, \n, \r, \t, \uXXXX
+        # Remove any backslash NOT followed by these
+        json_str = re.sub(r'\\(?!["\\/bfnrtu])', '', json_str)
+        
+        # Fix newlines within strings: replace actual newlines with \n
+        # This is tricky - we need to replace only newlines WITHIN quoted strings
+        # Strategy: find each quoted string and replace newlines inside
+        def fix_string_newlines(match):
+            # match.group(1) is the content inside quotes
+            content = match.group(1)
+            # Replace actual newlines with space (to preserve content)
+            content = content.replace('\n', ' ').replace('\r', ' ')
+            return f'"{content}"'
+        
+        # Match quoted strings and fix newlines in them
+        json_str = re.sub(r'"((?:\\.|[^"\\])*)"', fix_string_newlines, json_str)
+        
+        return json_str
+    
+    def _create_fallback_response(self, raw_text: str, analysis_type: str, parse_error: str) -> dict:
+        """Create a structured response from raw text when JSON parsing fails."""
+        # Try to extract useful information from the raw response
+        return {
+            "analysis_type": analysis_type,
+            "answer": raw_text[:500],  # First 500 chars as answer
+            "full_response": raw_text,
+            "confidence_score": 65,
+            "parse_error": parse_error,
+            "warning": "AURORA response was formatted differently than expected. Raw text shown above."
+        }
+    
+    def _create_error_response(self, error_msg: str, analysis_type: str) -> dict:
+        """Create consistent error response."""
+        return {
+            "error": f"API Error: {error_msg}",
+            "analysis_type": analysis_type,
+            "confidence_score": 0,
+        }
+    
+    # ===== HELPER METHODS =====
+    
+    def _build_hiring_context(
+        self,
+        component_name: str,
+        current_staffing: int,
+        required_staffing: int,
+        component_criticality: str,
+        team_data: list[dict],
+        components_data: list[dict],
+    ) -> str:
+        """Build context about hiring delay scenario."""
+        
+        component_info = next(
+            (c for c in components_data if c.get("component_name") == component_name),
+            {},
+        )
+        
+        # Find exits in next 12 months
+        exits_soon = [
+            e for e in team_data
+            if e.get("days_until_exit", 999) < 365
+        ]
+        
+        return f"""
+COMPONENT INFORMATION:
+- Name: {component_name}
+- Criticality: {component_criticality}
+- Current staffing: {current_staffing}
+- Required staffing: {required_staffing} (gap: {required_staffing - current_staffing})
+- Responsible persons: {', '.join(component_info.get('responsible_persons', []))}
+- Knowledge transfer time: {component_info.get('knowledge_transfer_time_needed', 6)} months
+
+TEAM CONTEXT:
+- Total team size: {len(team_data)}
+- Exits planned in next 12 months: {len(exits_soon)}
+- Team capacity: {(current_staffing / required_staffing * 100):.0f}% of target
+
+BUSINESS CONTEXT:
+- Industry: Siemens internal
+- Average hiring time: 60-90 days
+- Component strategic importance: {component_criticality}
+"""
+    
+    def _build_employee_context(
+        self,
+        employee_name: str,
+        employee_role: str,
+        employee_level: str,
+        components_assigned: list[str],
+        team_data: list[dict],
+        components_data: list[dict],
+    ) -> str:
+        """Build context about new employee."""
+        
+        component_gaps = []
+        for comp in components_assigned:
+            comp_data = next(
+                (c for c in components_data if c.get("component_name") == comp),
+                {},
+            )
+            required = comp_data.get("required_resources", 1)
+            current = len([
+                t for t in team_data
+                if comp in (t.get("components") or "").split(",")
+            ])
+            gap = required - current
+            if gap > 0:
+                component_gaps.append(f"- {comp}: {gap} people needed")
+        
+        return f"""
+NEW HIRE PROFILE:
+- Name: {employee_name}
+- Role: {employee_role}
+- Level: {employee_level}
+- Components assigned: {', '.join(components_assigned)}
+
+COMPONENT GAPS BEING FILLED:
+{chr(10).join(component_gaps) if component_gaps else "- No gaps, optimizing capacity"}
+
+TEAM STRUCTURE:
+- Current size: {len(team_data)}
+- Ramp-up overhead: {employee_level in ['junior', 'mid'] and '15-20%' or '5%'} of team capacity
+"""
+    
+    def _build_risk_context(
+        self,
+        component_name: str,
+        current_staffing: int,
+        required_staffing: int,
+        responsible_persons: list[str],
+        knowledge_transfer_status: str,
+        components_data: list[dict],
+        team_data: list[dict],
+    ) -> str:
+        """Build risk assessment context."""
+        
+        component_info = next(
+            (c for c in components_data if c.get("component_name") == component_name),
+            {},
+        )
+        
+        # Check exits for responsible persons
+        responsible_exits = []
+        for person in responsible_persons:
+            person_data = next(
+                (t for t in team_data if t.get("name") == person),
+                {},
+            )
+            if person_data:
+                days_left = person_data.get("days_until_exit", 999)
+                responsible_exits.append(
+                    f"- {person}: {days_left} days until exit"
+                )
+        
+        return f"""
+COMPONENT: {component_name}
+- Complexity score: {component_info.get('complexity_score', 5)}/10
+- Required staffing: {required_staffing}
+- Current staffing: {current_staffing}
+- Staffing gap: {required_staffing - current_staffing}
+- Knowledge transfer status: {knowledge_transfer_status}
+- Documentation status: {component_info.get('documentation_status', 'Unknown')}
+- Backup available: {component_info.get('backup_available', False)}
+
+RESPONSIBLE PERSONS:
+{chr(10).join(responsible_exits) if responsible_exits else "- No immediate exits"}
+
+CRITICALITY INDICATORS:
+- Single point of failure: {current_staffing == 1}
+- Skills difficult to find: {component_info.get('complexity_score', 5) > 7}
+"""
+    
+    def _build_hiring_priority_context(
+        self,
+        components_data: list[dict],
+        team_data: list[dict],
+    ) -> str:
+        """Build context for hiring priority recommendations."""
+        
+        priority_list = []
+        for comp in components_data:
+            comp_name = comp.get("component_name")
+            required = comp.get("required_resources", 1)
+            responsible = comp.get("responsible_persons", [])
+            
+            priority_list.append(
+                f"- {comp_name}: {required} required, "
+                f"Responsible: {', '.join(responsible) if responsible else 'Unassigned'}"
+            )
+        
+        return "\n".join(priority_list)
+    
+    def _call_claude_scenario(self, prompt: str, scenario_type: str) -> dict:
+        """Call Groq API and parse scenario response."""
+        
+        try:
+            response = self.client.chat.completions.create(
+                model=self.model,
+                max_tokens=2000,
+                messages=[{"role": "user", "content": prompt}],
+            )
+            
+            response_text = response.choices[0].message.content
+            
+            # Extract JSON from response
+            json_start = response_text.find("{")
+            json_end = response_text.rfind("}") + 1
+            
+            if json_start == -1 or json_end <= json_start:
+                raise ValueError("No JSON found in Groq response")
+            
+            json_str = response_text[json_start:json_end]
+            result = json.loads(json_str)
+            result["scenario_type"] = scenario_type
+            result["reasoning"] = response_text[:json_start].strip()
+            
+            return result
+        
+        except Exception as e:
+            return {
+                "error": f"API Error: {str(e)}",
+                "scenario_type": scenario_type,
+                "confidence_score": 0,
+            }
diff --git a/logic/visualization_service.py b/logic/visualization_service.py
new file mode 100644
index 0000000..b0eb844
--- /dev/null
+++ b/logic/visualization_service.py
@@ -0,0 +1,445 @@
+"""
+Visualization service for AURORA scenario simulations.
+Creates interactive Plotly charts to display simulation results.
+"""
+
+import plotly.graph_objects as go
+import plotly.express as px
+import pandas as pd
+from datetime import datetime, timedelta
+
+
+def create_timeline_impact_chart(timeline_impact_days: int, component_name: str) -> go.Figure:
+    """Create chart showing timeline impact in days."""
+    
+    fig = go.Figure()
+    
+    # Current vs impacted timeline
+    scenarios = ["Original Timeline", "With Delay"]
+    days = [0, timeline_impact_days]
+    colors = ["#00B8A9", "#F8B195"]
+    
+    fig.add_trace(go.Bar(
+        x=scenarios,
+        y=days,
+        marker=dict(color=colors),
+        text=[f"{d} days" for d in days],
+        textposition="auto",
+        hovertemplate="<b>%{x}</b><br>Delay: %{y} days<extra></extra>"
+    ))
+    
+    fig.update_layout(
+        title=f"📅 Timeline Impact for {component_name}",
+        yaxis_title="Days of Delay",
+        xaxis_title="Scenario",
+        height=300,
+        showlegend=False,
+        hovermode="closest"
+    )
+    
+    return fig
+
+
+def create_budget_impact_chart(budget_impact: float, component_name: str) -> go.Figure:
+    """Create gauge chart for budget impact."""
+    
+    # Determine color based on impact
+    if budget_impact > 0:
+        delta_color = "red"
+        impact_label = f"+€{budget_impact:,.0f} (additional cost)"
+    else:
+        delta_color = "green"
+        impact_label = f"€{budget_impact:,.0f} (savings)"
+    
+    fig = go.Figure(go.Indicator(
+        mode="gauge+number",
+        value=abs(budget_impact),
+        title={"text": f"💰 Budget Impact ({component_name})"},
+        domain={"x": [0, 1], "y": [0, 1]},
+        gauge={
+            "axis": {"range": [None, abs(budget_impact) * 1.2]},
+            "bar": {"color": delta_color},
+            "steps": [
+                {"range": [0, abs(budget_impact) * 0.3], "color": "lightgray"},
+                {"range": [abs(budget_impact) * 0.3, abs(budget_impact) * 0.7], "color": "gray"}
+            ],
+            "threshold": {
+                "line": {"color": "red", "width": 4},
+                "thickness": 0.75,
+                "value": abs(budget_impact) * 0.9
+            }
+        },
+    ))
+    
+    fig.add_annotation(
+        text=impact_label,
+        xref="paper",
+        yref="paper",
+        x=0.5,
+        y=0.3,
+        showarrow=False,
+        font=dict(size=12, color=delta_color)
+    )
+    
+    fig.update_layout(height=350)
+    return fig
+
+
+def create_risk_gauge_chart(risk_increase: float, component_name: str) -> go.Figure:
+    """Create gauge chart for risk level."""
+    
+    # Determine color based on risk
+    if risk_increase < 20:
+        color = "green"
+        risk_level = "LOW"
+    elif risk_increase < 50:
+        color = "yellow"
+        risk_level = "MEDIUM"
+    elif risk_increase < 80:
+        color = "orange"
+        risk_level = "HIGH"
+    else:
+        color = "red"
+        risk_level = "CRITICAL"
+    
+    fig = go.Figure(go.Indicator(
+        mode="gauge+number",
+        value=risk_increase,
+        title={"text": f"⚠️ Risk Increase ({component_name})"},
+        domain={"x": [0, 1], "y": [0, 1]},
+        gauge={
+            "axis": {"range": [0, 100]},
+            "bar": {"color": color},
+            "steps": [
+                {"range": [0, 25], "color": "#90EE90"},
+                {"range": [25, 50], "color": "#FFD700"},
+                {"range": [50, 75], "color": "#FFA500"},
+                {"range": [75, 100], "color": "#FF6B6B"}
+            ],
+            "threshold": {
+                "line": {"color": "darkred", "width": 4},
+                "thickness": 0.75,
+                "value": 90
+            }
+        },
+        number={"valueformat": ".0f"},
+    ))
+    
+    fig.add_annotation(
+        text=f"{risk_level}",
+        xref="paper",
+        yref="paper",
+        x=0.5,
+        y=0.3,
+        showarrow=False,
+        font=dict(size=16, color=color)
+    )
+    
+    fig.update_layout(height=350)
+    return fig
+
+
+def create_confidence_gauge_chart(confidence_score: float) -> go.Figure:
+    """Create gauge chart for AURORA confidence score."""
+    
+    if confidence_score >= 80:
+        color = "green"
+        level = "HIGH"
+    elif confidence_score >= 60:
+        color = "yellow"
+        level = "MEDIUM"
+    else:
+        color = "orange"
+        level = "LOW"
+    
+    fig = go.Figure(go.Indicator(
+        mode="gauge+number",
+        value=confidence_score,
+        title={"text": "🤖 AURORA Confidence"},
+        domain={"x": [0, 1], "y": [0, 1]},
+        gauge={
+            "axis": {"range": [0, 100]},
+            "bar": {"color": color},
+            "steps": [
+                {"range": [0, 40], "color": "#FFE0E0"},
+                {"range": [40, 70], "color": "#FFF8DC"},
+                {"range": [70, 100], "color": "#E0FFE0"}
+            ]
+        },
+    ))
+    
+    fig.add_annotation(
+        text=f"({level})",
+        xref="paper",
+        yref="paper",
+        x=0.5,
+        y=0.3,
+        showarrow=False,
+        font=dict(size=14, color=color)
+    )
+    
+    fig.update_layout(height=300)
+    return fig
+
+
+def create_hiring_priority_chart(recommendations: list[dict]) -> go.Figure:
+    """Create bar chart showing hiring priorities."""
+    
+    if not recommendations:
+        return create_empty_chart("No recommendations available")
+    
+    df = pd.DataFrame([
+        {
+            "Component": rec.get("component", "Unknown"),
+            "Priority": rec.get("priority", 0),
+            "Cost": rec.get("cost", 0),
+            "Risk Reduction": rec.get("risk_reduction", 0)
+        }
+        for rec in recommendations[:5]  # Top 5
+    ])
+    
+    fig = px.bar(
+        df,
+        x="Component",
+        y="Priority",
+        color="Risk Reduction",
+        title="📊 Hiring Priority Ranking",
+        labels={"Priority": "Priority Order", "Component": "Component"},
+        color_continuous_scale="RdYlGn"
+    )
+    
+    fig.update_layout(
+        height=350,
+        hovermode="closest",
+        xaxis_tickangle=-45
+    )
+    
+    return fig
+
+
+def create_hiring_impact_timeline(timeline_breakpoints: list[dict], component_name: str) -> go.Figure:
+    """Create timeline chart showing project phases and hiring impact."""
+    
+    if not timeline_breakpoints:
+        return create_empty_chart("No timeline data available")
+    
+    df = pd.DataFrame([
+        {
+            "Phase": bp.get("phase", "Unknown"),
+            "Days": bp.get("days", 0),
+            "Impact": bp.get("impact", "None")
+        }
+        for bp in timeline_breakpoints
+    ])
+    
+    fig = go.Figure(data=[
+        go.Bar(
+            x=df["Phase"],
+            y=df["Days"],
+            name="Duration",
+            marker_color="#00B8A9"
+        )
+    ])
+    
+    fig.update_layout(
+        title=f"📅 Project Timeline Impact for {component_name}",
+        xaxis_title="Project Phase",
+        yaxis_title="Days",
+        height=350,
+        hovermode="closest"
+    )
+    
+    return fig
+
+
+def create_alternatives_comparison(alternatives: list[dict]) -> go.Figure:
+    """Create comparison chart of alternative approaches."""
+    
+    if not alternatives:
+        return create_empty_chart("No alternatives available")
+    
+    # Prepare data
+    df = pd.DataFrame([
+        {
+            "Option": alt.get("option", f"Alternative {i+1}"),
+            "Timeline Impact (days)": alt.get("timeline_impact", 0),
+            "Budget (€)": alt.get("budget_impact", 0),
+            "Effectiveness (%)": alt.get("effectiveness", 0)
+        }
+        for i, alt in enumerate(alternatives[:5])
+    ])
+    
+    # Normalize for comparison
+    fig = go.Figure()
+    
+    fig.add_trace(go.Bar(
+        name="Timeline Impact",
+        x=df["Option"],
+        y=df["Timeline Impact (days)"],
+        marker_color="lightblue"
+    ))
+    
+    fig.add_trace(go.Bar(
+        name="Effectiveness (%)",
+        x=df["Option"],
+        y=df["Effectiveness (%)"],
+        marker_color="lightgreen"
+    ))
+    
+    fig.update_layout(
+        title="💡 Alternative Approaches Comparison",
+        xaxis_title="Option",
+        height=350,
+        barmode="group",
+        hovermode="closest",
+        xaxis_tickangle=-45
+    )
+    
+    return fig
+
+
+def create_risk_heatmap(components_risk_data: list[dict]) -> go.Figure:
+    """Create heatmap showing risk across components."""
+    
+    if not components_risk_data:
+        return create_empty_chart("No risk data available")
+    
+    df = pd.DataFrame(components_risk_data)
+    
+    if len(df) == 0:
+        return create_empty_chart("No components to display")
+    
+    # Create heatmap
+    risk_matrix = df.pivot_table(
+        index="component_name",
+        values="risk_score",
+        aggfunc="first"
+    ).fillna(0)
+    
+    fig = go.Figure(data=go.Heatmap(
+        z=risk_matrix.values,
+        x=["Risk Score"],
+        y=risk_matrix.index,
+        colorscale="RdYlGn_r",
+        colorbar=dict(title="Risk %")
+    ))
+    
+    fig.update_layout(
+        title="🔥 Risk Heatmap Across Components",
+        height=max(300, len(risk_matrix) * 40),
+        hovermode="closest"
+    )
+    
+    return fig
+
+
+def create_knowledge_transfer_timeline(kt_plan: list[dict]) -> go.Figure:
+    """Create timeline chart for knowledge transfer phases."""
+    
+    if not kt_plan:
+        return create_empty_chart("No KT plan available")
+    
+    df = pd.DataFrame([
+        {
+            "Phase": phase.get("phase", "Unknown"),
+            "Weeks": phase.get("weeks", 0),
+            "Completion": phase.get("weeks", 0)  # For cumulative
+        }
+        for phase in kt_plan
+    ])
+    
+    # Calculate cumulative weeks
+    df["Cumulative"] = df["Weeks"].cumsum()
+    
+    fig = go.Figure()
+    
+    fig.add_trace(go.Bar(
+        x=df["Phase"],
+        y=df["Weeks"],
+        name="Duration",
+        marker_color="#FF6B6B",
+        text=df["Weeks"],
+        textposition="auto"
+    ))
+    
+    fig.add_trace(go.Scatter(
+        x=df["Phase"],
+        y=df["Cumulative"],
+        name="Cumulative",
+        mode="lines+markers",
+        marker=dict(size=10, color="#00B8A9"),
+        line=dict(color="#00B8A9", width=2)
+    ))
+    
+    fig.update_layout(
+        title="📚 Knowledge Transfer Timeline",
+        xaxis_title="KT Phase",
+        yaxis_title="Weeks",
+        height=350,
+        hovermode="closest",
+        yaxis2=dict(
+            title="Cumulative Weeks",
+            overlaying="y",
+            side="right"
+        )
+    )
+    
+    return fig
+
+
+def create_budget_vs_impact_scatter(scenarios: list[dict]) -> go.Figure:
+    """Create scatter plot of budget vs timeline impact."""
+    
+    if not scenarios:
+        return create_empty_chart("No scenario data")
+    
+    df = pd.DataFrame([
+        {
+            "Scenario": s.get("name", f"Scenario {i+1}"),
+            "Budget Impact (€)": s.get("budget_impact", 0),
+            "Timeline Impact (days)": s.get("timeline_impact", 0),
+            "Risk": s.get("risk_increase", 0)
+        }
+        for i, s in enumerate(scenarios)
+    ])
+    
+    fig = px.scatter(
+        df,
+        x="Budget Impact (€)",
+        y="Timeline Impact (days)",
+        size="Risk",
+        color="Risk",
+        hover_name="Scenario",
+        title="💰 Budget vs Timeline Trade-off",
+        color_continuous_scale="Reds"
+    )
+    
+    fig.update_layout(
+        height=350,
+        hovermode="closest"
+    )
+    
+    return fig
+
+
+def create_empty_chart(message: str = "No data available") -> go.Figure:
+    """Create a placeholder chart with a message."""
+    
+    fig = go.Figure()
+    fig.add_annotation(
+        text=message,
+        xref="paper",
+        yref="paper",
+        x=0.5,
+        y=0.5,
+        showarrow=False,
+        font=dict(size=16, color="gray")
+    )
+    
+    fig.update_layout(
+        xaxis={"visible": False},
+        yaxis={"visible": False},
+        height=300
+    )
+    
+    return fig
diff --git a/pages/Scenario_Analysis.py b/pages/Scenario_Analysis.py
new file mode 100644
index 0000000..5a0e4f0
--- /dev/null
+++ b/pages/Scenario_Analysis.py
@@ -0,0 +1,983 @@
+import streamlit as st
+import pandas as pd
+from datetime import datetime, timedelta
+import json
+import os
+from pathlib import Path
+from dotenv import load_dotenv
+
+from database.session_store import ensure_session_state
+from logic.scenario_engine import AurorAI
+from logic.team_service import build_team_dataframe
+from logic.visualization_service import (
+    create_timeline_impact_chart,
+    create_budget_impact_chart,
+    create_risk_gauge_chart,
+    create_confidence_gauge_chart,
+    create_alternatives_comparison,
+)
+from ui.theme import load_theme, render_sidebar_navigation
+
+# Load environment variables from .env file
+env_path = Path(__file__).parent.parent / ".env"
+load_dotenv(dotenv_path=env_path)
+
+
+st.set_page_config(
+    page_title="🤖 AURORA",
+    page_icon="🤖",
+    layout="wide"
+)
+
+ensure_session_state()
+load_theme()
+render_sidebar_navigation()
+
+st.title("🤖 AURORA - Scenario Simulator")
+st.markdown("Use AI to predict impact of your workforce decisions")
+st.markdown("---")
+
+# Initialize session state
+st.session_state.setdefault("scenario_results", None)
+
+# Check for API key
+api_key = st.session_state.get("groq_api_key")
+if not api_key:
+    api_key = None  # Will use environment variable
+
+# Try to initialize simulator
+try:
+    aurora = AurorAI(api_key=api_key)
+    api_ready = True
+except ValueError as e:
+    api_ready = False
+    api_error = str(e)
+
+if not api_ready:
+    st.error(f"⚠️ AI Service Error: {api_error}")
+    st.info(
+        """
+        To use scenario simulations, you need a FREE Groq API key:
+        1. Set environment variable: `GROQ_API_KEY=gsk_...`
+        2. Or enter your API key in the sidebar below
+        
+        Get your **FREE** API key at: https://console.groq.com/
+        
+        """
+    )
+    
+    with st.expander("💡 Enter API Key Manually"):
+        input_key = st.text_input(
+            "Groq API Key",
+            type="password",
+            help="Your key will only be used for this session"
+        )
+        if input_key:
+            st.session_state.groq_api_key = input_key
+            st.info("✅ API key set for this session. Refresh the page to use it.")
+
+if api_ready:
+    # Create tabs for different modes
+    tab1, tab2 = st.tabs([
+        "📋 Predefined Scenarios",
+        "🤔 Ask AURORA Anything"
+    ])
+    
+    # ==================== TAB 1: PREDEFINED SCENARIOS ====================
+    with tab1:
+        # Main scenario selection
+        scenario_type = st.selectbox(
+            "📊 What scenario do you want to explore?",
+            [
+                "--- Select a scenario ---",
+                "Hiring Impact: Delay hiring for a component",
+                "Employee Impact: Add a new hire",
+                "Component Risk: Assess risk for a component",
+                "Hiring Priority: Where should we hire first?",
+                "Knowledge Transfer: Will KT succeed?",
+            ]
+        )
+
+        st.markdown("---")
+
+    # ===== SCENARIO 1: HIRING DELAY =====
+    if scenario_type == "Hiring Impact: Delay hiring for a component":
+        st.markdown("### 📅 Hiring Delay Impact Simulator")
+        st.markdown(
+            "Predict what happens if you delay hiring for a critical component"
+        )
+
+        df_team = build_team_dataframe(st.session_state.team_data)
+        components_list = [
+            c.get("component_name")
+            for c in st.session_state.get("components_data", [])
+            if c.get("component_name")
+        ]
+
+        col1, col2 = st.columns(2)
+
+        with col1:
+            selected_component = st.selectbox(
+                "Component to delay hiring for",
+                components_list or ["No components found"]
+            )
+
+            delay_days = st.slider(
+                "Hiring delay (days)",
+                min_value=0,
+                max_value=180,
+                value=30,
+                step=15,
+                help="How many days to push back hiring start date"
+            )
+
+        with col2:
+            criticality = st.select_slider(
+                "Component criticality",
+                options=["low", "standard", "important", "critical"],
+                value="standard"
+            )
+
+            budget_remaining = st.number_input(
+                "Budget remaining (€)",
+                min_value=0,
+                value=100000,
+                step=5000
+            )
+
+        if st.button("🔮 Simulate Impact", type="primary", use_container_width=True):
+            if selected_component == "No components found":
+                st.error("Please add components first in Stammdaten Management")
+            else:
+                with st.spinner("🤔 AURORA analyzing scenario..."):
+                    # Get component details
+                    comp_data = next(
+                        (c for c in st.session_state.components_data
+                         if c.get("component_name") == selected_component),
+                        {}
+                    )
+
+                    result = aurora.simulate_hiring_delay(
+                        component_name=selected_component,
+                        delay_days=delay_days,
+                        current_staffing=len([
+                            t for t in st.session_state.team_data
+                            if selected_component in (t.get("components") or "").split(",")
+                        ]) + (1 if comp_data.get("backup_available", False) else 0),
+                        required_staffing=int(comp_data.get("required_resources", 1)) + (1 if comp_data.get("backup_available", False) else 0),
+                        component_criticality=criticality,
+                        budget_remaining_euros=budget_remaining,
+                        team_data=st.session_state.team_data,
+                        components_data=st.session_state.get("components_data", []),
+                    )
+
+                    st.session_state.scenario_results = result
+                    st.rerun()
+
+        # Display results
+        if st.session_state.scenario_results:
+            results = st.session_state.scenario_results
+
+            if "error" not in results:
+                st.success("✅ Analysis Complete")
+
+                # Display reasoning
+                if results.get("reasoning"):
+                    with st.expander("💭 AURORA Reasoning"):
+                        st.write(results["reasoning"])
+
+                # Impact metrics
+                st.markdown("### 📈 Predicted Impact")
+
+                col1, col2, col3, col4 = st.columns(4)
+
+                with col1:
+                    timeline_impact = results.get("timeline_impact_days", 0)
+                    st.metric(
+                        "Timeline Delay",
+                        f"+{timeline_impact} days",
+                        delta=f"+{timeline_impact}" if timeline_impact > 0 else "No delay",
+                        delta_color="inverse"
+                    )
+
+                with col2:
+                    budget_impact = results.get("budget_impact_euros", 0)
+                    st.metric(
+                        "Budget Impact",
+                        f"€{budget_impact:,.0f}",
+                        delta=f"€+{budget_impact:,.0f}" if budget_impact > 0 else "No cost",
+                        delta_color="inverse"
+                    )
+
+                with col3:
+                    risk_increase = results.get("risk_increase_percent", 0)
+                    st.metric(
+                        "Risk Increase",
+                        f"+{risk_increase:.0f}%",
+                        delta=f"+{risk_increase:.0f}%",
+                        delta_color="inverse"
+                    )
+
+                with col4:
+                    confidence = results.get("confidence_score", 0)
+                    st.metric(
+                        "AURORA Confidence",
+                        f"{confidence:.0f}%",
+                        help="How confident is AURORA in this prediction?"
+                    )
+
+                # Prognose visualizations
+                st.markdown("### 📊 Prognose & Visualisierungen")
+                
+                viz_col1, viz_col2 = st.columns(2)
+                
+                with viz_col1:
+                    timeline_chart = create_timeline_impact_chart(
+                        timeline_impact, 
+                        selected_component
+                    )
+                    st.plotly_chart(timeline_chart, use_container_width=True)
+                
+                with viz_col2:
+                    budget_chart = create_budget_impact_chart(
+                        budget_impact,
+                        selected_component
+                    )
+                    st.plotly_chart(budget_chart, use_container_width=True)
+                
+                viz_col3, viz_col4 = st.columns(2)
+                
+                with viz_col3:
+                    risk_chart = create_risk_gauge_chart(
+                        risk_increase,
+                        selected_component
+                    )
+                    st.plotly_chart(risk_chart, use_container_width=True)
+                
+                with viz_col4:
+                    conf_chart = create_confidence_gauge_chart(confidence)
+                    st.plotly_chart(conf_chart, use_container_width=True)
+
+                # Recommendation
+                st.markdown("### 🎯 AURORA Recommendation")
+                recommendation = results.get("recommendation", "No recommendation")
+
+                if "AVOID" in recommendation:
+                    st.error(f"❌ {recommendation}")
+                elif "RECONSIDER" in recommendation:
+                    st.warning(f"⚠️ {recommendation}")
+                else:
+                    st.info(f"✅ {recommendation}")
+
+                # Alternatives
+                if results.get("alternatives"):
+                    st.markdown("### 💡 Alternative Approaches")
+                    
+                    # Show comparison chart
+                    alt_chart = create_alternatives_comparison(results["alternatives"])
+                    st.plotly_chart(alt_chart, use_container_width=True)
+
+                    for i, alt in enumerate(results["alternatives"], 1):
+                        with st.expander(f"Option {i}: {alt.get('option', 'Alternative')}"):
+                            col1, col2, col3 = st.columns(3)
+
+                            with col1:
+                                st.metric(
+                                    "Timeline Impact",
+                                    f"{alt.get('timeline_impact', 0)} days"
+                                )
+
+                            with col2:
+                                st.metric(
+                                    "Budget Cost",
+                                    f"€{alt.get('budget_impact', 0):,.0f}"
+                                )
+
+                            with col3:
+                                st.metric(
+                                    "Effectiveness",
+                                    f"{alt.get('effectiveness', 0)}%"
+                                )
+
+                            if alt.get("pros"):
+                                st.write(f"**Pros:** {alt['pros']}")
+                            if alt.get("cons"):
+                                st.write(f"**Cons:** {alt['cons']}")
+
+            else:
+                st.error(f"❌ Error: {results.get('error')}")
+                st.info("Please check your API key and try again")
+
+    # ===== SCENARIO 2: EMPLOYEE IMPACT =====
+    elif scenario_type == "Employee Impact: Add a new hire":
+        st.markdown("### 👤 New Employee Impact Simulator")
+        st.markdown(
+            "Predict the impact of adding a new employee to your team"
+        )
+
+        col1, col2 = st.columns(2)
+
+        with col1:
+            emp_name = st.text_input("New employee name", value="New Hire")
+            emp_role = st.text_input("Role/Position", value="Developer")
+
+        with col2:
+            emp_level = st.select_slider(
+                "Experience level",
+                options=["junior", "mid", "senior"],
+                value="mid"
+            )
+            start_date = st.date_input("Start date", value=datetime.now())
+
+        components_list = [
+            c.get("component_name")
+            for c in st.session_state.get("components_data", [])
+            if c.get("component_name")
+        ]
+
+        components_assigned = st.multiselect(
+            "Assign to components",
+            components_list or ["No components"],
+            help="Which components will this person work on?"
+        )
+
+        col1, col2 = st.columns(2)
+
+        with col1:
+            monthly_cost = st.number_input(
+                "Monthly salary (€)",
+                min_value=1000,
+                value=5000,
+                step=500
+            )
+
+        with col2:
+            job_impact = st.text_input(
+                "Expected impact (optional)",
+                value="Will fill staffing gap",
+                help="Brief description of why we're hiring this role"
+            )
+
+        if st.button("🔮 Simulate Impact", type="primary", use_container_width=True):
+            if not components_assigned or components_assigned[0] == "No components":
+                st.error("Please assign the employee to at least one component")
+            else:
+                with st.spinner("🤔 AURORA analyzing impact..."):
+                    result = aurora.simulate_employee_addition(
+                        employee_name=emp_name,
+                        employee_role=emp_role,
+                        employee_level=emp_level,
+                        components_assigned=components_assigned,
+                        start_date=start_date.isoformat(),
+                        budget_impact_monthly_euros=monthly_cost,
+                        team_data=st.session_state.team_data,
+                        components_data=st.session_state.get("components_data", []),
+                    )
+
+                    st.session_state.scenario_results = result
+                    st.rerun()
+
+        if st.session_state.scenario_results:
+            results = st.session_state.scenario_results
+
+            if "error" not in results:
+                st.success("✅ Analysis Complete")
+
+                col1, col2, col3, col4 = st.columns(4)
+
+                with col1:
+                    timeline_impact = results.get("timeline_impact_days", 0)
+                    st.metric(
+                        "Timeline Impact",
+                        f"{timeline_impact:+.0f} days",
+                        help="Positive = improves timeline"
+                    )
+
+                with col2:
+                    budget_impact = results.get("budget_impact_euros", 0)
+                    st.metric("Total Cost", f"€{budget_impact:,.0f}")
+
+                with col3:
+                    risk_decrease = results.get("risk_decrease_percent", 0)
+                    st.metric(
+                        "Risk Reduction",
+                        f"-{risk_decrease:.0f}%",
+                        help="Lower is better"
+                    )
+
+                with col4:
+                    confidence = results.get("confidence_score", 0)
+                    st.metric("AURORA Confidence", f"{confidence:.0f}%")
+
+                # Recommendation
+                st.markdown("### 🎯 AURORA Recommendation")
+                recommendation = results.get("recommendation", "No recommendation")
+
+                if "HIRE" in recommendation:
+                    st.success(f"✅ {recommendation}")
+                elif "CONDITIONAL" in recommendation:
+                    st.warning(f"🟡 {recommendation}")
+                else:
+                    st.info(f"ℹ️ {recommendation}")
+
+                # Knockon effects
+                if results.get("knock_on_effects"):
+                    st.markdown("### ⚡ Knock-On Effects")
+                    for effect in results["knock_on_effects"]:
+                        st.write(f"• {effect}")
+
+                # Alternatives
+                if results.get("alternatives"):
+                    st.markdown("### 💡 Alternative Approaches")
+
+                    for i, alt in enumerate(results["alternatives"], 1):
+                        with st.expander(f"Option {i}: {alt.get('option', 'Alternative')}"):
+                            st.write(f"**Pros:** {alt.get('pros', 'N/A')}")
+                            st.write(f"**Cons:** {alt.get('cons', 'N/A')}")
+                            st.write(f"**Cost:** €{alt.get('cost', 0):,.0f}")
+
+            else:
+                st.error(f"❌ Error: {results.get('error')}")
+
+    # ===== SCENARIO 3: COMPONENT RISK =====
+    elif scenario_type == "Component Risk: Assess risk for a component":
+        st.markdown("### 🚨 Component Risk Assessment")
+        st.markdown("Analyze current risk level for a component")
+
+        components_list = [
+            c.get("component_name")
+            for c in st.session_state.get("components_data", [])
+            if c.get("component_name")
+        ]
+
+        selected_component = st.selectbox(
+            "Select component to analyze",
+            components_list or ["No components found"]
+        )
+
+        if st.button("🔍 Analyze Risk", type="primary", use_container_width=True):
+            if selected_component == "No components found":
+                st.error("Please add components first")
+            else:
+                with st.spinner("🤔 AURORA analyzing risk..."):
+                    comp_data = next(
+                        (c for c in st.session_state.components_data
+                         if c.get("component_name") == selected_component),
+                        {}
+                    )
+
+                    result = aurora.analyze_component_risk(
+                        component_name=selected_component,
+                        current_staffing=len([
+                            t for t in st.session_state.team_data
+                            if selected_component in (t.get("components") or "").split(",")
+                        ]) + (1 if comp_data.get("backup_available", False) else 0),
+                        required_staffing=int(comp_data.get("required_resources", 1)) + (1 if comp_data.get("backup_available", False) else 0),
+                        responsible_persons=comp_data.get("responsible_persons", []),
+                        knowledge_transfer_status=comp_data.get(
+                            "knowledge_transfer_status", "Unknown"
+                        ),
+                        components_data=st.session_state.get("components_data", []),
+                        team_data=st.session_state.team_data,
+                    )
+
+                    st.session_state.scenario_results = result
+                    st.rerun()
+
+        if st.session_state.scenario_results:
+            results = st.session_state.scenario_results
+
+            if "error" not in results:
+                # Risk level indicator
+                risk_score = results.get("risk_score", 50)
+                risk_level = results.get("risk_level", "MEDIUM")
+
+                col1, col2, col3 = st.columns(3)
+
+                with col1:
+                    if risk_score < 30:
+                        st.success(f"✅ Risk Level: {risk_level} ({risk_score}/100)")
+                    elif risk_score < 60:
+                        st.warning(f"🟡 Risk Level: {risk_level} ({risk_score}/100)")
+                    else:
+                        st.error(f"🔴 Risk Level: {risk_level} ({risk_score}/100)")
+
+                with col2:
+                    single_pof = results.get("single_point_of_failure", False)
+                    if single_pof:
+                        st.error("⚠️ Single Point of Failure!")
+                    else:
+                        st.success("✅ Multiple resources available")
+
+                with col3:
+                    months_critical = results.get("months_until_critical", 999)
+                    if months_critical < 3:
+                        st.error(f"🔴 Critical in {months_critical} months")
+                    elif months_critical < 12:
+                        st.warning(f"🟡 Critical in {months_critical} months")
+                    else:
+                        st.success(f"✅ Stable for {months_critical} months")
+
+                # Immediate actions
+                if results.get("immediate_actions"):
+                    st.markdown("### ⚡ Immediate Actions Required")
+                    for action in results["immediate_actions"]:
+                        st.error(f"🚨 {action}")
+
+                # Priority hiring
+                if results.get("priority_hiring"):
+                    st.markdown("### 👥 Priority Hiring Needed")
+                    for hire in results["priority_hiring"]:
+                        col1, col2, col3 = st.columns(3)
+                        with col1:
+                            st.write(f"**Role:** {hire.get('role')}")
+                        with col2:
+                            st.write(f"**Urgency:** {hire.get('urgency')}")
+                        with col3:
+                            st.write(f"**Reason:** {hire.get('reason')}")
+
+                # Alternatives to hiring
+                if results.get("alternatives_to_hiring"):
+                    st.markdown("### 💡 Alternatives to Hiring")
+                    for alt in results["alternatives_to_hiring"]:
+                        st.write(
+                            f"**{alt.get('approach')}** - Cost: €{alt.get('cost', 0):,.0f}, "
+                            f"Effectiveness: {alt.get('effectiveness', 0)}%"
+                        )
+
+            else:
+                st.error(f"❌ Error: {results.get('error')}")
+
+    # ===== SCENARIO 4: HIRING PRIORITY =====
+    elif scenario_type == "Hiring Priority: Where should we hire first?":
+        st.markdown("### 🎯 Hiring Priority Optimization")
+        st.markdown(
+            "AI-powered recommendation for optimal hiring sequence given your constraints"
+        )
+
+        col1, col2 = st.columns(2)
+
+        with col1:
+            available_budget = st.number_input(
+                "Available hiring budget (€)",
+                min_value=50000,
+                value=200000,
+                step=10000
+            )
+
+        with col2:
+            max_hires = st.number_input(
+                "Maximum hires allowed",
+                min_value=1,
+                value=3,
+                step=1
+            )
+
+        st.info(
+            f"💡 Finding optimal way to hire {max_hires} people with €{available_budget:,} "
+            "to minimize risk and maximize ROI"
+        )
+
+        if st.button("🔮 Get Recommendations", type="primary", use_container_width=True):
+            with st.spinner("🤔 AI optimizing hiring sequence..."):
+                result = aurora.recommend_hiring_priority(
+                    available_budget_euros=available_budget,
+                    max_hires=max_hires,
+                    components_data=st.session_state.get("components_data", []),
+                    team_data=st.session_state.team_data,
+                )
+
+                st.session_state.scenario_results = result
+                st.rerun()
+
+        if st.session_state.scenario_results:
+            results = st.session_state.scenario_results
+
+            if "error" not in results:
+                st.success("✅ Optimization Complete")
+
+                st.markdown("### 📋 Recommended Hiring Sequence")
+                st.write(f"**Key Reasoning:** {results.get('why_this_sequence', 'N/A')}")
+                st.metric("Total Cost", f"€{results.get('total_cost', 0):,.0f}")
+
+                for i, hire in enumerate(results.get("recommended_sequence", []), 1):
+                    with st.expander(
+                        f"Priority {i}: {hire.get('component')} - {hire.get('role')}",
+                        expanded=(i == 1)
+                    ):
+                        col1, col2, col3 = st.columns(3)
+
+                        with col1:
+                            st.metric(
+                                "Hire Count",
+                                hire.get("hire_count"),
+                                help="Number of people to hire"
+                            )
+                            st.metric(
+                                "Level",
+                                hire.get("level").capitalize()
+                            )
+
+                        with col2:
+                            st.metric(
+                                "Monthly Cost",
+                                f"€{hire.get('cost', 0):,.0f}",
+                                help="Per person salary"
+                            )
+                            st.metric(
+                                "Risk Reduction",
+                                f"{hire.get('risk_reduction', 0)}%"
+                            )
+
+                        with col3:
+                            st.metric(
+                                "Timeline Impact",
+                                hire.get("timeline_impact", "TBD")
+                            )
+
+                        st.write(f"**Rationale:** {hire.get('rationale', 'N/A')}")
+
+                # Risks if not followed
+                if results.get("risks_if_not_followed"):
+                    st.markdown("### ⚠️ Risks If Not Followed")
+                    for risk in results["risks_if_not_followed"]:
+                        st.warning(f"• {risk}")
+
+            else:
+                st.error(f"❌ Error: {results.get('error')}")
+
+    # ===== SCENARIO 5: KNOWLEDGE TRANSFER =====
+    elif scenario_type == "Knowledge Transfer: Will KT succeed?":
+        st.markdown("### 📚 Knowledge Transfer Success Prediction")
+        st.markdown("Predict success probability of knowledge transfer before someone leaves")
+
+        df_team = build_team_dataframe(st.session_state.team_data)
+
+        if df_team.empty:
+            st.error("No team members found")
+        else:
+            # Get people leaving soon
+            departing = df_team[df_team["days_until_exit"] < 365].sort_values(
+                "days_until_exit"
+            )
+
+            if departing.empty:
+                st.info("No team members with planned exits found")
+            else:
+                departing_person = st.selectbox(
+                    "Person leaving",
+                    departing["name"].tolist(),
+                    help="Select the person whose knowledge needs to be transferred"
+                )
+
+                departing_data = departing[departing["name"] == departing_person].iloc[0]
+
+                col1, col2 = st.columns(2)
+
+                with col1:
+                    kt_weeks = st.slider(
+                        "Knowledge transfer duration (weeks)",
+                        min_value=2,
+                        max_value=24,
+                        value=8
+                    )
+
+                with col2:
+                    replacement_assigned = st.checkbox(
+                        "Replacement employee already assigned?"
+                    )
+
+                if replacement_assigned:
+                    remaining_team = [
+                        t for t in df_team["name"]
+                        if t != departing_person
+                    ]
+                    replacement_person = st.selectbox(
+                        "Replacement person",
+                        remaining_team
+                    )
+                else:
+                    replacement_person = None
+
+                st.info(
+                    f"Days until {departing_person} leaves: "
+                    f"{int(departing_data['days_until_exit'])} days"
+                )
+
+                if st.button("🔮 Analyze KT Success", type="primary", use_container_width=True):
+                    with st.spinner("🤔 AURORA analyzing KT scenario..."):
+                        departing_dict = {
+                            "name": departing_person,
+                            "role": departing_data["role"],
+                        }
+
+                        replacement_dict = None
+                        if replacement_person:
+                            replacement_data = df_team[
+                                df_team["name"] == replacement_person
+                            ].iloc[0]
+                            replacement_dict = {
+                                "name": replacement_person,
+                                "role": replacement_data["role"],
+                            }
+
+                        result = aurora.predict_kt_success(
+                            component_name=departing_data.get("components", "Unknown"),
+                            departing_person=departing_dict,
+                            replacement_person=replacement_dict,
+                            planned_kt_weeks=kt_weeks,
+                            team_data=st.session_state.team_data,
+                            components_data=st.session_state.get("components_data", []),
+                        )
+
+                        st.session_state.scenario_results = result
+                        st.rerun()
+
+                if st.session_state.scenario_results:
+                    results = st.session_state.scenario_results
+
+                    if "error" not in results:
+                        success_prob = results.get("success_probability", 50)
+
+                        col1, col2, col3 = st.columns(3)
+
+                        with col1:
+                            if success_prob > 80:
+                                st.success(f"✅ Success Probability: {success_prob}%")
+                            elif success_prob > 60:
+                                st.warning(f"🟡 Success Probability: {success_prob}%")
+                            else:
+                                st.error(f"🔴 Success Probability: {success_prob}%")
+
+                        with col2:
+                            risk_level = results.get("risk_level", "UNKNOWN")
+                            st.write(f"**Risk Level:** {risk_level}")
+
+                        with col3:
+                            budget_for_kt = results.get("budget_for_kt", 0)
+                            st.metric("Recommended KT Budget", f"€{budget_for_kt:,.0f}")
+
+                        # Loss assessment
+                        st.markdown("### 📊 Loss Assessment")
+                        st.write(results.get("loss_assessment", "N/A"))
+
+                        # KT Plan phases
+                        if results.get("kt_plan"):
+                            st.markdown("### 📋 Recommended KT Plan")
+
+                            for phase in results["kt_plan"]:
+                                with st.expander(
+                                    f"{phase.get('phase')} ({phase.get('weeks')} weeks)",
+                                    expanded=True
+                                ):
+                                    st.write("**Activities:**")
+                                    for activity in phase.get("activities", []):
+                                        st.write(f"• {activity}")
+
+                                    if phase.get("critical_tasks"):
+                                        st.write("**Critical Tasks:**")
+                                        for task in phase["critical_tasks"]:
+                                            st.write(f"✓ {task}")
+
+                                    if phase.get("success_metrics"):
+                                        st.write("**Success Metrics:**")
+                                        for metric in phase["success_metrics"]:
+                                            st.write(f"📊 {metric}")
+
+                        # Contingency
+                        st.markdown("### 🆘 If KT Fails")
+                        contingency = results.get("contingency_plan", "No contingency available")
+                        st.error(contingency)
+
+                    else:
+                        st.error(f"❌ Error: {results.get('error')}")
+    
+    # ==================== TAB 2: CUSTOM QUERY ====================
+    with tab2:
+        st.markdown("### 🤔 Ask AURORA Anything")
+        st.markdown(
+            "Ask complex workforce questions and get AI-powered analysis. "
+            "No predefined scenarios needed!"
+        )
+        
+        st.markdown("---")
+        
+        # Analysis type selection
+        col1, col2 = st.columns(2)
+        with col1:
+            analysis_type = st.selectbox(
+                "Analysis Type",
+                [
+                    "standard: Direct answer to your question",
+                    "comparative: Compare multiple options",
+                    "sensitivity: Explore parameter ranges",
+                    "hypothesis: Validate a theory",
+                ],
+                help="Choose how AURORA should analyze your question"
+            )
+            # Extract just the mode name
+            mode = analysis_type.split(":")[0]
+        
+        with col2:
+            include_team = st.checkbox("Include team data", value=True)
+            include_components = st.checkbox("Include projects/components", value=True)
+            include_budget = st.checkbox("Include budget info", value=True)
+        
+        st.markdown("---")
+        
+        # Question input
+        st.markdown("#### 📝 Your Question")
+        user_question = st.text_area(
+            "What do you want to know about your workforce?",
+            placeholder="Examples:\n- Can we deliver with 20% fewer people?\n- What if we delay hiring for 3 months?\n- Should we hire 2 juniors or 1 senior?\n- What's the impact of losing our lead architect?",
+            height=100,
+            label_visibility="collapsed"
+        )
+        
+        # Prepare context data
+        context_data_prepared = {
+            "team": st.session_state.team_data if include_team else None,
+            "components": st.session_state.get("components_data") if include_components else None,
+            "budget": {
+                "total_budget_euros": 500000,  # Example - you might get from db
+                "spent_euros": 250000,
+            } if include_budget else None,
+        }
+        
+        # Ask button
+        if st.button("🚀 Get AURORA Analysis", type="primary", use_container_width=True):
+            if not user_question.strip():
+                st.error("❌ Please enter a question")
+            else:
+                with st.spinner(f"🤔 AURORA analyzing... ({mode} mode)"):
+                    result = aurora.ask_custom_question(
+                        question=user_question,
+                        team_data=context_data_prepared["team"],
+                        components_data=context_data_prepared["components"],
+                        budget_data=context_data_prepared["budget"],
+                        analysis_type=mode,
+                    )
+                    
+                    st.session_state.scenario_results = result
+                    st.rerun()
+        
+        # Display custom query results
+        if st.session_state.scenario_results and st.session_state.scenario_results.get("analysis_type") == mode:
+            result = st.session_state.scenario_results
+            
+            if "error" not in result:
+                st.success("✅ AURORA Analysis Complete")
+                st.markdown("---")
+                
+                # Main answer
+                st.markdown("### 📌 AURORA's Answer")
+                st.info(result.get("answer", "Analysis complete"))
+                
+                # Display reasoning  
+                if result.get("reasoning"):
+                    st.markdown("### 💭 Reasoning")
+                    st.write(result["reasoning"])
+                
+                # Mode-specific fields
+                if result.get("recommendation"):
+                    st.markdown("### 💡 Recommendation")
+                    st.success(result["recommendation"])
+                
+                if result.get("risk"):
+                    st.markdown("### ⚠️ Key Risks")
+                    st.warning(result["risk"])
+                
+                if result.get("timeline"):
+                    st.markdown("### ⏱️ Timeline")
+                    st.info(result["timeline"])
+                
+                # For comparative mode
+                if result.get("option_a"):
+                    st.markdown("### ⚖️ Options Comparison")
+                    
+                    col1, col2 = st.columns(2)
+                    with col1:
+                        st.markdown(f"#### ✅ {result.get('option_a', 'Option A')}")
+                        st.write(f"**Pros:** {result.get('option_a_pros', 'N/A')}")
+                        st.write(f"**Cons:** {result.get('option_a_cons', 'N/A')}")
+                    
+                    with col2:
+                        st.markdown(f"#### ✅ {result.get('option_b', 'Option B')}")
+                        st.write(f"**Pros:** {result.get('option_b_pros', 'N/A')}")
+                        st.write(f"**Cons:** {result.get('option_b_cons', 'N/A')}")
+                    
+                    if result.get("timeline_impact"):
+                        st.write(f"**Timeline Impact:** {result['timeline_impact']}")
+                    if result.get("budget_impact"):
+                        st.write(f"**Budget Impact:** {result['budget_impact']}")
+                
+                # For sensitivity mode
+                if result.get("best_case"):
+                    st.markdown("### 📊 Sensitivity Analysis")
+                    
+                    col1, col2, col3 = st.columns(3)
+                    with col1:
+                        st.success(f"**Best Case**\n{result.get('best_case', 'N/A')}")
+                        if result.get("best_case_conditions"):
+                            st.caption(f"When: {result['best_case_conditions']}")
+                    
+                    with col2:
+                        st.info(f"**Base Case**\n{result.get('base_case', 'N/A')}")
+                    
+                    with col3:
+                        st.error(f"**Worst Case**\n{result.get('worst_case', 'N/A')}")
+                        if result.get("worst_case_conditions"):
+                            st.caption(f"When: {result['worst_case_conditions']}")
+                    
+                    if result.get("most_critical_variable"):
+                        st.warning(f"**Most Critical:** {result['most_critical_variable']} - {result.get('why_critical', '')}")
+                
+                # For hypothesis mode
+                if result.get("is_likely") is not None:
+                    st.markdown("### 🔬 Hypothesis Analysis")
+                    
+                    is_likely = result.get("is_likely", False)
+                    if is_likely:
+                        st.success("### ✅ Hypothesis is LIKELY TRUE")
+                    else:
+                        st.error("### ❌ Hypothesis is UNLIKELY")
+                    
+                    col1, col2 = st.columns(2)
+                    with col1:
+                        st.markdown("**Supporting Evidence:**")
+                        st.write(result.get("supporting_evidence", "N/A"))
+                    
+                    with col2:
+                        st.markdown("**Contradicting Evidence:**")
+                        st.write(result.get("contradicting_evidence", "N/A"))
+                    
+                    if result.get("conditions_needed"):
+                        st.markdown("**Conditions Needed:**")
+                        st.write(result["conditions_needed"])
+                    
+                    if result.get("key_risks"):
+                        st.markdown("**Key Risks:**")
+                        st.warning(result["key_risks"])
+                
+                # Confidence score (shown for all modes)
+                st.markdown("---")
+                confidence = result.get("confidence_score", 0)
+                st.metric("AURORA Confidence", f"{confidence}%")
+                
+                # Show warning if there was a parse issue
+                if result.get("parse_error"):
+                    st.warning(f"⚠️ Response formatting issue: {result.get('warning', 'Response was parsed differently than expected.')}")
+            
+            elif result.get("parse_error"):
+                # Fallback display for parse errors
+                st.warning("⚠️ Response formatting issue")
+                st.write(result.get("answer", "AURORA had trouble formatting its response."))
+                if result.get("full_response"):
+                    with st.expander("📋 Raw response"):
+                        st.code(result["full_response"])
+            
+            else:
+                st.error(f"❌ Error: {result.get('error')}")
+
+else:
+    st.info("⚠️ Waiting for API configuration...")
diff --git a/pages/Stammdaten_Management.py b/pages/Stammdaten_Management.py
index 9ff4eb2..0259404 100644
--- a/pages/Stammdaten_Management.py
+++ b/pages/Stammdaten_Management.py
@@ -31,6 +31,7 @@
 load_theme()
 render_sidebar_navigation()
 st.session_state.setdefault("editing_index", None)
+st.session_state.setdefault("component_editing_index", None)
 
 
 def parse_component_names(value):
@@ -42,6 +43,12 @@ def parse_component_names(value):
     return [str(item).strip() for item in raw_items if str(item).strip()]
 
 
+def required_with_backup(component: dict) -> int:
+    """Return required headcount including backup coverage if enabled."""
+    base_required = int(component.get("required_resources", 1) or 1)
+    return base_required + 1 if component.get("backup_available", False) else base_required
+
+
 # ============= BULK IMPORT HELPER FUNCTIONS =============
 
 def create_employee_template():
@@ -303,7 +310,7 @@ def sync_master_data_to_legacy_state():
         responsible_people = parse_component_names(component.get("responsible_persons", []))
         component_map[component_name] = responsible_people
         component_products[component_name] = component.get("product_name", "Unknown")
-        component_requirements[component_name] = int(component.get("required_resources", 1))
+        component_requirements[component_name] = required_with_backup(component)
         component_transfer_times[component_name] = int(component.get("knowledge_transfer_time_needed", 6))
 
     st.session_state.component_map = component_map
@@ -854,6 +861,139 @@ def sync_master_data_to_legacy_state():
                 else:
                     st.error("Bitte geben Sie einen Namen ein und wählen Sie mindestens eine verantwortliche Person aus.")
 
+    st.markdown("---")
+
+    st.markdown("#### ✏️ Komponente bearbeiten")
+    component_names = [item.get("component_name") for item in st.session_state.components_data if item.get("component_name")]
+    if component_names:
+        filter_col1, filter_col2 = st.columns(2)
+        with filter_col1:
+            edit_product_filter = st.selectbox(
+                "Produkt (Filter)",
+                options=["Alle Produkte"] + product_options,
+                key="component_edit_product_filter",
+            )
+
+        filtered_components = [
+            item.get("component_name")
+            for item in st.session_state.components_data
+            if item.get("component_name")
+            and (
+                edit_product_filter == "Alle Produkte"
+                or item.get("product_name") == edit_product_filter
+            )
+        ]
+
+        if not filtered_components:
+            st.info("Für dieses Produkt sind aktuell keine Komponenten hinterlegt.")
+            selected_component_to_edit = None
+        else:
+            with filter_col2:
+                selected_component_to_edit = st.selectbox(
+                    "Bestehende Komponente",
+                    options=filtered_components,
+                    key="component_edit_selector",
+                )
+
+        selected_component_index = next(
+            (idx for idx, comp in enumerate(st.session_state.components_data) if comp.get("component_name") == selected_component_to_edit),
+            None,
+        ) if selected_component_to_edit else None
+        if selected_component_index is not None:
+            selected_component = st.session_state.components_data[selected_component_index]
+            edit_key_suffix = f"{selected_component_index}"
+            with st.form("edit_component_form"):
+                edit_col1, edit_col2 = st.columns(2)
+                with edit_col1:
+                    edit_component_name = st.text_input(
+                        "Komponentenname",
+                        value=selected_component.get("component_name", ""),
+                        help="Wählen Sie die bestehende Komponente oben aus; hier können Sie den Namen bei Bedarf anpassen.",
+                        key=f"edit_component_name_{edit_key_suffix}",
+                    )
+                    edit_product_name = st.selectbox(
+                        "Produkt",
+                        options=product_options,
+                        index=product_options.index(selected_component.get("product_name")) if selected_component.get("product_name") in product_options else 0,
+                        key=f"edit_component_product_{edit_key_suffix}",
+                    )
+                    edit_responsible_persons = st.multiselect(
+                        "Verantwortliche Person(en)",
+                        options=[member["name"] for member in st.session_state.team_data],
+                        default=selected_component.get("responsible_persons", []),
+                        key=f"edit_component_responsible_{edit_key_suffix}",
+                    )
+                    edit_backup_available = st.checkbox(
+                        "Backup verfügbar (zählt +1 Headcount im Bedarf)",
+                        value=bool(selected_component.get("backup_available", False)),
+                        key=f"edit_component_backup_{edit_key_suffix}",
+                    )
+
+                with edit_col2:
+                    edit_complexity_score = st.slider(
+                        "Komplexität (1-10)",
+                        min_value=1,
+                        max_value=10,
+                        value=int(selected_component.get("complexity_score", 5) or 5),
+                        key=f"edit_component_complexity_{edit_key_suffix}",
+                    )
+                    edit_required_count = st.number_input(
+                        "Benötigte Anzahl Personen (permanent)",
+                        min_value=1,
+                        max_value=10,
+                        value=int(selected_component.get("required_resources", 1) or 1),
+                        key=f"edit_component_required_{edit_key_suffix}",
+                    )
+                    edit_transfer_time = st.number_input(
+                        "Wissensübergabe Zeit (Monate)",
+                        min_value=1,
+                        max_value=24,
+                        value=int(selected_component.get("knowledge_transfer_time_needed", 6) or 6),
+                        key=f"edit_component_transfer_{edit_key_suffix}",
+                    )
+                    edit_documentation_status = st.selectbox(
+                        "Dokumentationsgrad",
+                        ["Nicht bewertet", "Niedrig", "Mittel", "Gut"],
+                        index=["Nicht bewertet", "Niedrig", "Mittel", "Gut"].index(selected_component.get("documentation_status", "Nicht bewertet")) if selected_component.get("documentation_status", "Nicht bewertet") in ["Nicht bewertet", "Niedrig", "Mittel", "Gut"] else 0,
+                        key=f"edit_component_doc_{edit_key_suffix}",
+                    )
+
+                save_component_edit = st.form_submit_button("💾 Komponentenänderung speichern", use_container_width=True)
+
+                if save_component_edit:
+                    new_component_name = edit_component_name.strip()
+                    if not new_component_name or not edit_responsible_persons:
+                        st.error("Bitte Komponentenname und mindestens eine verantwortliche Person angeben.")
+                    else:
+                        old_name = selected_component.get("component_name", "")
+                        st.session_state.components_data[selected_component_index] = {
+                            "component_name": new_component_name,
+                            "product_name": edit_product_name,
+                            "responsible_persons": edit_responsible_persons,
+                            "complexity_score": int(edit_complexity_score),
+                            "knowledge_transfer_time_needed": int(edit_transfer_time),
+                            "required_resources": int(edit_required_count),
+                            "documentation_status": edit_documentation_status,
+                            "backup_available": bool(edit_backup_available),
+                        }
+
+                        for product in st.session_state.products_data:
+                            comps = parse_component_names(product.get("components", []))
+                            if old_name in comps and old_name != new_component_name:
+                                comps = [new_component_name if comp == old_name else comp for comp in comps]
+                            if product.get("product_name") == edit_product_name and new_component_name not in comps:
+                                comps.append(new_component_name)
+                            elif product.get("product_name") != edit_product_name and new_component_name in comps:
+                                comps = [comp for comp in comps if comp != new_component_name]
+                            product["components"] = sorted(set(comps))
+
+                        sync_master_data_to_legacy_state()
+                        save_component_state()
+                        st.success(f"✅ Komponente '{new_component_name}' wurde aktualisiert.")
+                        st.rerun()
+    else:
+        st.info("Noch keine Komponenten vorhanden.")
+
     st.markdown("---")
     overview_col1, overview_col2 = st.columns(2)
     with overview_col1:
@@ -872,6 +1012,82 @@ def sync_master_data_to_legacy_state():
         else:
             st.info("Noch keine Komponenten hinterlegt.")
 
+    st.markdown("---")
+    st.markdown("#### 🗑️ Produkte und Komponenten löschen")
+
+    delete_col1, delete_col2 = st.columns(2)
+
+    with delete_col1:
+        st.markdown("**Produkt löschen**")
+        product_delete_options = [p.get("product_name") for p in st.session_state.products_data if p.get("product_name")]
+        if product_delete_options:
+            product_to_delete = st.selectbox(
+                "Zu löschendes Produkt",
+                options=product_delete_options,
+                key="delete_product_selector",
+            )
+            product_delete_confirm = st.checkbox(
+                "Produkt wirklich löschen",
+                key="delete_product_confirm",
+            )
+            if st.button("🗑️ Produkt löschen", key="delete_product_btn", use_container_width=True):
+                if not product_delete_confirm:
+                    st.warning("Bitte Löschung bestätigen.")
+                else:
+                    st.session_state.products_data = [
+                        product for product in st.session_state.products_data
+                        if product.get("product_name") != product_to_delete
+                    ]
+
+                    # Keep components but detach them from deleted product.
+                    for component in st.session_state.components_data:
+                        if component.get("product_name") == product_to_delete:
+                            component["product_name"] = "Unknown"
+
+                    sync_master_data_to_legacy_state()
+                    save_component_state()
+                    st.success(f"✅ Produkt '{product_to_delete}' wurde gelöscht.")
+                    st.rerun()
+        else:
+            st.info("Keine Produkte zum Löschen vorhanden.")
+
+    with delete_col2:
+        st.markdown("**Komponente löschen**")
+        component_delete_options = [c.get("component_name") for c in st.session_state.components_data if c.get("component_name")]
+        if component_delete_options:
+            component_to_delete = st.selectbox(
+                "Zu löschende Komponente",
+                options=component_delete_options,
+                key="delete_component_selector",
+            )
+            component_delete_confirm = st.checkbox(
+                "Komponente wirklich löschen",
+                key="delete_component_confirm",
+            )
+            if st.button("🗑️ Komponente löschen", key="delete_component_btn", use_container_width=True):
+                if not component_delete_confirm:
+                    st.warning("Bitte Löschung bestätigen.")
+                else:
+                    st.session_state.components_data = [
+                        component for component in st.session_state.components_data
+                        if component.get("component_name") != component_to_delete
+                    ]
+
+                    # Remove deleted component from all product component lists.
+                    for product in st.session_state.products_data:
+                        current_components = parse_component_names(product.get("components", []))
+                        product["components"] = [
+                            component_name for component_name in current_components
+                            if component_name != component_to_delete
+                        ]
+
+                    sync_master_data_to_legacy_state()
+                    save_component_state()
+                    st.success(f"✅ Komponente '{component_to_delete}' wurde gelöscht.")
+                    st.rerun()
+        else:
+            st.info("Keine Komponenten zum Löschen vorhanden.")
+
 with admin_tab:
     st.markdown("### ⚙️ Administrative Aktionen")
     action_col1, action_col2 = st.columns(2)
diff --git a/requirements.txt b/requirements.txt
new file mode 100644
index 0000000..3693a11
--- /dev/null
+++ b/requirements.txt
@@ -0,0 +1,8 @@
+streamlit==1.28.1
+pandas==2.1.3
+plotly==5.17.0
+numpy==1.24.3
+openpyxl==3.1.2
+groq==0.9.0
+python-dotenv==1.0.0
+pytest==8.3.5
diff --git a/tests/test_allocation_service.py b/tests/test_allocation_service.py
new file mode 100644
index 0000000..80b0120
--- /dev/null
+++ b/tests/test_allocation_service.py
@@ -0,0 +1,75 @@
+from datetime import date, datetime
+
+from logic.allocation_service import (
+    check_overallocation,
+    get_next_allocation_id,
+    validate_allocation_dates,
+)
+
+
+def test_validate_allocation_dates_allows_equal_or_later_end_date() -> None:
+    start = date(2026, 1, 1)
+    same = date(2026, 1, 1)
+    later = date(2026, 2, 1)
+
+    assert validate_allocation_dates(start, same) is True
+    assert validate_allocation_dates(start, later) is True
+
+
+def test_validate_allocation_dates_rejects_earlier_end_date() -> None:
+    assert validate_allocation_dates(date(2026, 3, 1), date(2026, 2, 1)) is False
+
+
+def test_get_next_allocation_id_returns_incremented_max_id() -> None:
+    allocations = [{"id": 0}, {"id": 3}, {"id": 2}]
+    assert get_next_allocation_id(allocations) == 4
+
+
+def test_get_next_allocation_id_returns_zero_for_empty_allocations() -> None:
+    assert get_next_allocation_id([]) == 0
+
+
+def test_check_overallocation_detects_capacity_violation() -> None:
+    allocations = [
+        {
+            "employee": "Alice",
+            "start_date": date(2026, 1, 1),
+            "end_date": date(2026, 3, 1),
+            "percentage": 60,
+        }
+    ]
+
+    is_over, month, total = check_overallocation(
+        allocations=allocations,
+        employee="Alice",
+        start_month=date(2026, 2, 1),
+        end_month=date(2026, 2, 1),
+        allocation_percentage=50,
+    )
+
+    assert is_over is True
+    assert month == "2026-02"
+    assert total == 110
+
+
+def test_check_overallocation_supports_datetime_ranges_and_no_conflict() -> None:
+    allocations = [
+        {
+            "employee": "Bob",
+            "start_date": datetime(2026, 1, 15, 10, 30),
+            "end_date": datetime(2026, 2, 20, 18, 0),
+            "percentage": 40,
+        }
+    ]
+
+    is_over, month, total = check_overallocation(
+        allocations=allocations,
+        employee="Bob",
+        start_month=date(2026, 3, 1),
+        end_month=date(2026, 3, 1),
+        allocation_percentage=70,
+    )
+
+    assert is_over is False
+    assert month is None
+    assert total == 70
diff --git a/tests/test_finance_service.py b/tests/test_finance_service.py
new file mode 100644
index 0000000..1b0effc
--- /dev/null
+++ b/tests/test_finance_service.py
@@ -0,0 +1,72 @@
+import math
+
+from logic.finance_service import (
+    add_finance_columns,
+    calculate_employee_cost,
+    calculate_employee_fte,
+)
+
+
+def test_calculate_employee_cost_uses_employee_specific_hourly_model() -> None:
+    budget_data = {
+        "Intern": {"monthly_cost": 2000, "yearly_budget": 24000, "hourly_rate": 20, "weekly_hours": 35}
+    }
+    employee_settings = {"Max": {"hourly_rate": 50, "weekly_hours": 20}}
+
+    monthly, yearly = calculate_employee_cost("Max", "Intern", budget_data, employee_settings)
+
+    assert math.isclose(monthly, (20 * 50 * 52) / 12, rel_tol=1e-9)
+    assert math.isclose(yearly, 20 * 50 * 52, rel_tol=1e-9)
+
+
+def test_calculate_employee_cost_falls_back_to_budget_defaults() -> None:
+    budget_data = {
+        "Extern": {"monthly_cost": 8000, "yearly_budget": 96000, "hourly_rate": 0, "weekly_hours": 0}
+    }
+
+    monthly, yearly = calculate_employee_cost("Nina", "Extern", budget_data, {})
+
+    assert monthly == 8000
+    assert yearly == 96000
+
+
+def test_calculate_employee_fte_uses_settings_for_named_employee() -> None:
+    budget_data = {"Intern": {"weekly_hours": 35}}
+    employee_settings = {"Ivy": {"weekly_hours": 17.5}}
+
+    fte = calculate_employee_fte("Ivy", "Intern", budget_data, employee_settings)
+
+    assert math.isclose(fte, 0.5, rel_tol=1e-9)
+
+
+def test_calculate_employee_fte_for_intern_without_settings_uses_budget_hours() -> None:
+    budget_data = {"Intern": {"weekly_hours": 21}}
+
+    fte = calculate_employee_fte("Tom", "Intern", budget_data, {})
+
+    assert math.isclose(fte, 0.6, rel_tol=1e-9)
+
+
+def test_calculate_employee_fte_for_non_intern_defaults_to_one() -> None:
+    fte = calculate_employee_fte("Lea", "Lead Cost Employee (LCE)", {}, {})
+    assert fte == 1.0
+
+
+def test_add_finance_columns_enriches_dataframe_with_expected_columns() -> None:
+    team_data = [
+        {"name": "A", "employee_type": "Intern"},
+        {"name": "B", "employee_type": "Extern"},
+    ]
+    budget_data = {
+        "Intern": {"monthly_cost": 2000, "yearly_budget": 24000, "hourly_rate": 25, "weekly_hours": 35},
+        "Extern": {"monthly_cost": 9000, "yearly_budget": 108000, "hourly_rate": 0, "weekly_hours": 0},
+    }
+    employee_settings = {"A": {"hourly_rate": 30, "weekly_hours": 35}}
+
+    df = add_finance_columns(team_data, budget_data, employee_settings)
+
+    assert "Monatliche Kosten" in df.columns
+    assert "Jährliche Kosten" in df.columns
+    assert "FTE" in df.columns
+    assert len(df) == 2
+    assert df.loc[df["name"] == "A", "Monatliche Kosten"].iloc[0] > 0
diff --git a/tests/test_team_service.py b/tests/test_team_service.py
new file mode 100644
index 0000000..b5d9757
--- /dev/null
+++ b/tests/test_team_service.py
@@ -0,0 +1,98 @@
+import pandas as pd
+
+from logic.team_service import (
+    TEAM_COLUMNS,
+    build_team_dataframe,
+    calculate_kt_status_from_tenure,
+    calculate_priority_from_tenure,
+    get_kt_status_mapping,
+    update_priorities_from_tenure,
+)
+
+
+def test_get_kt_status_mapping_contains_bidirectional_values() -> None:
+    mapping = get_kt_status_mapping()
+
+    assert mapping["Nicht gestartet"] == "Not Started"
+    assert mapping["In Progress"] == "In Bearbeitung"
+
+
+def test_tenure_based_calculations_return_expected_buckets() -> None:
+    today = pd.Timestamp.today().normalize()
+
+    recent = (today - pd.Timedelta(days=30)).strftime("%Y-%m-%d")
+    medium = (today - pd.Timedelta(days=365)).strftime("%Y-%m-%d")
+    old = (today - pd.Timedelta(days=1000)).strftime("%Y-%m-%d")
+
+    assert calculate_priority_from_tenure(recent) == "High"
+    assert calculate_priority_from_tenure(medium) == "Medium"
+    assert calculate_priority_from_tenure(old) == "Low"
+
+    assert calculate_kt_status_from_tenure(recent) == "Not Started"
+    assert calculate_kt_status_from_tenure(medium) == "In Progress"
+    assert calculate_kt_status_from_tenure(old) == "Completed"
+
+
+def test_update_priorities_respects_manual_override() -> None:
+    today = pd.Timestamp.today().normalize()
+    start_recent = (today - pd.Timedelta(days=60)).strftime("%Y-%m-%d")
+    start_old = (today - pd.Timedelta(days=1000)).strftime("%Y-%m-%d")
+
+    team_data = [
+        {
+            "name": "Auto",
+            "start_date": start_recent,
+            "priority": "Low",
+            "knowledge_transfer_status": "Completed",
+            "manual_override": False,
+        },
+        {
+            "name": "Manual",
+            "start_date": start_old,
+            "priority": "Critical",
+            "knowledge_transfer_status": "Not Started",
+            "manual_override": True,
+        },
+    ]
+
+    update_priorities_from_tenure(team_data)
+
+    assert team_data[0]["priority"] == "High"
+    assert team_data[0]["knowledge_transfer_status"] == "Not Started"
+    assert team_data[1]["priority"] == "Critical"
+    assert team_data[1]["knowledge_transfer_status"] == "Not Started"
+
+
+def test_build_team_dataframe_handles_empty_input() -> None:
+    df = build_team_dataframe([])
+    assert list(df.columns) == TEAM_COLUMNS
+    assert df.empty
+
+
+def test_build_team_dataframe_adds_derived_columns_and_default_team() -> None:
+    today = pd.Timestamp.today().normalize()
+    planned_exit = (today + pd.Timedelta(days=45)).strftime("%Y-%m-%d")
+    start_date = (today - pd.Timedelta(days=400)).strftime("%Y-%m-%d")
+
+    team_data = [
+        {
+            "name": "Mia",
+            "role": "Engineer",
+            "employee_type": "Intern",
+            "components": "A",
+            "start_date": start_date,
+            "planned_exit": planned_exit,
+            "knowledge_transfer_status": "In Progress",
+            "priority": "Medium",
+            "dob": "1990-05-10",
+        }
+    ]
+
+    df = build_team_dataframe(team_data)
+
+    assert "team" in df.columns
+    assert df.loc[0, "team"] == "Unassigned"
+    assert "age" in df.columns
+    assert "days_until_exit" in df.columns
+    assert "tenure_days" in df.columns
+    assert pd.notna(df.loc[0, "days_until_exit"])
diff --git a/ui/theme.py b/ui/theme.py
index 9aeac31..2de5c99 100644
--- a/ui/theme.py
+++ b/ui/theme.py
@@ -21,6 +21,7 @@ def render_sidebar_navigation() -> None:
     render_navigation_link(st.sidebar, "pages/Stammdaten_Management.py", "Stammdaten Management", "🛠️", "Team-, Produkt- und Komponentendaten")
     render_navigation_link(st.sidebar, "pages/Projekt_Allocation.py", "Projekt-Allocation", "📅", "Kapazitäten und Allokationen")
     render_navigation_link(st.sidebar, "pages/Finanzielle_Verwaltung.py", "Finanzielle Verwaltung", "💰", "Budget und Kosten")
+    render_navigation_link(st.sidebar, "pages/Scenario_Analysis.py", "🤖 AURORA", "🤖", "AI-gestützte What-If Szenarien und Entscheidungshilfen")
     st.sidebar.markdown("---")