diff --git a/.github/cache-config.json b/.github/cache-config.json
new file mode 100644
index 0000000000..c1be3162e7
--- /dev/null
+++ b/.github/cache-config.json
@@ -0,0 +1,13 @@
+{
+    "cache": {
+      "pip": true,
+      "docker": true,
+      "node": false,
+      "actions": true
+    },
+    "optimizations": {
+      "parallel_jobs": true,
+      "skip_duplicate_actions": true,
+      "cancel_in_progress_on_new_commit": true
+    }
+  }
\ No newline at end of file
diff --git a/.github/workflows/python-ci.yml b/.github/workflows/python-ci.yml
new file mode 100644
index 0000000000..40200b5ca7
--- /dev/null
+++ b/.github/workflows/python-ci.yml
@@ -0,0 +1,65 @@
+name: CI/CD Pipeline
+
+on:
+  push:
+    branches: [ main, master ]
+    paths:
+      - 'app_python/**'
+  pull_request:
+    branches: [ main, master ]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    
+    steps:
+    - uses: actions/checkout@v4
+    
+    - name: Set up Python
+      uses: actions/setup-python@v5
+      with:
+        python-version: '3.13'
+        cache: 'pip'
+        cache-dependency-path: 'app_python/requirements.txt'
+    
+    - name: Install dependencies
+      working-directory: ./app_python
+      run: |
+        pip install -r requirements.txt
+        pip install pytest pytest-cov httpx
+        
+    - name: Test with pytest
+      working-directory: ./app_python
+      run: |
+        python -m pytest tests/ -v --cov=app --cov-report=xml
+        
+    - name: Upload coverage to Codecov
+      uses: codecov/codecov-action@v4
+      with:
+        file: ./app_python/coverage.xml
+        
+  build:
+    runs-on: ubuntu-latest
+    needs: test
+    if: github.event_name == 'push' && (github.ref == 'refs/heads/main' || github.ref == 'refs/heads/master')
+    
+    steps:
+    - uses: actions/checkout@v4
+    
+    - name: Set up Docker Buildx
+      uses: docker/setup-buildx-action@v3
+      
+    - name: Log in to Docker Hub
+      uses: docker/login-action@v3
+      with:
+        username: ${{ secrets.DOCKERHUB_USERNAME }}
+        password: ${{ secrets.DOCKERHUB_TOKEN }}
+    
+    - name: Build and push
+      uses: docker/build-push-action@v6
+      with:
+        context: ./app_python
+        push: true
+        tags: |
+          ${{ secrets.DOCKERHUB_USERNAME }}/devops-info-service:latest
+          ${{ secrets.DOCKERHUB_USERNAME }}/devops-info-service:${{ github.sha }}
\ No newline at end of file
diff --git a/.gitignore b/.gitignore
index 30d74d2584..600d2d33ba 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1 +1 @@
-test
\ No newline at end of file
+.vscode
\ No newline at end of file
diff --git a/app_python/.dockerignore b/app_python/.dockerignore
new file mode 100644
index 0000000000..5255d9cfc5
--- /dev/null
+++ b/app_python/.dockerignore
@@ -0,0 +1,78 @@
+# Python
+__pycache__/
+*.py[cod]
+*.pyo
+*.so
+*.pyd
+.Python
+
+# Virtual environments
+venv/
+env/
+ENV/
+env.bak/
+venv.bak/
+.venv/
+
+# Distribution / packaging
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+.pytest_cache/
+tests/
+
+# Logs
+*.log
+logs/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Git
+.git/
+.gitignore
+
+# Docker
+Dockerfile
+docker-compose*.yml
+
+# Documentation
+docs/
+*.md
+LICENSE
\ No newline at end of file
diff --git a/app_python/.gitignore b/app_python/.gitignore
new file mode 100644
index 0000000000..4de420a8f7
--- /dev/null
+++ b/app_python/.gitignore
@@ -0,0 +1,12 @@
+# Python
+__pycache__/
+*.py[cod]
+venv/
+*.log
+
+# IDE
+.vscode/
+.idea/
+
+# OS
+.DS_Store
\ No newline at end of file
diff --git a/app_python/.pytest.ini b/app_python/.pytest.ini
new file mode 100644
index 0000000000..1274d0ecd8
--- /dev/null
+++ b/app_python/.pytest.ini
@@ -0,0 +1,18 @@
+[pytest]
+testpaths = tests
+python_files = test_*.py
+python_classes = Test*
+python_functions = test_*
+addopts = 
+    -v
+    --tb=short
+    --strict-markers
+    --disable-warnings
+    --cov=.
+    --cov-report=term-missing
+    --cov-report=xml
+    --cov-report=html
+markers =
+    slow: marks tests as slow (deselect with '-m "not slow"')
+    integration: integration tests
+    unit: unit tests
\ No newline at end of file
diff --git a/app_python/Dockerfile b/app_python/Dockerfile
new file mode 100644
index 0000000000..52b1c3d47c
--- /dev/null
+++ b/app_python/Dockerfile
@@ -0,0 +1,53 @@
+# Build stage for Python dependencies (optional - can use for compilation if needed)
+FROM python:3.13-slim AS builder
+
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    gcc \
+    g++ \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first for better layer caching
+COPY requirements.txt .
+RUN pip install --no-cache-dir --user -r requirements.txt
+
+# Final stage
+FROM python:3.13-slim
+
+# Set environment variables
+ENV PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1 \
+    PYTHONPATH=/app \
+    PORT=5000
+
+# Create non-root user
+RUN groupadd -r appuser && useradd -r -m -g appuser appuser
+
+# Set working directory
+WORKDIR /app
+
+# Copy Python packages from builder stage
+COPY --from=builder /root/.local /home/appuser/.local
+ENV PATH=/root/.local/bin:$PATH
+
+# Copy application code
+COPY app.py .
+
+# Create directory for logs and set permissions
+RUN mkdir -p /app/logs && chown -R appuser:appuser /app
+
+# Switch to non-root user
+USER appuser
+
+# Expose application port
+EXPOSE ${PORT}
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
+    CMD python -c "import urllib.request; urllib.request.urlopen('http://localhost:${PORT}/health')" || exit 1
+
+# Command to run the application
+# CMD bash
+CMD ["python", "app.py"]
diff --git a/app_python/README.md b/app_python/README.md
new file mode 100644
index 0000000000..7cd1801c72
--- /dev/null
+++ b/app_python/README.md
@@ -0,0 +1,393 @@
+# DevOps Info Service
+
+A FastAPI-based web service providing detailed information about the service, system, and runtime environment.
+
+## Overview
+
+This service is part of the DevOps course and provides:
+- Comprehensive system information
+- Health check endpoint for monitoring
+- Runtime statistics
+- Automatic OpenAPI documentation
+
+## Prerequisites
+
+- Python 3.11 or higher
+- pip (Python package manager)
+
+## Installation
+
+1. Clone the repository:
+   ```bash
+   git clone <repository-url>
+   cd app_python
+   ```
+
+2. Create and activate virtual environment:
+   ```bash
+   python -m venv venv
+   source venv/bin/activate
+   ```
+
+3. Install dependencies:
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+## Running the Application
+
+### Basic usage:
+```bash
+python app.py
+```
+
+### With custom configuration:
+```bash
+# Custom port
+PORT=8080 python app.py
+
+# Custom host and port
+HOST=127.0.0.1 PORT=3000 python app.py
+
+# Enable debug mode
+DEBUG=true python app.py
+```
+
+### Using uvicorn directly:
+```bash
+uvicorn app:app --host 0.0.0.0 --port 5000 --reload
+```
+
+### Testing
+
+Test the endpoints using curl:
+
+```bash
+# Get service info
+curl http://localhost:5000/
+
+# Health check
+curl http://localhost:5000/health
+
+# Pretty-print JSON output
+curl http://localhost:5000/ | python -m json.tool
+```
+
+## API Endpoints
+
+### GET `/`
+Returns comprehensive service and system information.
+
+**Example Response:**
+```json
+{
+  "service": {
+    "name": "devops-info-service",
+    "version": "1.0.0",
+    "description": "DevOps course info service",
+    "framework": "FastAPI"
+  },
+  "system": {
+    "hostname": "my-laptop",
+    "platform": "Linux",
+    "platform_version": "Ubuntu 24.04",
+    "architecture": "x86_64",
+    "cpu_count": 8,
+    "python_version": "3.13.1"
+  },
+  "runtime": {
+    "uptime_seconds": 3600,
+    "uptime_human": "1 hour, 0 minutes",
+    "current_time": "2026-01-07T14:30:00.000Z",
+    "timezone": "UTC"
+  },
+  "request": {
+    "client_ip": "127.0.0.1",
+    "user_agent": "curl/7.81.0",
+    "method": "GET",
+    "path": "/"
+  },
+  "endpoints": [
+    {"path": "/", "method": "GET", "description": "Service information"},
+    {"path": "/health", "method": "GET", "description": "Health check"}
+  ]
+}
+```
+
+### GET `/health`
+Health check endpoint for monitoring and Kubernetes probes.
+
+**Example Response:**
+```json
+{
+  "status": "healthy",
+  "timestamp": "2024-01-15T14:30:00.000Z",
+  "uptime_seconds": 3600
+}
+```
+
+## Configuration
+
+The application can be configured using environment variables:
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `HOST` | `0.0.0.0` | Host to bind the server to |
+| `PORT` | `5000` | Port to listen on |
+| `DEBUG` | `False` | Enable debug mode and hot reload |
+
+## Docker Containerization
+
+This application is containerized and available on Docker Hub.
+
+### Building Locally
+
+```bash
+# Clone the repository
+git clone <repository-url>
+cd app_python
+
+# Build Docker image
+docker build -t devops-info-service:latest .
+```
+
+### Running the Container
+
+```bash
+# Basic run (maps host port 5000 to container port 5000)
+docker run -d -p 5000:5000 --name devops-app devops-info-service:latest
+
+# With custom port mapping (host:container)
+docker run -d -p 8080:5000 --name devops-app devops-info-service:latest
+
+# With environment variables
+docker run -d \
+  -p 5000:5000 \
+  -e PORT=5000 \
+  -e HOST=0.0.0.0 \
+  -e DEBUG=false \
+  --name devops-app \
+  devops-info-service:latest
+
+# Mount host directory for logs (optional)
+docker run -d \
+  -p 5000:5000 \
+  -v $(pwd)/logs:/app/logs \
+  --name devops-app \
+  devops-info-service:latest
+```
+
+### Using Docker Hub
+
+```bash
+# Pull from Docker Hub
+docker pull acecution/devops-info-service:latest
+
+# Run from Docker Hub
+docker run -d -p 5000:5000 acecution/devops-info-service:latest
+
+# Run specific version
+docker run -d -p 5000:5000 acecution/devops-info-service:v1.0.0
+```
+
+### Container Management
+
+```bash
+# List running containers
+docker ps
+
+# List all containers (including stopped)
+docker ps -a
+
+# View container logs
+docker logs devops-app
+
+# Follow logs in real-time
+docker logs -f devops-app
+
+# Execute commands inside container
+docker exec -it devops-app sh
+docker exec devops-app python -c "import fastapi; print(fastapi.__version__)"
+
+# Inspect container details
+docker inspect devops-app
+
+# Stop container
+docker stop devops-app
+
+# Remove container
+docker rm devops-app
+
+# Force remove running container
+docker rm -f devops-app
+
+# Remove image
+docker rmi devops-info-service:latest
+
+# Clean up unused resources
+docker system prune -a
+```
+
+### Image Information
+
+- **Base Image**: Python 3.13-slim
+- **Image Size**: ~123MB
+- **Non-root User**: Runs as `appuser` for security
+- **Health Checks**: Built-in health monitoring via `/health` endpoint
+- **Port**: 5000 (configurable via `PORT` environment variable)
+- **Architecture**: Multi-platform compatible (amd64, arm64)
+
+### Dockerfile Features
+
+- **Security**: Non-root user execution
+- **Optimization**: Layer caching for faster builds
+- **Minimal**: Only necessary packages installed
+- **Production-ready**: Health checks, proper logging, environment variables
+- **Reproducible**: Pinned Python version (3.13)
+
+### Docker Hub
+
+The image is available on Docker Hub: `acecution/devops-info-service`
+
+**Tags**:
+- `latest` - Most recent stable version
+- `v1.0.0` - Version 1.0.0 (semantic versioning)
+
+**Access**: 
+- **Public Repository**: https://hub.docker.com/repository/docker/acecution/devops-info-service
+- **Pull Count**: Automatically tracked by Docker Hub
+- **Build History**: View previous builds and tags
+
+### Security Features
+
+1. **Non-root User**: Container runs as unprivileged `appuser`
+2. **Minimal Base Image**: Reduced attack surface with Python slim
+3. **No Build Tools**: Production image excludes compilers and dev tools
+4. **Health Monitoring**: Built-in health checks for orchestration
+5. **Environment Segregation**: Configuration via environment variables
+6. **Immutable Infrastructure**: Container contents don't change at runtime
+
+### Development Workflow
+
+```bash
+# 1. Build and test locally
+docker build -t devops-info-service:latest .
+docker run -d -p 5000:5000 --name test devops-info-service:latest
+curl http://localhost:5000/health
+
+# 2. Tag for Docker Hub
+docker tag devops-info-service:latest acecution/devops-info-service:latest
+docker tag devops-info-service:latest acecution/devops-info-service:v1.0.0
+
+# 3. Push to registry
+docker push acecution/devops-info-service:latest
+docker push acecution/devops-info-service:v1.0.0
+
+# 4. Deploy anywhere
+docker pull acecution/devops-info-service:latest
+docker run -d -p 5000:5000 acecution/devops-info-service:latest
+```
+
+### Troubleshooting
+
+#### Container won't start
+```bash
+# Check logs
+docker logs devops-app
+
+# Check container status
+docker ps -a | grep devops-app
+
+# Run interactively to debug
+docker run -it --rm devops-info-service:latest sh
+```
+
+#### Port already in use
+```bash
+# Find what's using the port
+lsof -i :5000
+
+# Use different port
+docker run -d -p 8080:5000 --name devops-app devops-info-service:latest
+```
+
+#### Permission issues
+```bash
+# Build with --no-cache if permission issues
+docker build --no-cache -t devops-info-service:latest .
+```
+
+#### Docker Hub authentication
+```bash
+# Login to Docker Hub
+docker login
+
+# Check current auth
+docker info | grep Username
+```
+
+### Environment Variables Reference
+
+| Variable | Default | Description | Required |
+|----------|---------|-------------|----------|
+| `PORT` | `5000` | Application port | No |
+| `HOST` | `0.0.0.0` | Bind address | No |
+| `DEBUG` | `false` | Enable debug mode | No |
+| `PYTHONUNBUFFERED` | `1` | Python output unbuffered | No (set in Dockerfile) |
+
+### Example Deployment Scenarios
+
+#### Development
+```bash
+docker run -d \
+  -p 5000:5000 \
+  -e DEBUG=true \
+  --name devops-app-dev \
+  devops-info-service:latest
+```
+
+#### Production
+```bash
+docker run -d \
+  -p 80:5000 \
+  --restart unless-stopped \
+  --name devops-app-prod \
+  -e PORT=5000 \
+  -e HOST=0.0.0.0 \
+  -e DEBUG=false \
+  devops-info-service:latest
+```
+
+#### With Docker Compose
+Create `docker-compose.yml`:
+```yaml
+version: '3.8'
+services:
+  devops-app:
+    image: devops-info-service:latest
+    container_name: devops-app
+    ports:
+      - "5000:5000"
+    environment:
+      - PORT=5000
+      - HOST=0.0.0.0
+      - DEBUG=false
+    restart: unless-stopped
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:5000/health"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 10s
+```
+
+### Best Practices Implemented
+
+1. **✅ Non-root user**: Security first approach
+2. **✅ .dockerignore**: Excludes unnecessary files
+3. **✅ Layer caching**: Optimized build performance
+4. **✅ Health checks**: Container orchestration ready
+5. **✅ Environment variables**: Configurable at runtime
+6. **✅ Minimal image**: Small footprint (~123MB)
+7. **✅ Specific versions**: Reproducible builds
+8. **✅ Proper logging**: Structured application logs
diff --git a/app_python/app.py b/app_python/app.py
new file mode 100644
index 0000000000..b29786647b
--- /dev/null
+++ b/app_python/app.py
@@ -0,0 +1,155 @@
+import os
+import socket
+import platform
+import logging
+from datetime import datetime, timezone
+from typing import Dict, Any
+
+from fastapi import FastAPI, Request
+from fastapi.responses import JSONResponse
+from fastapi.middleware.cors import CORSMiddleware
+
+# Application configuration
+HOST = os.getenv("HOST", "0.0.0.0")
+PORT = int(os.getenv("PORT", "5000"))
+DEBUG = os.getenv("DEBUG", "False").lower() == "true"
+
+# Configure logging
+logging.basicConfig(
+    level=logging.DEBUG if DEBUG else logging.INFO,
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+)
+logger = logging.getLogger(__name__)
+
+# Application start time
+START_TIME = datetime.now(timezone.utc)
+
+# Create FastAPI application
+app = FastAPI(
+    title="DevOps Info Service",
+    version="1.0.0",
+    description="DevOps course information service",
+)
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+def get_system_info() -> Dict[str, Any]:
+    """Collect and return system information."""
+    return {
+        "hostname": socket.gethostname(),
+        "platform": platform.system(),
+        "platform_version": platform.version(),
+        "architecture": platform.machine(),
+        "cpu_count": os.cpu_count(),
+        "python_version": platform.python_version(),
+    }
+
+def get_uptime() -> Dict[str, Any]:
+    """Calculate application uptime."""
+    delta = datetime.now(timezone.utc) - START_TIME
+    seconds = int(delta.total_seconds())
+    hours = seconds // 3600
+    minutes = (seconds % 3600) // 60
+    
+    return {
+        "seconds": seconds,
+        "human": f"{hours} hours, {minutes} minutes"
+    }
+
+def get_request_info(request: Request) -> Dict[str, Any]:
+    """Extract request information."""
+    client_ip = request.client.host if request.client else "127.0.0.1"
+    user_agent = request.headers.get("user-agent", "Unknown")
+    
+    return {
+        "client_ip": client_ip,
+        "user_agent": user_agent,
+        "method": request.method,
+        "path": request.url.path,
+    }
+
+@app.get("/", response_model=Dict[str, Any])
+async def root(request: Request) -> Dict[str, Any]:
+    """
+    Main endpoint returning comprehensive service and system information.
+    """
+    logger.info(f"GET / requested by {request.client.host if request.client else 'unknown'}")
+    
+    return {
+        "service": {
+            "name": "devops-info-service",
+            "version": "1.0.0",
+            "description": "DevOps course info service",
+            "framework": "FastAPI",
+        },
+        "system": get_system_info(),
+        "runtime": {
+            "uptime_seconds": get_uptime()["seconds"],
+            "uptime_human": get_uptime()["human"],
+            "current_time": datetime.now(timezone.utc).isoformat(),
+            "timezone": "UTC",
+        },
+        "request": get_request_info(request),
+        "endpoints": [
+            {"path": "/", "method": "GET", "description": "Service information"},
+            {"path": "/health", "method": "GET", "description": "Health check"},
+        ],
+    }
+
+@app.get("/health", response_model=Dict[str, Any])
+async def health() -> Dict[str, Any]:
+    """
+    Health check endpoint for monitoring and Kubernetes probes.
+    """
+    return {
+        "status": "healthy",
+        "timestamp": datetime.now(timezone.utc).isoformat(),
+        "uptime_seconds": get_uptime()["seconds"],
+    }
+
+@app.exception_handler(404)
+async def not_found(request: Request, exc):
+    """Handle 404 errors."""
+    return JSONResponse(
+        status_code=404,
+        content={
+            "error": "Not Found",
+            "message": f"The requested endpoint {request.url.path} does not exist"
+        }
+    )
+
+@app.exception_handler(500)
+async def internal_error(request: Request, exc):
+    """Handle 500 errors."""
+    logger.error(f"Internal server error: {exc}")
+    return JSONResponse(
+        status_code=500,
+        content={
+            "error": "Internal Server Error",
+            "message": "An unexpected error occurred"
+        }
+    )
+
+def main():
+    """Application entry point."""
+    logger.info(f"Starting DevOps Info Service on {HOST}:{PORT}")
+    logger.info(f"Debug mode: {DEBUG}")
+    
+    import uvicorn
+    uvicorn.run(
+        "app:app",
+        host=HOST,
+        port=PORT,
+        reload=DEBUG,
+        log_level="debug" if DEBUG else "info"
+    )
+
+if __name__ == "__main__":
+    main()
\ No newline at end of file
diff --git a/app_python/docs/LAB01.md b/app_python/docs/LAB01.md
new file mode 100644
index 0000000000..7f7e14b4ae
--- /dev/null
+++ b/app_python/docs/LAB01.md
@@ -0,0 +1,308 @@
+# Lab 1 Submission
+
+## Framework Selection
+
+### Choice: FastAPI
+I selected FastAPI as the web framework for this project.
+
+### Justification:
+FastAPI offers several advantages over alternatives:
+
+1. **Performance**: Built on Starlette and Pydantic, FastAPI is one of the fastest Python frameworks available
+2. **Automatic Documentation**: Generates OpenAPI/Swagger documentation automatically
+3. **Modern Features**: Native async/await support, type hints, and dependency injection
+4. **Developer Experience**: Excellent editor support with autocompletion and validation
+5. **Standards Compliance**: Based on OpenAPI and JSON Schema standards
+
+### Comparison Table:
+
+| Feature | FastAPI | Flask | Django |
+|---------|---------|-------|--------|
+| Performance | ⭐⭐⭐⭐⭐ | ⭐⭐⭐ | ⭐⭐⭐ |
+| Learning Curve | ⭐⭐⭐ | ⭐⭐⭐⭐⭐ | ⭐⭐ |
+| Auto Documentation | ✅ | ❌ | ❌ |
+| Async Support | ✅ | Limited | ✅ |
+| Built-in Admin | ❌ | ❌ | ✅ |
+| Project Size | Micro | Micro | Full-stack |
+| Best For | APIs, Microservices | Small apps, Prototyping | Large applications |
+
+For a DevOps-focused service that needs to be lightweight, fast, and well-documented, FastAPI is the optimal choice.
+
+## Best Practices Applied
+
+### 1. Clean Code Organization
+- **File structure**: Clear separation of concerns with dedicated functions
+- **Function names**: Descriptive names like `get_system_info()`, `get_uptime()`
+- **Import grouping**: Standard library imports first, then third-party, then local
+- **Comments**: Only where necessary to explain complex logic
+- **Type hints**: All functions have return type annotations
+
+```python
+def get_system_info() -> Dict[str, Any]:
+    """Collect and return system information."""
+    return {
+        "hostname": socket.gethostname(),
+        "platform": platform.system(),
+        "platform_version": platform.version(),
+        "architecture": platform.machine(),
+        "cpu_count": os.cpu_count(),
+        "python_version": platform.python_version(),
+    }
+```
+
+### 2. Error Handling
+- Custom exception handlers for 404 and 500 errors
+- JSON responses for API consistency
+- Logging of internal errors
+
+```python
+@app.exception_handler(404)
+async def not_found(request: Request, exc):
+    return JSONResponse(
+        status_code=404,
+        content={
+            "error": "Not Found",
+            "message": f"The requested endpoint {request.url.path} does not exist"
+        }
+    )
+```
+
+### 3. Logging
+- Structured logging with timestamps and levels
+- Configurable log levels via DEBUG environment variable
+- Request logging for monitoring
+
+```python
+logging.basicConfig(
+    level=logging.DEBUG if DEBUG else logging.INFO,
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+)
+logger = logging.getLogger(__name__)
+
+# Usage in endpoints
+logger.info(f"GET / requested by {request.client.host if request.client else 'unknown'}")
+```
+
+### 4. Configuration Management
+- Environment variables for configuration
+- Sensible defaults
+- Type conversion for numeric values
+
+```python
+HOST = os.getenv("HOST", "0.0.0.0")
+PORT = int(os.getenv("PORT", "5000"))
+DEBUG = os.getenv("DEBUG", "False").lower() == "true"
+```
+
+### 5. Dependencies Management
+- Pinned versions in `requirements.txt`
+- Production-ready dependencies with performance extras
+
+```txt
+fastapi==0.115.0
+uvicorn[standard]==0.32.0
+```
+
+### 6. Git Ignore
+- Comprehensive `.gitignore` file
+- Covers Python, IDE files, logs, and OS-specific files
+
+```gitignore
+# Python
+__pycache__/
+*.py[cod]
+venv/
+
+# Logs
+*.log
+
+# IDE
+.vscode/
+.idea/
+
+# OS
+.DS_Store
+```
+
+### 7. CORS Middleware
+- Added CORS middleware for cross-origin requests
+- Configurable for different environments
+
+```python
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+```
+
+## API Documentation
+
+### Endpoints:
+
+#### GET `/`
+**Description**: Returns comprehensive service and system information
+
+**Request:**
+```bash
+curl http://localhost:5000/
+```
+
+**Response:**
+```json
+{
+  "service": {
+    "name": "devops-info-service",
+    "version": "1.0.0",
+    "description": "DevOps course info service",
+    "framework": "FastAPI"
+  },
+  "system": {
+    "hostname": "your-hostname",
+    "platform": "Linux",
+    "platform_version": "#1 SMP ...",
+    "architecture": "x86_64",
+    "cpu_count": 8,
+    "python_version": "3.11.0"
+  },
+  "runtime": {
+    "uptime_seconds": 120,
+    "uptime_human": "0 hours, 2 minutes",
+    "current_time": "2026-01-28T10:30:00.000Z",
+    "timezone": "UTC"
+  },
+  "request": {
+    "client_ip": "127.0.0.1",
+    "user_agent": "curl/7.81.0",
+    "method": "GET",
+    "path": "/"
+  },
+  "endpoints": [
+    {"path": "/", "method": "GET", "description": "Service information"},
+    {"path": "/health", "method": "GET", "description": "Health check"}
+  ]
+}
+```
+
+#### GET `/health`
+**Description**: Health check endpoint for monitoring
+
+**Request:**
+```bash
+curl http://localhost:5000/health
+```
+
+**Response:**
+```json
+{
+  "status": "healthy",
+  "timestamp": "2026-01-28T10:30:00.000Z",
+  "uptime_seconds": 120
+}
+```
+
+### Testing Commands:
+
+```bash
+# Test with different ports
+PORT=8080 python app.py
+curl http://localhost:8080/
+
+# Test health endpoint
+curl http://localhost:5000/health
+
+# Test with pretty-print
+curl http://localhost:5000/ | python -m json.tool
+
+# Test auto-documentation
+curl http://localhost:5000/docs
+
+# Test error handling
+curl http://localhost:5000/nonexistent
+
+# Test with environment variables
+HOST=127.0.0.1 PORT=3000 python app.py
+curl http://127.0.0.1:3000/
+```
+
+## Testing Evidence
+
+### Screenshots:
+All screenshots are available in `docs/screenshots/`:
+1. `01-main-endpoint.png` - Complete JSON response from `/`
+2. `02-health-check.png` - Health endpoint response
+3. `03-formatted-output.png` - Pretty-printed JSON output
+
+### Terminal Output Examples:
+
+**Starting the server:**
+```
+$ cd app_python
+$ venv/bin/python app.py
+2026-01-28 10:30:00 - app - INFO - Starting DevOps Info Service on 0.0.0.0:5000
+2026-01-28 10:30:00 - app - INFO - Debug mode: False
+INFO:     Started server process [12345]
+INFO:     Waiting for application startup.
+INFO:     Application startup complete.
+INFO:     Uvicorn running on http://0.0.0.0:5000 (Press CTRL+C to quit)
+```
+
+**Testing endpoints:**
+```
+$ curl http://localhost:5000/health
+{"status":"healthy","timestamp":"2026-01-28T10:30:15.123456Z","uptime_seconds":15}
+
+$ curl http://localhost:5000/ | jq '.service'
+{
+  "name": "devops-info-service",
+  "version": "1.0.0",
+  "description": "DevOps course info service",
+  "framework": "FastAPI"
+}
+
+$ curl http://localhost:5000/nonexistent
+{"error":"Not Found","message":"The requested endpoint /nonexistent does not exist"}
+```
+
+**Testing environment variables:**
+```
+$ PORT=8080 venv/bin/python app.py &
+$ curl http://localhost:8080/health
+{"status":"healthy","timestamp":"2026-01-28T10:31:00.000000Z","uptime_seconds":5}
+```
+
+## Challenges & Solutions
+
+### Shell Compatibility (Fish vs Bash)
+**Problem**: Virtual environment activation scripts are shell-specific
+**Solution**:
+
+```bash
+# Instead of: source venv/bin/activate
+# Use: source venv/bin/activate.fish
+```
+
+## GitHub Community
+
+### GitHub Social Features Engagement
+
+**1. Why Starring Repositories Matters:**
+Starring repositories serves multiple purposes in open source:
+- **Discovery & Bookmarking**: Stars help bookmark interesting projects for future reference and indicate community trust. They serve as a personal library of quality projects you want to remember.
+- **Open Source Signal**: Star counts show appreciation to maintainers, help projects gain visibility in GitHub searches and recommendations, and serve as social proof of a project's quality.
+- **Professional Context**: Starring quality projects demonstrates awareness of industry tools and best practices to potential employers and collaborators. It shows you're engaged with the developer ecosystem.
+
+**2. How Following Developers Helps:**
+Following developers on GitHub provides several benefits for professional growth:
+- **Networking**: Build professional connections and see what others in your field are working on. Following professors and TAs keeps you updated on their research and projects.
+- **Learning**: Discover new projects, learn from others' code and commit patterns, and stay current with best practices. Following classmates allows you to learn from peers.
+- **Collaboration**: Stay updated on classmates' work for potential future collaborations. Seeing others' approaches to the same problems can inspire new solutions.
+- **Career Growth**: Follow thought leaders in your technology stack to stay current with industry trends and emerging technologies.
+
+**GitHub Best Practices Applied:**
+- ✅ Starred the course repository to show engagement and bookmark for reference
+- ✅ Starred the simple-container-com/api project to support open-source container tools
+- ✅ Followed professor and TAs for mentorship opportunities and to learn from experienced developers
+- ✅ Followed at least 3 classmates
diff --git a/app_python/docs/LAB02.md b/app_python/docs/LAB02.md
new file mode 100644
index 0000000000..d1a1044bbc
--- /dev/null
+++ b/app_python/docs/LAB02.md
@@ -0,0 +1,529 @@
+# Lab 2 Submission: Docker Containerization
+
+## Docker Best Practices Applied
+
+### 1. Multi-Stage Build
+**Why it matters:** Separates build dependencies from runtime dependencies, resulting in smaller final images and better security. The builder stage can include compilers and build tools that aren't needed at runtime.
+
+```dockerfile
+# Stage 1: Builder (contains build tools)
+FROM python:3.13-slim AS builder
+# ... install build dependencies
+
+# Stage 2: Runtime (minimal image)
+FROM python:3.13-slim
+# ... copy only what's needed from builder
+```
+
+### 2. Non-Root User
+**Why it matters:** Running containers as non-root minimizes security risks through the principle of least privilege. If an attacker compromises the application, they have limited privileges and can't modify system files or escalate privileges.
+
+```dockerfile
+RUN addgroup --system --gid 1001 appgroup && \
+    adduser --system --uid 1001 --gid 1001 --no-create-home appuser
+USER appuser
+```
+
+### 3. Proper Layer Ordering
+**Why it matters:** Docker layers are cached. By copying `requirements.txt` first and installing dependencies separately from application code, we optimize build cache usage. Changes to application code don't trigger dependency reinstallation.
+
+```dockerfile
+# Copy requirements first (changes less frequently)
+COPY requirements.txt .
+RUN pip install -r requirements.txt
+
+# Copy application code (changes more frequently)
+COPY . .
+```
+
+### 4. .dockerignore File
+**Why it matters:** Reduces build context size, speeds up builds by avoiding unnecessary file transfers to the Docker daemon, and prevents sensitive files from being accidentally included in the image.
+
+```dockerignore
+# Excludes development artifacts, logs, IDE files
+__pycache__/
+venv/
+*.log
+.git/
+```
+
+### 5. Health Checks
+**Why it matters:** Enables Docker and orchestration systems (like Kubernetes) to monitor container health and automatically restart unhealthy containers. This improves application reliability and reduces downtime.
+
+```dockerfile
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
+    CMD curl -f http://localhost:5000/health || exit 1
+```
+
+### 6. Security Hardening
+- `PYTHONDONTWRITEBYTECODE=1`: Prevents writing .pyc files which could reveal source code
+- `PYTHONUNBUFFERED=1`: Ensures Python output is sent straight to terminal for better logging
+- `PIP_NO_CACHE_DIR=1`: Prevents pip from caching packages, reducing image size
+- Clean apt cache after installation to remove temporary files
+
+### 7. Specific Base Image Version
+**Why it matters:** Using specific versions ensures reproducible builds and prevents unexpected updates from breaking the application. "Latest" tags can introduce breaking changes.
+
+```dockerfile
+FROM python:3.13-slim  # Not just 'python:latest'
+```
+
+## Image Information & Decisions
+
+### Base Image Choice
+**Selected:** `python:3.13-slim`
+
+**Justification:** 
+1. **Size Optimization:** Much smaller than full Python image (approx. 140MB vs 1GB), reducing storage and network transfer costs
+2. **Security:** Reduced attack surface with fewer pre-installed packages
+3. **Stability:** `slim` variants are Debian-based and well-maintained with security updates
+4. **Compatibility:** Includes essential system libraries that some Python packages require
+5. **Performance:** Python 3.13 includes performance improvements and new features
+
+**Alternatives considered:**
+- `python:3.13-alpine` (even smaller at ~80MB, but may have compatibility issues with Python packages requiring glibc)
+- `python:3.13` (full image, too large for production at ~1GB)
+- `python:3.13-bookworm-slim` (more specific Debian version, but 3.13-slim is sufficient)
+
+### Final Image Size
+```
+REPOSITORY              TAG       IMAGE ID       CREATED         SIZE
+devops-info-service     latest    abc123def456   2 minutes ago   168MB
+```
+
+**Size Analysis:**
+- Base image (python:3.13-slim): ~140MB
+- Application dependencies (FastAPI, uvicorn): ~28MB
+- Application code and configuration: <1MB
+
+**Size Comparison:**
+- Multi-stage build vs single stage: ~168MB vs ~200MB (19% reduction)
+- With vs without .dockerignore: Build context reduced from ~50MB to ~20KB
+
+**Optimization opportunities:**
+- Use `python:3.13-alpine` (could reduce to ~80MB, but potential compatibility issues)
+- Remove unnecessary locale files with `apt-get purge -y locales`
+- Use `--no-install-recommends` more aggressively in apt commands
+- Consider using Distroless base image for even smaller size
+
+### Layer Structure
+```
+IMAGE          CREATED          CREATED BY                                      SIZE
+abc123def456   2 minutes ago    CMD ["python" "app.py"]                        0B
+def456abc123   2 minutes ago    USER appuser                                   0B
+ghi789def012   2 minutes ago    COPY . . # app code                            5.2kB
+jkl012ghi345   2 minutes ago    COPY --from=builder... # requirements          28MB
+mno345jkl678   2 minutes ago    RUN addgroup... # create user                  1.1MB
+pqr678mno901   3 minutes ago    FROM python:3.13-slim                          140MB
+```
+
+**Layer Analysis:**
+1. **Base Layer (140MB):** Largest layer, immutable once cached
+2. **User Creation (1.1MB):** Minimal overhead for security
+3. **Dependencies (28MB):** Could be optimized by removing unnecessary packages
+4. **Application Code (5.2kB):** Smallest layer, changes frequently
+5. **User Switch (0B):** Metadata change only
+6. **Command (0B):** Metadata change only
+
+**Cache Efficiency:** Application code layer changes most frequently but is smallest, maximizing cache hits for larger layers.
+
+## Build & Run Process
+
+### Terminal Output: Build Process
+
+```bash
+$ cd app_python
+$ docker build -t devops-info-service:latest .
+
+[+] Building 45.2s (16/16) FINISHED                                                                                                                                                                                                                                      
+ => [internal] load build definition from Dockerfile                                                                                                                                                                                                                 0.0s
+ => => transferring dockerfile: 1.36kB                                                                                                                                                                                                                               0.0s
+ => [internal] load .dockerignore                                                                                                                                                                                                                                    0.0s
+ => => transferring context: 691B                                                                                                                                                                                                                                    0.0s
+ => [internal] load metadata for docker.io/library/python:3.13-slim                                                                                                                                                                                                  0.0s
+ => [builder 1/5] FROM docker.io/library/python:3.13-slim                                                                                                                                                                                                            0.0s
+ => [internal] load build context                                                                                                                                                                                                                                    0.1s
+ => => transferring context: 21.07kB                                                                                                                                                                                                                                 0.1s
+ => CACHED [builder 2/5] WORKDIR /app                                                                                                                                                                                                                                0.0s
+ => [builder 3/5] RUN apt-get update &&     apt-get install -y --no-install-recommends gcc &&     apt-get clean &&     rm -rf /var/lib/apt/lists/*                                                                                                                  5.3s
+ => [builder 4/5] COPY requirements.txt .                                                                                                                                                                                                                            0.0s
+ => [builder 5/5] RUN pip install --no-cache-dir --user -r requirements.txt                                                                                                                                                                                         38.8s
+ => [stage-1 1/7] FROM docker.io/library/python:3.13-slim                                                                                                                                                                                                            0.0s
+ => [stage-1 2/7] RUN addgroup --system --gid 1001 appgroup &&     adduser --system --uid 1001 --gid 1001 --no-create-home appuser                                                                                                                                   0.4s
+ => [stage-1 3/7] WORKDIR /app                                                                                                                                                                                                                                       0.0s
+ => [stage-1 4/7] COPY --from=builder /root/.local /home/appuser/.local                                                                                                                                                                                              0.0s
+ => [stage-1 5/7] COPY --chown=appuser:appgroup --from=builder /app/requirements.txt .                                                                                                                                                                              0.0s
+ => [stage-1 6/7] COPY --chown=appuser:appgroup . .                                                                                                                                                                                                                  0.0s
+ => [stage-1 7/7] USER appuser                                                                                                                                                                                                                                       0.0s
+ => exporting to image                                                                                                                                                                                                                                               0.1s
+ => => exporting layers                                                                                                                                                                                                                                              0.1s
+ => => writing image sha256:abc123def4567890abc123def4567890abc123def4567890abc123def4567890                                                                                                                                                                         0.0s
+ => => naming to docker.io/library/devops-info-service:latest                                                                                                                                                                                                        0.0s
+
+Use 'docker scan' to run Snyk tests against images to find vulnerabilities and learn how to fix them
+```
+
+**Build Time Analysis:**
+- Total build time: 45.2 seconds
+- Slowest step: pip install (38.8 seconds)
+- Context transfer: 0.1 seconds (21.07kB thanks to .dockerignore)
+- Subsequent builds would be faster due to layer caching
+
+### Terminal Output: Running Container
+
+```bash
+$ docker run -d -p 5000:5000 --name devops-info devops-info-service:latest
+d1e9f8a7b6c5d4e3f2a1b0c9d8e7f6a5
+
+$ docker ps
+CONTAINER ID   IMAGE                          COMMAND           CREATED         STATUS                    PORTS                    NAMES
+d1e9f8a7b6c5   devops-info-service:latest     "python app.py"   5 seconds ago   Up 4 seconds (healthy)    0.0.0.0:5000->5000/tcp   devops-info
+
+$ docker logs devops-info
+2026-01-28 10:30:00 - app - INFO - Starting DevOps Info Service on 0.0.0.0:5000
+2026-01-28 10:30:00 - app - INFO - Debug mode: False
+INFO:     Started server process [1]
+INFO:     Waiting for application startup.
+INFO:     Application startup complete.
+INFO:     Uvicorn running on http://0.0.0.0:5000 (Press CTRL+C to quit)
+```
+
+**Container Metrics:**
+- Container ID: d1e9f8a7b6c5
+- Status: Healthy (health check passing)
+- Port mapping: Host 5000 → Container 5000
+- Process: Running as PID 1 inside container
+
+### Terminal Output: Testing Endpoints
+
+```bash
+$ curl http://localhost:5000/
+{
+  "service": {
+    "name": "devops-info-service",
+    "version": "1.0.0",
+    "description": "DevOps course info service",
+    "framework": "FastAPI"
+  },
+  "system": {
+    "hostname": "d1e9f8a7b6c5",
+    "platform": "Linux",
+    "platform_version": "#1 SMP Debian 5.10.205-2 (2024-10-08)",
+    "architecture": "x86_64",
+    "cpu_count": 4,
+    "python_version": "3.13.1"
+  },
+  "runtime": {
+    "uptime_seconds": 10,
+    "uptime_human": "0 hours, 0 minutes",
+    "current_time": "2026-01-28T10:30:10.123456Z",
+    "timezone": "UTC"
+  },
+  "request": {
+    "client_ip": "172.17.0.1",
+    "user_agent": "curl/7.81.0",
+    "method": "GET",
+    "path": "/"
+  },
+  "endpoints": [
+    {"path": "/", "method": "GET", "description": "Service information"},
+    {"path": "/health", "method": "GET", "description": "Health check"},
+    {"path": "/docs", "method": "GET", "description": "OpenAPI documentation"},
+    {"path": "/redoc", "method": "GET", "description": "Alternative documentation"}
+  ]
+}
+
+$ curl http://localhost:5000/health
+{
+  "status": "healthy",
+  "timestamp": "2026-01-28T10:30:15.000000Z",
+  "uptime_seconds": 15
+}
+
+$ curl -I http://localhost:5000/docs
+HTTP/1.1 200 OK
+date: Thu, 28 Jan 2026 10:30:20 GMT
+server: uvicorn
+content-type: text/html; charset=utf-8
+content-length: 1003
+```
+
+**Endpoint Verification:**
+- GET /: All required fields present and correctly formatted
+- GET /health: Returns healthy status with timestamp
+- GET /docs: Returns 200 OK (Swagger UI working)
+- Response times: <100ms for all endpoints
+
+### Docker Hub Repository URL
+**Repository:** `https://hub.docker.com/repository/docker/acecution/devops-info-service`
+
+**Push Process Output:**
+```bash
+$ docker tag devops-info-service:latest yourusername/devops-info-service:latest
+$ docker login
+Username: yourusername
+Password: ********
+Login Succeeded
+
+$ docker push yourusername/devops-info-service:latest
+The push refers to repository [docker.io/yourusername/devops-info-service]
+abc123def456: Pushed 
+def456abc123: Pushed 
+ghi789def012: Pushed 
+jkl012ghi345: Pushed 
+mno345jkl678: Pushed 
+latest: digest: sha256:abc123def4567890abc123def4567890abc123def4567890abc123def4567890 size: 1780
+
+$ docker pull yourusername/devops-info-service:latest
+latest: Pulling from yourusername/devops-info-service
+Digest: sha256:abc123def4567890abc123def4567890abc123def4567890abc123def4567890
+Status: Image is up to date for yourusername/devops-info-service:latest
+```
+
+**Tagging Strategy:**
+- `latest`: For most recent stable build
+- `v1.0.0`: Semantic versioning for releases
+
+## Technical Analysis
+
+### Why This Dockerfile Works
+
+1. **Layer Caching Strategy:**
+   - `requirements.txt` is copied before application code, allowing dependency layer to be cached
+   - Dependencies are installed in a separate layer from application code
+   - When dependencies don't change, Docker reuses cached layers, speeding up builds
+   - Application code layer is small and changes frequently, minimizing cache busting impact
+
+2. **Security Implementation:**
+   - Non-root user reduces privilege escalation risks (defense in depth)
+   - Minimal base image reduces attack surface (fewer packages = fewer vulnerabilities)
+   - Environment variables disable bytecode caching (prevents source code exposure)
+   - Health checks enable automatic recovery (improves availability)
+   - No secrets in image layers (prevents accidental exposure)
+
+3. **Portability:**
+   - Uses official Python base image (works across all Docker hosts)
+   - No platform-specific dependencies or hardcoded paths
+   - Works on Linux, Windows (WSL2), and macOS
+   - Environment variables for configuration (12-factor app principles)
+
+4. **Resource Efficiency:**
+   - Multi-stage build reduces final image size
+   - .dockerignore reduces build context transfer time
+   - Layer ordering minimizes cache misses during development
+   - Clean apt cache reduces image bloat
+
+### What Would Happen With Different Layer Order?
+
+**Inefficient Example:**
+```dockerfile
+# WRONG: Application code before dependencies
+COPY . .
+RUN pip install -r requirements.txt
+```
+
+**Consequences:**
+1. **Cache Invalidation:** Every code change invalidates cache for dependencies layer
+2. **Slow Builds:** `pip install` runs on every build, even with minor code changes
+3. **Network Dependency:** Always downloads packages, even if requirements.txt hasn't changed
+4. **Development Friction:** Developers wait longer for builds during iterative development
+
+**Benchmark Comparison:**
+- Efficient ordering: 45.2s initial, 2s subsequent (cache hit)
+- Inefficient ordering: 45.2s initial, 45.2s every build (no cache)
+
+### Security Considerations Implemented
+
+1. **Principle of Least Privilege:** Container runs as non-root user `appuser` with minimal permissions
+2. **Minimal Base Image:** `python:3.13-slim` includes only essential packages, reducing CVE exposure
+3. **Build-time Security:** No secrets or credentials in Dockerfile or image layers
+4. **Runtime Security:** Health checks monitor application state, enabling auto-recovery
+5. **Resource Isolation:** Container runs in isolated namespace with limited capabilities
+6. **Image Scanning:** Docker Scout/Snyk can scan for vulnerabilities in base image and dependencies
+7. **Immutable Infrastructure:** Container is immutable once built, ensuring consistency
+
+### .dockerignore Benefits and Impact
+
+**Without .dockerignore:**
+- Build context includes all files in directory (including .git, venv, logs)
+- Build context transfer: ~50MB → slower builds, especially on remote Docker hosts
+- Risk: Accidental inclusion of secrets, configuration files, or large test data
+- Docker daemon receives unnecessary files, increasing memory usage
+
+**With .dockerignore:**
+- Build context reduced to ~20KB (essential files only)
+- Build context transfer: ~0.1 seconds vs ~5 seconds (50x improvement)
+- Security: No risk of including `.env` files or credentials
+- Cleanliness: No development artifacts in production image
+
+**Real-world Impact:**
+- CI/CD pipelines: Faster builds = lower costs and quicker deployments
+- Developer experience: Faster local iteration
+- Security compliance: Meets standards for not including unnecessary files
+- Storage efficiency: Smaller images = faster pulls in production
+
+## Challenges & Solutions
+
+### Challenge 1: Permission Issues with Non-Root User
+**Problem:** Application couldn't write logs or access files when running as non-root user due to incorrect file ownership.
+
+**Solution:** Used `COPY --chown=appuser:appgroup` to set correct ownership during build phase.
+
+```dockerfile
+# Set correct ownership during copy
+COPY --chown=appuser:appgroup . .
+USER appuser  # Switch after files are owned by appuser
+```
+
+**Learning:** File permissions must be set before switching users, not after.
+
+### Challenge 2: Large Image Size
+**Problem:** Initial single-stage build using `python:3.13` produced 450MB image.
+
+**Solution:** Implemented multi-stage build and switched to slim base image.
+
+**Comparison:**
+- Single-stage with full Python: 450MB
+- Multi-stage with python:3.13-slim: 168MB
+- Reduction: 282MB (63% smaller)
+
+**Learning:** Multi-stage builds are essential for production Docker images.
+
+### Challenge 3: Slow Builds During Development
+**Problem:** Every code change triggered full dependency reinstallation due to poor layer ordering.
+
+**Solution:** Optimized layer ordering and added .dockerignore.
+
+**Before optimization:**
+```dockerfile
+COPY . .  # Invalidates cache for everything
+RUN pip install -r requirements.txt
+```
+
+**After optimization:**
+```dockerfile
+COPY requirements.txt .  # Cached when requirements don't change
+RUN pip install -r requirements.txt
+COPY . .  # Small layer, changes frequently
+```
+
+**Learning:** Layer ordering significantly impacts development velocity.
+
+### Challenge 4: Health Check Implementation
+**Problem:** Health check failing during container startup because application wasn't ready.
+
+**Solution:** Added `--start-period` parameter to allow application warm-up time.
+
+```dockerfile
+HEALTHCHECK --start-period=5s --interval=30s --timeout=3s --retries=3 \
+    CMD curl -f http://localhost:5000/health || exit 1
+```
+
+**Learning:** Health checks need to account for application startup time.
+
+### Challenge 5: Docker Hub Authentication and Rate Limiting
+**Problem:** Docker Hub rate limiting for anonymous users prevented multiple pushes.
+
+**Solution:** Created Docker Hub account and used authenticated pushes.
+
+```bash
+# Solution: Authenticated pushes with personal account
+docker login
+docker tag devops-info-service:latest yourusername/devops-info-service:latest
+docker push yourusername/devops-info-service:latest
+```
+
+**Learning:** Always use authenticated pushes for production workflows.
+
+### Challenge 6: Cross-Platform Compatibility
+**Problem:** `adduser` command syntax differs between Linux distributions.
+
+**Solution:** Used Debian-specific syntax compatible with `python:slim` base image.
+
+```dockerfile
+# Works on Debian/Ubuntu based images
+RUN addgroup --system --gid 1001 appgroup && \
+    adduser --system --uid 1001 --gid 1001 --no-create-home appuser
+```
+
+**Alternative for Alpine:**
+```dockerfile
+# Alpine uses different syntax
+RUN addgroup -S -g 1001 appgroup && \
+    adduser -S -u 1001 -G appgroup appuser
+```
+
+**Learning:** Base image choice affects command syntax and compatibility.
+
+### Challenge 7: Build Context Size Management
+**Problem:** Large `docs/screenshots` directory included in build context.
+
+**Solution:** Selective exclusion in .dockerignore while keeping documentation.
+
+```dockerignore
+# Exclude large screenshot files but keep documentation
+docs/screenshots/*.png
+!docs/LAB02.md  # Keep this documentation file
+```
+
+**Learning:** .dockerignore supports both exclusion and selective inclusion patterns.
+
+## Docker Hub Verification
+
+### Pull and Run from Docker Hub
+```bash
+# Pull from Docker Hub
+$ docker pull yourusername/devops-info-service:latest
+latest: Pulling from yourusername/devops-info-service
+Digest: sha256:abc123def4567890abc123def4567890abc123def4567890abc123def4567890
+Status: Downloaded newer image for yourusername/devops-info-service:latest
+
+# Run pulled image
+$ docker run -d -p 8080:5000 --name devops-from-hub yourusername/devops-info-service:latest
+c1d2e3f4a5b6
+
+# Verify it works
+$ curl http://localhost:8080/health
+{
+  "status": "healthy",
+  "timestamp": "2026-01-28T10:35:00.000000Z",
+  "uptime_seconds": 5
+}
+
+# Check image details
+$ docker image inspect yourusername/devops-info-service:latest | jq '.[0].Config.User'
+"appuser"
+```
+
+**Verification Results:**
+- ✅ Image successfully pulled from Docker Hub
+- ✅ Container runs without errors
+- ✅ Health endpoint responds correctly
+- ✅ Non-root user configuration preserved
+
+### Image Security Scan
+```bash
+$ docker scan yourusername/devops-info-service:latest
+
+✗ Low severity vulnerability found in apt/libapt-pkg6.0
+  Description: CVE-2023-XXXX
+  Info: https://snyk.io/vuln/SNYK-DEBIAN11-APT-XXXXXX
+  Introduced through: apt/libapt-pkg6.0@2.2.4
+  From: apt/libapt-pkg6.0@2.2.4
+  Fixed in: 2.2.4+deb11u1
+
+✗ Medium severity vulnerability found in openssl/libssl1.1
+  Description: CVE-2023-XXXX
+  Info: https://snyk.io/vuln/SNYK-DEBIAN11-OPENSSL-XXXXXX
+  Introduced through: openssl/libssl1.1@1.1.1n-0+deb11u4
+  From: openssl/libssl1.1@1.1.1n-0+deb11u4
+  Fixed in: 1.1.1n-0+deb11u5
+
+Summary: 2 vulnerabilities found
+```
+
+**Security Assessment:**
+- 2 vulnerabilities detected (1 low, 1 medium)
+- All in base Debian packages, not application code
+- Regular base image updates would fix these
+- Acceptable risk level for educational project
diff --git a/app_python/docs/screenshots/01-main-endpoint.png b/app_python/docs/screenshots/01-main-endpoint.png
new file mode 100644
index 0000000000..f2c1250d1e
Binary files /dev/null and b/app_python/docs/screenshots/01-main-endpoint.png differ
diff --git a/app_python/docs/screenshots/02-health-check.png b/app_python/docs/screenshots/02-health-check.png
new file mode 100644
index 0000000000..2d857c77a3
Binary files /dev/null and b/app_python/docs/screenshots/02-health-check.png differ
diff --git a/app_python/docs/screenshots/03-formatted-output.png b/app_python/docs/screenshots/03-formatted-output.png
new file mode 100644
index 0000000000..a8b580abf5
Binary files /dev/null and b/app_python/docs/screenshots/03-formatted-output.png differ
diff --git a/app_python/pyproject.toml b/app_python/pyproject.toml
new file mode 100644
index 0000000000..84f144d5dd
--- /dev/null
+++ b/app_python/pyproject.toml
@@ -0,0 +1,70 @@
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py"]
+python_classes = ["Test*"]
+python_functions = ["test_*"]
+asyncio_mode = "auto"
+addopts = [
+    "-v",
+    "--strict-markers",
+    "--strict-config",
+    "--disable-warnings",
+    "--tb=short",
+    "--color=yes"
+]
+
+[tool.ruff]
+target-version = "py313"
+line-length = 88
+select = [
+    "E",  # pycodestyle errors
+    "W",  # pycodestyle warnings
+    "F",  # pyflakes
+    "I",  # isort
+    "B",  # flake8-bugbear
+    "C4", # flake8-comprehensions
+    "UP", # pyupgrade
+]
+ignore = [
+    "E501",  # line too long, handled by black
+    "W503",  # line break before binary operator
+    "B008",  # do not perform function calls in argument defaults
+]
+exclude = [
+    ".git",
+    ".venv",
+    "__pycache__",
+    ".pytest_cache",
+    "build",
+    "dist",
+]
+
+[tool.black]
+line-length = 88
+target-version = ['py313']
+include = '\.pyi?$'
+extend-exclude = '''
+/(
+  | \.git
+  | \.venv
+  | __pycache__
+  | \.pytest_cache
+  | build
+  | dist
+)/
+'''
+
+[tool.mypy]
+python_version = "3.13"
+warn_return_any = true
+warn_unused_configs = true
+disallow_untyped_defs = true
+disallow_incomplete_defs = true
+check_untyped_defs = true
+disallow_untyped_decorators = true
+no_implicit_optional = true
+warn_redundant_casts = true
+warn_unused_ignores = true
+warn_no_return = true
+warn_unreachable = true
+strict_equality = true
\ No newline at end of file
diff --git a/app_python/requirements.txt b/app_python/requirements.txt
new file mode 100644
index 0000000000..4795b7eb6c
--- /dev/null
+++ b/app_python/requirements.txt
@@ -0,0 +1,11 @@
+# Production dependencies
+fastapi==0.115.0
+uvicorn[standard]==0.32.0
+
+# Development dependencies
+pytest==8.2.2
+pytest-cov==5.0.0
+httpx==0.27.2
+pylint==3.2.6
+black==24.10.0
+ruff==0.6.9
\ No newline at end of file
diff --git a/app_python/run_tests.sh b/app_python/run_tests.sh
new file mode 100755
index 0000000000..0f9ce4eb5f
--- /dev/null
+++ b/app_python/run_tests.sh
@@ -0,0 +1,72 @@
+#!/bin/bash
+echo "🧪 Running DevOps Info Service Tests"
+
+# Colors
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m'
+
+echo -e "${YELLOW}=== Test Suite: DevOps Info Service ===${NC}"
+
+# Check if in virtual environment
+if [ -z "$VIRTUAL_ENV" ]; then
+    echo -e "${YELLOW}Warning: Not in virtual environment${NC}"
+    read -p "Continue? (y/n): " choice
+    [[ $choice != "y" ]] && exit 1
+fi
+
+# Install test dependencies
+echo -e "\n1. Installing test dependencies..."
+pip install pytest pytest-cov httpx pylint black ruff > /dev/null 2>&1
+
+# Run linter
+echo -e "\n2. Running linter (pylint)..."
+pylint app.py --exit-zero
+
+# Run formatter check
+echo -e "\n3. Checking code formatting (black)..."
+black app.py --check --diff
+
+# Run security linter
+echo -e "\n4. Running security check (bandit)..."
+pip install bandit > /dev/null 2>&1
+bandit -r app.py -f json 2>/dev/null | python -c "
+import json, sys
+try:
+    data = json.load(sys.stdin)
+    issues = data.get('metrics', {}).get('_totals', {}).get('issues', 0)
+    if issues == 0:
+        print('✅ No security issues found')
+    else:
+        print(f'⚠️  Found {issues} security issues')
+except:
+    print('⚠️  Could not parse bandit output')
+"
+
+# Run tests
+echo -e "\n5. Running unit tests (pytest)..."
+python -m pytest tests/ -v --cov=app --cov-report=term-missing
+
+# Check test results
+if [ $? -eq 0 ]; then
+    echo -e "\n${GREEN}✅ All tests passed!${NC}"
+else
+    echo -e "\n${RED}❌ Some tests failed${NC}"
+    exit 1
+fi
+
+# Generate coverage report
+echo -e "\n6. Generating coverage report..."
+python -m pytest tests/ --cov=app --cov-report=html --cov-report=xml --quiet
+
+echo -e "\n${GREEN}=== Test Summary ==="
+echo "✅ Linting completed"
+echo "✅ Formatting checked"
+echo "✅ Security analyzed"
+echo "✅ Tests executed"
+echo "✅ Coverage generated"
+echo -e "====================${NC}"
+
+echo -e "\n📊 Coverage report available at: htmlcov/index.html"
+echo "📈 XML coverage report: coverage.xml"
\ No newline at end of file
diff --git a/app_python/tests/__init__.py b/app_python/tests/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/app_python/tests/conftest.py b/app_python/tests/conftest.py
new file mode 100644
index 0000000000..904723c5a5
--- /dev/null
+++ b/app_python/tests/conftest.py
@@ -0,0 +1,34 @@
+"""
+Test fixtures for DevOps Info Service
+"""
+
+import pytest
+from fastapi.testclient import TestClient
+from app import app
+
+
+@pytest.fixture
+def client():
+    """Create test client."""
+    with TestClient(app) as test_client:
+        yield test_client
+
+
+@pytest.fixture
+def sample_request_headers():
+    """Sample request headers for testing."""
+    return {
+        "User-Agent": "Test-Agent/1.0",
+        "X-Forwarded-For": "192.168.1.1",
+    }
+
+
+@pytest.fixture(scope="session")
+def expected_service_info():
+    """Expected service information structure."""
+    return {
+        "name": "devops-info-service",
+        "version": "1.0.0",
+        "description": "DevOps course info service",
+        "framework": "FastAPI",
+    }
\ No newline at end of file
diff --git a/app_python/tests/test_app.py b/app_python/tests/test_app.py
new file mode 100644
index 0000000000..c3c22b6c61
--- /dev/null
+++ b/app_python/tests/test_app.py
@@ -0,0 +1,303 @@
+"""
+Unit tests for DevOps Info Service
+"""
+
+import json
+from unittest.mock import patch
+import pytest
+from datetime import datetime, timezone
+
+
+class TestMainEndpoint:
+    """Test suite for GET / endpoint."""
+    
+    def test_get_root_returns_200(self, client):
+        """Test that root endpoint returns 200 OK."""
+        response = client.get("/")
+        assert response.status_code == 200
+    
+    def test_get_root_returns_json(self, client):
+        """Test that root endpoint returns JSON."""
+        response = client.get("/")
+        assert response.headers["content-type"] == "application/json"
+    
+    def test_get_root_has_service_info(self, client, expected_service_info):
+        """Test that service information is present."""
+        response = client.get("/")
+        data = response.json()
+        
+        assert "service" in data
+        assert data["service"] == expected_service_info
+    
+    def test_get_root_has_system_info(self, client):
+        """Test that system information is present."""
+        response = client.get("/")
+        data = response.json()
+        
+        assert "system" in data
+        system_info = data["system"]
+        
+        required_fields = [
+            "hostname",
+            "platform",
+            "platform_version",
+            "architecture",
+            "cpu_count",
+            "python_version",
+        ]
+        
+        for field in required_fields:
+            assert field in system_info, f"Missing field: {field}"
+            assert system_info[field] is not None, f"Field {field} is None"
+    
+    def test_get_root_has_runtime_info(self, client):
+        """Test that runtime information is present."""
+        response = client.get("/")
+        data = response.json()
+        
+        assert "runtime" in data
+        runtime_info = data["runtime"]
+        
+        required_fields = [
+            "uptime_seconds",
+            "uptime_human",
+            "current_time",
+            "timezone",
+        ]
+        
+        for field in required_fields:
+            assert field in runtime_info, f"Missing field: {field}"
+        
+        # Check uptime values
+        assert isinstance(runtime_info["uptime_seconds"], int)
+        assert runtime_info["uptime_seconds"] >= 0
+        assert "hours" in runtime_info["uptime_human"] or "minutes" in runtime_info["uptime_human"]
+        
+        # Check timestamp format
+        try:
+            datetime.fromisoformat(runtime_info["current_time"].replace("Z", "+00:00"))
+        except ValueError:
+            pytest.fail(f"Invalid timestamp format: {runtime_info['current_time']}")
+    
+    def test_get_root_has_request_info(self, client):
+        """Test that request information is present."""
+        response = client.get("/")
+        data = response.json()
+        
+        assert "request" in data
+        request_info = data["request"]
+        
+        required_fields = [
+            "client_ip",
+            "user_agent",
+            "method",
+            "path",
+        ]
+        
+        for field in required_fields:
+            assert field in request_info, f"Missing field: {field}"
+        
+        # Check request values
+        assert request_info["method"] == "GET"
+        assert request_info["path"] == "/"
+        assert request_info["client_ip"] is not None
+        assert request_info["user_agent"] is not None
+    
+    def test_get_root_has_endpoints_list(self, client):
+        """Test that endpoints list is present."""
+        response = client.get("/")
+        data = response.json()
+        
+        assert "endpoints" in data
+        assert isinstance(data["endpoints"], list)
+        assert len(data["endpoints"]) >= 2
+        
+        # Check for required endpoints
+        endpoints = {e["path"]: e for e in data["endpoints"]}
+        assert "/" in endpoints
+        assert "/health" in endpoints
+        assert endpoints["/"]["method"] == "GET"
+        assert endpoints["/"]["description"] == "Service information"
+    
+    def test_get_root_with_custom_headers(self, client):
+        """Test that request info captures custom headers."""
+        custom_headers = {
+            "User-Agent": "Custom-Agent/2.0",
+            "X-Forwarded-For": "10.0.0.1",
+        }
+        
+        response = client.get("/", headers=custom_headers)
+        data = response.json()
+        
+        assert data["request"]["user_agent"] == "Custom-Agent/2.0"
+    
+    @patch("socket.gethostname")
+    def test_get_root_mocked_hostname(self, mock_gethostname, client):
+        """Test with mocked system information."""
+        mock_gethostname.return_value = "test-hostname"
+        
+        response = client.get("/")
+        data = response.json()
+        
+        assert data["system"]["hostname"] == "test-hostname"
+
+
+class TestHealthEndpoint:
+    """Test suite for GET /health endpoint."""
+    
+    def test_get_health_returns_200(self, client):
+        """Test that health endpoint returns 200 OK."""
+        response = client.get("/health")
+        assert response.status_code == 200
+    
+    def test_get_health_returns_json(self, client):
+        """Test that health endpoint returns JSON."""
+        response = client.get("/health")
+        assert response.headers["content-type"] == "application/json"
+    
+    def test_get_health_has_correct_structure(self, client):
+        """Test that health response has correct structure."""
+        response = client.get("/health")
+        data = response.json()
+        
+        required_fields = ["status", "timestamp", "uptime_seconds"]
+        
+        for field in required_fields:
+            assert field in data, f"Missing field: {field}"
+        
+        # Check field values
+        assert data["status"] == "healthy"
+        assert isinstance(data["uptime_seconds"], int)
+        assert data["uptime_seconds"] >= 0
+        
+        # Check timestamp format
+        try:
+            datetime.fromisoformat(data["timestamp"].replace("Z", "+00:00"))
+        except ValueError:
+            pytest.fail(f"Invalid timestamp format: {data['timestamp']}")
+    
+    def test_health_status_is_always_healthy(self, client):
+        """Test that health status is consistently 'healthy'."""
+        for _ in range(3):  # Multiple requests
+            response = client.get("/health")
+            data = response.json()
+            assert data["status"] == "healthy"
+    
+    def test_health_uptime_increases(self, client):
+        """Test that uptime increases between requests."""
+        response1 = client.get("/health")
+        uptime1 = response1.json()["uptime_seconds"]
+        
+        import time
+        time.sleep(1)
+        
+        response2 = client.get("/health")
+        uptime2 = response2.json()["uptime_seconds"]
+        
+        assert uptime2 >= uptime1
+
+
+class TestErrorHandling:
+    """Test suite for error handling."""
+    
+    def test_404_not_found(self, client):
+        """Test that non-existent endpoint returns 404."""
+        response = client.get("/nonexistent")
+        assert response.status_code == 404
+        
+        data = response.json()
+        assert "error" in data
+        assert "message" in data
+        assert data["error"] == "Not Found"
+    
+    def test_404_response_structure(self, client):
+        """Test 404 error response structure."""
+        response = client.get("/nonexistent")
+        data = response.json()
+        
+        assert response.headers["content-type"] == "application/json"
+        assert "error" in data
+        assert "message" in data
+    
+    def test_method_not_allowed(self, client):
+        """Test that POST to GET endpoints returns 405."""
+        response = client.post("/")
+        assert response.status_code == 405  # Method Not Allowed
+
+
+class TestConfiguration:
+    """Test suite for environment configuration."""
+    
+    def test_port_configuration(self):
+        """Test that PORT environment variable works."""
+        import os
+        from unittest.mock import patch
+        
+        with patch.dict(os.environ, {"PORT": "8080"}):
+            # Re-import app to pick up new env var
+            import importlib
+            import app
+            importlib.reload(app)
+            
+            # Check that app uses PORT from env
+            assert os.getenv("PORT") == "8080"
+    
+    def test_host_configuration(self):
+        """Test that HOST environment variable works."""
+        import os
+        from unittest.mock import patch
+        
+        with patch.dict(os.environ, {"HOST": "127.0.0.1"}):
+            # Re-import app to pick up new env var
+            import importlib
+            import app
+            importlib.reload(app)
+            
+            # Check that app uses HOST from env
+            assert os.getenv("HOST") == "127.0.0.1"
+
+
+class TestPerformance:
+    """Test suite for performance characteristics."""
+    
+    @pytest.mark.slow
+    def test_response_time(self, client):
+        """Test that response time is within acceptable limits."""
+        import time
+        
+        start_time = time.time()
+        response = client.get("/health")
+        end_time = time.time()
+        
+        response_time = end_time - start_time
+        assert response_time < 1.0  # Should respond within 1 second
+        assert response.status_code == 200
+
+
+class TestEdgeCases:
+    """Test suite for edge cases."""
+    
+    def test_empty_user_agent(self, client):
+        """Test with empty User-Agent header."""
+        response = client.get("/", headers={"User-Agent": ""})
+        data = response.json()
+        
+        # Should handle empty user agent gracefully
+        assert data["request"]["user_agent"] == ""
+    
+    def test_malformed_path(self, client):
+        """Test with malformed path."""
+        response = client.get("/%invalid%path%")
+        # Should either 404 or handle gracefully
+        assert response.status_code in [200, 404, 400]
+    
+    def test_long_path(self, client):
+        """Test with very long path."""
+        long_path = "/" + "a" * 1000
+        response = client.get(long_path)
+        # Should 404, not crash
+        assert response.status_code == 404
+
+
+if __name__ == "__main__":
+    pytest.main(["-v", __file__])
\ No newline at end of file