novahiz 0.1.0

package/bundled-skills/database-designer/README.md

@@ -0,0 +1,388 @@
+# Database Designer - POWERFUL Tier Skill
+
+A comprehensive database design and analysis toolkit that provides expert-level schema analysis, index optimization, and migration generation capabilities for modern database systems.
+
+## Features
+
+### 🔍 Schema Analyzer
+- **Normalization Analysis**: Automated detection of 1NF through BCNF violations
+- **Data Type Optimization**: Identifies antipatterns and inappropriate types
+- **Constraint Analysis**: Finds missing foreign keys, unique constraints, and checks
+- **ERD Generation**: Creates Mermaid diagrams from DDL or JSON schema
+- **Naming Convention Validation**: Ensures consistent naming patterns
+
+### ⚡ Index Optimizer  
+- **Missing Index Detection**: Identifies indexes needed for query patterns
+- **Composite Index Design**: Optimizes column ordering for maximum efficiency
+- **Redundancy Analysis**: Finds duplicate and overlapping indexes
+- **Performance Modeling**: Estimates selectivity and query performance impact
+- **Covering Index Recommendations**: Eliminates table lookups
+
+### 🚀 Migration Generator
+- **Zero-Downtime Migrations**: Implements expand-contract patterns
+- **Schema Evolution**: Handles column changes, table renames, constraint updates
+- **Data Migration Scripts**: Automated data transformation and validation
+- **Rollback Planning**: Complete reversal capabilities for all changes
+- **Execution Orchestration**: Dependency-aware migration ordering
+
+## Quick Start
+
+### Prerequisites
+- Python 3.7+ (no external dependencies required)
+- Database schema in SQL DDL format or JSON
+- Query patterns (for index optimization)
+
+### Installation
+```bash
+# Clone or download the database-designer skill
+cd engineering/database-designer/
+
+# Make scripts executable
+chmod +x *.py
+```
+
+## Usage Examples
+
+### Schema Analysis
+
+**Analyze SQL DDL file:**
+```bash
+python schema_analyzer.py --input assets/sample_schema.sql --output-format text
+```
+
+**Generate ERD diagram:**
+```bash
+python schema_analyzer.py --input assets/sample_schema.sql --generate-erd --output analysis.txt
+```
+
+**JSON schema analysis:**
+```bash
+python schema_analyzer.py --input assets/sample_schema.json --output-format json --output results.json
+```
+
+### Index Optimization
+
+**Basic index analysis:**
+```bash
+python index_optimizer.py --schema assets/sample_schema.json --queries assets/sample_query_patterns.json
+```
+
+**High-priority recommendations only:**
+```bash
+python index_optimizer.py --schema assets/sample_schema.json --queries assets/sample_query_patterns.json --min-priority 2
+```
+
+**JSON output with existing index analysis:**
+```bash
+python index_optimizer.py --schema assets/sample_schema.json --queries assets/sample_query_patterns.json --format json --analyze-existing
+```
+
+### Migration Generation
+
+**Generate migration between schemas:**
+```bash
+python migration_generator.py --current assets/current_schema.json --target assets/target_schema.json
+```
+
+**Zero-downtime migration:**
+```bash
+python migration_generator.py --current current.json --target target.json --zero-downtime --format sql
+```
+
+**Include validation queries:**
+```bash
+python migration_generator.py --current current.json --target target.json --include-validations --output migration_plan.txt
+```
+
+## Tool Documentation
+
+### Schema Analyzer
+
+**Input Formats:**
+- SQL DDL files (.sql)
+- JSON schema definitions (.json)
+
+**Key Capabilities:**
+- Detects 1NF violations (non-atomic values, repeating groups)
+- Identifies 2NF issues (partial dependencies in composite keys)
+- Finds 3NF problems (transitive dependencies)
+- Checks BCNF compliance (determinant key requirements)
+- Validates data types (VARCHAR(255) antipattern, inappropriate types)
+- Missing constraints (NOT NULL, UNIQUE, CHECK, foreign keys)
+- Naming convention adherence
+
+**Sample Command:**
+```bash
+python schema_analyzer.py \
+  --input sample_schema.sql \
+  --generate-erd \
+  --output-format text \
+  --output analysis.txt
+```
+
+**Output:**
+- Comprehensive text or JSON analysis report
+- Mermaid ERD diagram
+- Prioritized recommendations
+- SQL statements for improvements
+
+### Index Optimizer
+
+**Input Requirements:**
+- Schema definition (JSON format)
+- Query patterns with frequency and selectivity data
+
+**Analysis Features:**
+- Selectivity estimation based on column patterns
+- Composite index column ordering optimization  
+- Covering index recommendations for SELECT queries
+- Foreign key index validation
+- Redundancy detection (duplicates, overlaps, unused indexes)
+- Performance impact modeling
+
+**Sample Command:**
+```bash
+python index_optimizer.py \
+  --schema schema.json \
+  --queries query_patterns.json \
+  --format text \
+  --min-priority 3 \
+  --output recommendations.txt
+```
+
+**Output:**
+- Prioritized index recommendations
+- CREATE INDEX statements
+- Drop statements for redundant indexes
+- Performance impact analysis
+- Storage size estimates
+
+### Migration Generator
+
+**Input Requirements:**
+- Current schema (JSON format)
+- Target schema (JSON format)
+
+**Migration Strategies:**
+- Standard migrations with ALTER statements
+- Zero-downtime expand-contract patterns
+- Data migration and transformation scripts
+- Constraint management (add/drop in correct order)
+- Index management with timing estimates
+
+**Sample Command:**
+```bash
+python migration_generator.py \
+  --current current_schema.json \
+  --target target_schema.json \
+  --zero-downtime \
+  --include-validations \
+  --format text
+```
+
+**Output:**
+- Step-by-step migration plan
+- Forward and rollback SQL statements
+- Risk assessment for each step
+- Validation queries
+- Execution time estimates
+
+## File Structure
+
+```
+database-designer/
+├── README.md                          # This file
+├── SKILL.md                          # Comprehensive database design guide
+├── schema_analyzer.py                # Schema analysis tool
+├── index_optimizer.py                # Index optimization tool  
+├── migration_generator.py            # Migration generation tool
+├── references/                       # Reference documentation
+│   ├── normalization_guide.md        # Normalization principles and patterns
+│   ├── index_strategy_patterns.md    # Index design and optimization guide
+│   └── database_selection_decision_tree.md # Database technology selection
+├── assets/                           # Sample files and test data
+│   ├── sample_schema.sql            # Sample DDL with various issues
+│   ├── sample_schema.json           # JSON schema definition
+│   └── sample_query_patterns.json   # Query patterns for index analysis
+└── expected_outputs/                 # Example tool outputs
+    ├── schema_analysis_sample.txt   # Sample schema analysis report
+    ├── index_optimization_sample.txt # Sample index recommendations
+    └── migration_sample.txt         # Sample migration plan
+```
+
+## JSON Schema Format
+
+The tools use a standardized JSON format for schema definitions:
+
+```json
+{
+  "tables": {
+    "table_name": {
+      "columns": {
+        "column_name": {
+          "type": "VARCHAR(255)",
+          "nullable": true,
+          "unique": false,
+          "foreign_key": "other_table.column",
+          "default": "default_value",
+          "cardinality_estimate": 1000
+        }
+      },
+      "primary_key": ["id"],
+      "unique_constraints": [["email"], ["username"]],
+      "check_constraints": {
+        "chk_positive_price": "price > 0"
+      },
+      "indexes": [
+        {
+          "name": "idx_table_column",
+          "columns": ["column_name"],
+          "unique": false,
+          "partial_condition": "status = 'active'"
+        }
+      ]
+    }
+  }
+}
+```
+
+## Query Patterns Format
+
+For index optimization, provide query patterns in this format:
+
+```json
+{
+  "queries": [
+    {
+      "id": "user_lookup",
+      "type": "SELECT",
+      "table": "users",
+      "where_conditions": [
+        {
+          "column": "email",
+          "operator": "=",
+          "selectivity": 0.95
+        }
+      ],
+      "join_conditions": [
+        {
+          "local_column": "user_id",
+          "foreign_table": "orders",
+          "foreign_column": "id",
+          "join_type": "INNER"
+        }
+      ],
+      "order_by": [
+        {"column": "created_at", "direction": "DESC"}
+      ],
+      "frequency": 1000,
+      "avg_execution_time_ms": 5.2
+    }
+  ]
+}
+```
+
+## Best Practices
+
+### Schema Analysis
+1. **Start with DDL**: Use actual CREATE TABLE statements when possible
+2. **Include Constraints**: Capture all existing constraints and indexes
+3. **Consider History**: Some denormalization may be intentional for performance
+4. **Validate Results**: Review recommendations against business requirements
+
+### Index Optimization  
+1. **Real Query Patterns**: Use actual application queries, not theoretical ones
+2. **Include Frequency**: Query frequency is crucial for prioritization
+3. **Monitor Performance**: Validate recommendations with actual performance testing
+4. **Gradual Implementation**: Add indexes incrementally and monitor impact
+
+### Migration Planning
+1. **Test Migrations**: Always test on non-production environments first
+2. **Backup First**: Ensure complete backups before running migrations
+3. **Monitor Progress**: Watch for locks and performance impacts during execution
+4. **Rollback Ready**: Have rollback procedures tested and ready
+
+## Advanced Usage
+
+### Custom Selectivity Estimation
+The index optimizer uses pattern-based selectivity estimation. You can improve accuracy by providing cardinality estimates in your schema JSON:
+
+```json
+{
+  "columns": {
+    "status": {
+      "type": "VARCHAR(20)",
+      "cardinality_estimate": 5  # Only 5 distinct values
+    }
+  }
+}
+```
+
+### Zero-Downtime Migration Strategy
+For production systems, use the zero-downtime flag to generate expand-contract migrations:
+
+1. **Expand Phase**: Add new columns/tables without constraints
+2. **Dual Write**: Application writes to both old and new structures  
+3. **Backfill**: Populate new structures with existing data
+4. **Contract Phase**: Remove old structures after validation
+
+### Integration with CI/CD
+Integrate these tools into your deployment pipeline:
+
+```bash
+# Schema validation in CI
+python schema_analyzer.py --input schema.sql --output-format json | \
+  jq '.constraint_analysis.total_issues' | \
+  test $(cat) -eq 0 || exit 1
+
+# Generate migrations automatically
+python migration_generator.py \
+  --current prod_schema.json \
+  --target new_schema.json \
+  --zero-downtime \
+  --output migration.sql
+```
+
+## Troubleshooting
+
+### Common Issues
+
+**"No tables found in input file"**
+- Ensure SQL DDL uses standard CREATE TABLE syntax
+- Check for syntax errors in DDL
+- Verify file encoding (UTF-8 recommended)
+
+**"Invalid JSON schema"**  
+- Validate JSON syntax with a JSON validator
+- Ensure all required fields are present
+- Check that foreign key references use "table.column" format
+
+**"Analysis shows no issues but problems exist"**
+- Tools use heuristic analysis - review recommendations carefully
+- Some design decisions may be intentional (denormalization for performance)
+- Consider domain-specific requirements not captured by general rules
+
+### Performance Tips
+
+**Large Schemas:**
+- Use `--output-format json` for machine processing
+- Consider analyzing subsets of tables for very large schemas
+- Provide cardinality estimates for better index recommendations
+
+**Complex Queries:**
+- Include actual execution times in query patterns
+- Provide realistic frequency estimates
+- Consider seasonal or usage pattern variations
+
+## Contributing
+
+This is a self-contained skill with no external dependencies. To extend functionality:
+
+1. Follow the existing code patterns
+2. Maintain Python standard library only requirement
+3. Add comprehensive test cases for new features
+4. Update documentation and examples
+
+## License
+
+This database designer skill is part of the claude-skills collection and follows the same licensing terms.

package/bundled-skills/database-designer/SKILL.md

@@ -0,0 +1,314 @@
+---
+name: "database-designer"
+description: "Use when the user asks to design database schemas, plan data migrations, optimize queries, choose between SQL and NoSQL, or model data relationships."
+---
+
+# Database Designer - POWERFUL Tier Skill
+
+## Overview
+
+A comprehensive database design skill that provides expert-level analysis, optimization, and migration capabilities for modern database systems. This skill combines theoretical principles with practical tools to help architects and developers create scalable, performant, and maintainable database schemas.
+
+## Core Competencies
+
+### Schema Design & Analysis
+- **Normalization Analysis**: Automated detection of normalization levels (1NF through BCNF)
+- **Denormalization Strategy**: Smart recommendations for performance optimization
+- **Data Type Optimization**: Identification of inappropriate types and size issues
+- **Constraint Analysis**: Missing foreign keys, unique constraints, and null checks
+- **Naming Convention Validation**: Consistent table and column naming patterns
+- **ERD Generation**: Automatic Mermaid diagram creation from DDL
+
+### Index Optimization
+- **Index Gap Analysis**: Identification of missing indexes on foreign keys and query patterns
+- **Composite Index Strategy**: Optimal column ordering for multi-column indexes
+- **Index Redundancy Detection**: Elimination of overlapping and unused indexes
+- **Performance Impact Modeling**: Selectivity estimation and query cost analysis
+- **Index Type Selection**: B-tree, hash, partial, covering, and specialized indexes
+
+### Migration Management
+- **Zero-Downtime Migrations**: Expand-contract pattern implementation
+- **Schema Evolution**: Safe column additions, deletions, and type changes
+- **Data Migration Scripts**: Automated data transformation and validation
+- **Rollback Strategy**: Complete reversal capabilities with validation
+- **Execution Planning**: Ordered migration steps with dependency resolution
+
+## Tool Workflow (run these — do not analyze schemas by hand)
+
+All paths relative to this skill folder; sample inputs in `assets/`.
+
+### 1. Analyze the schema
+
+```bash
+python3 schema_analyzer.py --input schema.sql --generate-erd --output-format json -o analysis.json
+```
+
+Accepts SQL DDL or JSON schema (`assets/sample_schema.sql` / `sample_schema.json`). Output includes normalization findings, missing constraints, naming issues, and a Mermaid ERD — show the ERD to the user and fix flagged issues before optimizing.
+
+### 2. Optimize indexes against real query patterns
+
+```bash
+python3 index_optimizer.py --schema assets/sample_schema.json --queries assets/sample_query_patterns.json --analyze-existing --format json -o indexes.json
+```
+
+Write the user's hot queries into a query-patterns JSON first (copy `assets/sample_query_patterns.json`). Output is a priority-ordered list of CREATE INDEX recommendations plus redundant-index removals.
+
+### 3. Generate the migration
+
+```bash
+python3 migration_generator.py --current current_schema.json --target target_schema.json --zero-downtime --format sql -o migration.sql
+```
+
+`--zero-downtime` emits an expand-contract plan; `--validate-only` checks feasibility without generating SQL.
+
+### 4. Verification loop
+
+Re-run step 1 on the *target* schema and assert the issues found in the first pass are gone; run `migration_generator.py --validate-only` before handing over the migration.
+
+## Database Design Principles
+→ See references/database-design-reference.md for details
+
+## Best Practices
+
+### Schema Design
+1. **Use meaningful names**: Clear, consistent naming conventions
+2. **Choose appropriate data types**: Right-sized columns for storage efficiency
+3. **Define proper constraints**: Foreign keys, check constraints, unique indexes
+4. **Consider future growth**: Plan for scale from the beginning
+5. **Document relationships**: Clear foreign key relationships and business rules
+
+### Performance Optimization
+1. **Index strategically**: Cover common query patterns without over-indexing
+2. **Monitor query performance**: Regular analysis of slow queries
+3. **Partition large tables**: Improve query performance and maintenance
+4. **Use appropriate isolation levels**: Balance consistency with performance
+5. **Implement connection pooling**: Efficient resource utilization
+
+### Security Considerations
+1. **Principle of least privilege**: Grant minimal necessary permissions
+2. **Encrypt sensitive data**: At rest and in transit
+3. **Audit access patterns**: Monitor and log database access
+4. **Validate inputs**: Prevent SQL injection attacks
+5. **Regular security updates**: Keep database software current
+
+## Query Generation Patterns
+
+### SELECT with JOINs
+
+```sql
+-- INNER JOIN: only matching rows
+SELECT o.id, c.name, o.total
+FROM orders o
+INNER JOIN customers c ON c.id = o.customer_id;
+
+-- LEFT JOIN: all left rows, NULLs for non-matches
+SELECT c.name, COUNT(o.id) AS order_count
+FROM customers c
+LEFT JOIN orders o ON o.customer_id = c.id
+GROUP BY c.name;
+
+-- Self-join: hierarchical data (employees/managers)
+SELECT e.name AS employee, m.name AS manager
+FROM employees e
+LEFT JOIN employees m ON m.id = e.manager_id;
+```
+
+### Common Table Expressions (CTEs)
+
+```sql
+-- Recursive CTE for org chart
+WITH RECURSIVE org AS (
+  SELECT id, name, manager_id, 1 AS depth
+  FROM employees WHERE manager_id IS NULL
+  UNION ALL
+  SELECT e.id, e.name, e.manager_id, o.depth + 1
+  FROM employees e INNER JOIN org o ON o.id = e.manager_id
+)
+SELECT * FROM org ORDER BY depth, name;
+```
+
+### Window Functions
+
+```sql
+-- ROW_NUMBER for pagination / dedup
+SELECT *, ROW_NUMBER() OVER (PARTITION BY customer_id ORDER BY created_at DESC) AS rn
+FROM orders;
+
+-- RANK with gaps, DENSE_RANK without gaps
+SELECT name, score, RANK() OVER (ORDER BY score DESC) AS rank FROM leaderboard;
+
+-- LAG/LEAD for comparing adjacent rows
+SELECT date, revenue,
+  revenue - LAG(revenue) OVER (ORDER BY date) AS daily_change
+FROM daily_sales;
+```
+
+### Aggregation Patterns
+
+```sql
+-- FILTER clause (PostgreSQL) for conditional aggregation
+SELECT
+  COUNT(*) AS total,
+  COUNT(*) FILTER (WHERE status = 'active') AS active,
+  AVG(amount) FILTER (WHERE amount > 0) AS avg_positive
+FROM accounts;
+
+-- GROUPING SETS for multi-level rollups
+SELECT region, product, SUM(revenue)
+FROM sales
+GROUP BY GROUPING SETS ((region, product), (region), ());
+```
+
+---
+
+## Migration Patterns
+
+### Up/Down Migration Scripts
+
+Every migration must have a reversible counterpart. Name files with a timestamp prefix for ordering:
+
+```
+migrations/
+├── 20260101_000001_create_users.up.sql
+├── 20260101_000001_create_users.down.sql
+├── 20260115_000002_add_users_email_index.up.sql
+└── 20260115_000002_add_users_email_index.down.sql
+```
+
+### Zero-Downtime Migrations (Expand/Contract)
+
+Use the expand-contract pattern to avoid locking or breaking running code:
+
+1. **Expand** — add the new column/table (nullable, with default)
+2. **Migrate data** — backfill in batches; dual-write from application
+3. **Transition** — application reads from new column; stop writing to old
+4. **Contract** — drop old column in a follow-up migration
+
+### Data Backfill Strategies
+
+```sql
+-- Batch update to avoid long-running locks
+UPDATE users SET email_normalized = LOWER(email)
+WHERE id IN (SELECT id FROM users WHERE email_normalized IS NULL LIMIT 5000);
+-- Repeat in a loop until 0 rows affected
+```
+
+### Rollback Procedures
+
+- Always test the `down.sql` in staging before deploying `up.sql` to production
+- Keep rollback window short — if the contract step has run, rollback requires a new forward migration
+- For irreversible changes (dropping columns with data), take a logical backup first
+
+---
+
+## Performance Optimization
+
+### Indexing Strategies
+
+| Index Type | Use Case | Example |
+|------------|----------|---------|
+| **B-tree** (default) | Equality, range, ORDER BY | `CREATE INDEX idx_users_email ON users(email);` |
+| **GIN** | Full-text search, JSONB, arrays | `CREATE INDEX idx_docs_body ON docs USING gin(to_tsvector('english', body));` |
+| **GiST** | Geometry, range types, nearest-neighbor | `CREATE INDEX idx_locations ON places USING gist(coords);` |
+| **Partial** | Subset of rows (reduce size) | `CREATE INDEX idx_active ON users(email) WHERE active = true;` |
+| **Covering** | Index-only scans | `CREATE INDEX idx_cov ON orders(customer_id) INCLUDE (total, created_at);` |
+
+### EXPLAIN Plan Reading
+
+```sql
+EXPLAIN (ANALYZE, BUFFERS, FORMAT TEXT) SELECT ...;
+```
+
+Key signals to watch:
+- **Seq Scan** on large tables — missing index
+- **Nested Loop** with high row estimates — consider hash/merge join or add index
+- **Buffers shared read** much higher than **hit** — working set exceeds memory
+
+### N+1 Query Detection
+
+Symptoms: application issues one query per row (e.g., fetching related records in a loop).
+
+Fixes:
+- Use `JOIN` or subquery to fetch in one round-trip
+- ORM eager loading (`select_related` / `includes` / `with`)
+- DataLoader pattern for GraphQL resolvers
+
+### Connection Pooling
+
+| Tool | Protocol | Best For |
+|------|----------|----------|
+| **PgBouncer** | PostgreSQL | Transaction/statement pooling, low overhead |
+| **ProxySQL** | MySQL | Query routing, read/write splitting |
+| **Built-in pool** (HikariCP, SQLAlchemy pool) | Any | Application-level pooling |
+
+**Rule of thumb:** Set pool size to `(2 * CPU cores) + disk spindles`. For cloud SSDs, start with `2 * vCPUs` and tune.
+
+### Read Replicas and Query Routing
+
+- Route all `SELECT` queries to replicas; writes to primary
+- Account for replication lag (typically <1s for async, 0 for sync)
+- Use `pg_last_wal_replay_lsn()` to detect lag before reading critical data
+
+---
+
+## Multi-Database Decision Matrix
+
+| Criteria | PostgreSQL | MySQL | SQLite | SQL Server |
+|----------|-----------|-------|--------|------------|
+| **Best for** | Complex queries, JSONB, extensions | Web apps, read-heavy workloads | Embedded, dev/test, edge | Enterprise .NET stacks |
+| **JSON support** | Excellent (JSONB + GIN) | Good (JSON type) | Minimal | Good (OPENJSON) |
+| **Replication** | Streaming, logical | Group replication, InnoDB cluster | N/A | Always On AG |
+| **Licensing** | Open source (PostgreSQL License) | Open source (GPL) / commercial | Public domain | Commercial |
+| **Max practical size** | Multi-TB | Multi-TB | ~1 TB (single-writer) | Multi-TB |
+
+**When to choose:**
+- **PostgreSQL** — default choice for new projects; best extensibility and standards compliance
+- **MySQL** — existing MySQL ecosystem; simple read-heavy web applications
+- **SQLite** — mobile apps, CLI tools, unit test databases, IoT/edge
+- **SQL Server** — mandated by enterprise policy; deep .NET/Azure integration
+
+### NoSQL Considerations
+
+| Database | Model | Use When |
+|----------|-------|----------|
+| **MongoDB** | Document | Schema flexibility, rapid prototyping, content management |
+| **Redis** | Key-value / cache | Session store, rate limiting, leaderboards, pub/sub |
+| **DynamoDB** | Wide-column | Serverless AWS apps, single-digit-ms latency at any scale |
+
+> Use SQL as default. Reach for NoSQL only when the access pattern clearly benefits from it.
+
+---
+
+## Sharding & Replication
+
+### Horizontal vs Vertical Partitioning
+
+- **Vertical partitioning**: Split columns across tables (e.g., separate BLOB columns). Reduces I/O for narrow queries.
+- **Horizontal partitioning (sharding)**: Split rows across databases/servers. Required when a single node cannot hold the dataset or handle the throughput.
+
+### Sharding Strategies
+
+| Strategy | How It Works | Pros | Cons |
+|----------|-------------|------|------|
+| **Hash** | `shard = hash(key) % N` | Even distribution | Resharding is expensive |
+| **Range** | Shard by date or ID range | Simple, good for time-series | Hot spots on latest shard |
+| **Geographic** | Shard by user region | Data locality, compliance | Cross-region queries are hard |
+
+### Replication Patterns
+
+| Pattern | Consistency | Latency | Use Case |
+|---------|------------|---------|----------|
+| **Synchronous** | Strong | Higher write latency | Financial transactions |
+| **Asynchronous** | Eventual | Low write latency | Read-heavy web apps |
+| **Semi-synchronous** | At-least-one replica confirmed | Moderate | Balance of safety and speed |
+
+---
+
+## Cross-References
+
+- **sql-database-assistant** — query writing, optimization, and debugging for day-to-day SQL work
+- **database-schema-designer** — ERD modeling, normalization analysis, and schema generation
+- **migration-architect** — large-scale migration planning across database engines or major schema overhauls
+- **senior-backend** — application-layer patterns (connection pooling, ORM best practices)
+- **senior-devops** — infrastructure provisioning for database clusters and replicas
+