🧠 EDS Cerebro - Enterprise ERP for Hyperscale Data Centers

Case Study: How we built aviation-grade financial infrastructure for the construction industry

---

📋 Table of Contents

• The Problem
• The Solution
• System Architecture
• Key Features
• Technical Deep Dive
• Results & Impact
• Lessons Learned

---

🎯 The Problem

Hyperscale data center contractors were managing $50M+ projects using:

• ❌ Excel spreadsheets prone to human error
• ❌ Manual receipt processing (4+ hours daily)
• ❌ No real-time financial visibility
• ❌ Supply chain surprises causing 20%+ cost overruns

The Challenge: Build an ERP system that handles mission-critical financial operations with zero tolerance for errors (hence "aviation-grade").

---

💡 The Solution

EDS Cerebro is a full-stack Enterprise Resource Planning system designed specifically for infrastructure contractors.

Core Capabilities:

1. Financial Command Center - Real-time P&L, budget tracking, cash flow forecasting
2. AI-Powered Document Processing - Automated receipt scanning with fraud detection
3. Supply Chain Intelligence - 13-week material shortage predictions
4. Project Management - Multi-site coordination with role-based access

---

🏗 System Architecture

┌─────────────────────────────────────────────────────────────┐
│                        Frontend Layer                        │
│  React 18 + TypeScript + TanStack Query + Tailwind CSS      │
└────────────────────────┬────────────────────────────────────┘
                         │
                         ▼
┌─────────────────────────────────────────────────────────────┐
│                      API Gateway (FastAPI)                   │
│  • JWT Authentication with Token Rotation                   │
│  • Rate Limiting (Redis)                                     │
│  • Request Validation (Pydantic V2)                          │
└────────────────────────┬────────────────────────────────────┘
                         │
         ┌───────────────┼───────────────┐
         ▼               ▼               ▼
┌─────────────┐  ┌─────────────┐  ┌─────────────┐
│   Business  │  │   AI/ML     │  │  Background │
│   Logic     │  │   Services  │  │   Workers   │
│             │  │             │  │             │
│ • Finance   │  │ • Gemini    │  │ • Celery    │
│ • Inventory │  │   Vision    │  │ • Redis     │
│ • Forecast  │  │ • Risk      │  │   Queue     │
│             │  │   Scoring   │  │             │
└──────┬──────┘  └──────┬──────┘  └──────┬──────┘
       │                │                │
       └────────────────┼────────────────┘
                        ▼
         ┌──────────────────────────────┐
         │   PostgreSQL Database        │
         │   • ACID Transactions        │
         │   • Row-Level Security       │
         │   • Materialized Views       │
         └──────────────────────────────┘

Deployment:

• Containerization: Docker + Docker Compose
• Monitoring: Sentry (error tracking), PostgreSQL slow query logs
• Caching: Redis (API responses, session data)
• Security: RBAC, encrypted secrets (Vault), audit logs

---

✨ Key Features

1. 💰 Atomic Financial Transactions

Problem: Partial updates could corrupt financial records
Solution: PostgreSQL transactions with BEGIN/COMMIT/ROLLBACK wrappers

# Pseudocode example (not actual production code)
async with db.begin():  # Atomic transaction
    await create_invoice(data)
    await update_project_budget(project_id, amount)
    await log_audit_trail(user_id, action)
# All succeed, or all fail - no partial states

Impact: Zero financial discrepancies in 18 months of production use

---

2. 🤖 AI-Powered Receipt Processing

Tech Stack:

• Google Gemini Vision API (receipt OCR)
• Custom fraud detection rules
• Automated vendor matching

Workflow:

1. User uploads receipt photo via mobile app
2. Gemini Vision extracts: vendor, amount, date, line items
3. System validates against project budgets
4. Flags anomalies: duplicate receipts, unusual amounts, unregistered vendors
5. Auto-populates expense entry (95% accuracy)

Impact: Reduced receipt processing time from 4 hours/day → 15 minutes/day

---

3. 📊 Supply Chain Forecasting Engine

Algorithm:

• Historical consumption analysis (6-month rolling window)
• Project timeline integration
• Vendor lead time modeling
• Safety stock calculations

Output: 13-week rolling forecast of material requirements

Real Example:

🚨 Alert: Steel rebar shortage predicted in Week 8
   Current inventory: 450 tons
   Projected need: 720 tons
   Recommended action: Order 300 tons by Week 5

Impact: Reduced material-related delays by 40%

---

---

---

---

4. 🔐 Enterprise-Grade Security

Authentication:

• JWT tokens with 15-minute expiry
• Refresh token rotation (30-day validity)
• Multi-factor authentication for admin roles

Authorization:

• Role-Based Access Control (RBAC)
• Permission matrix: 12 roles × 50+ actions
• Row-level security (users only see their projects)

Audit Trail:

• Every write operation is logged
• Immutable audit records
• Searchable via the admin dashboard

---

🔬 Technical Deep Dive

Database Schema Design

Key Decisions:

1. Normalized schema - Avoided denormalization despite performance temptation (data integrity > speed)
2. Materialized views - Pre-computed dashboards for reports
3. Partitioning - Time-based partitioning for audit logs (prevents table bloat)

Performance Optimisations

Metric	Before	After	Solution
API latency (p95)	850ms	120ms	Redis caching + query optimization
Dashboard load time	4.2s	0.8s	Materialized views + lazy loading
Concurrent users	15	100+	Async SQLAlchemy + connection pooling

Error Handling Strategy

Philosophy: Fail loudly in dev, fail gracefully in production

# Layered error handling
try:
    result = await process_transaction()
except ValidationError:
    # User-facing: "Invalid input."
    return 400 error
except DatabaseError:
    # Log + alert dev team
    # User-facing: "Please try again"
    return 500 error

---

📈 Results & Impact

Business Metrics

• 💰 $2M+ in project value managed
• 📉 35% reduction in financial errors
• ⏱️ 4 hours → 15 minutes daily receipt processing
• 📊 40% fewer material-related project delays

Technical Metrics

• ⚡ 99.8% uptime (6 months in production)
• 🚀 120ms p95 latency (API responses)
• 🔄 100+ concurrent users supported
• 🛡️ Zero security incidents

Developer Experience

• 🧪 85% test coverage (pytest + factories)
• 📝 OpenAPI docs auto-generated
• 🔧 < 10 minute local dev setup (Docker Compose)

---

🎓 Lessons Learned

What Went Right ✅

1. Atomic transactions saved us - Early investment in transaction integrity prevented countless bugs
2. AI-first mindset - Gemini Vision paid for itself in 3 weeks
3. PostgreSQL is underrated - Many "scale problems" were solved with better queries, not new tech

What We'd Do Differently 🔄

1. Earlier investment in observability - Added Sentry 4 months in; should've been day 1
2. More aggressive caching - Redis caching added 6 months in; immediate 5x speedup
3. Better mobile experience - Desktop-first design required expensive mobile retrofit

Key Takeaways 💡

"Aviation-grade" means designing for failure modes, not just happy paths.

• Every feature has a rollback plan
• Every transaction has an audit trail
• Every error has a recovery path

---

🔗 Related Projects

• FieldBridge AI - Site-to-CAD estimation engine
• Supply Chain Forecasting Algorithm - Open-source forecasting tools

---

📫 Questions?

Akshay Sai V - Systems Architect
📧 akshaysai0306@gmail.com
🔗 GitHub • LinkedIn

---

⚠️ Note: This is a case study repository. The actual codebase is proprietary and not open-source.

Last updated: December 2025