🏢 MULTI-TENANT SAAS & PLATFORMS
Data Isolation · Billing Workflows · Reconciliation
Production systems built around strict tenant boundaries (PostgreSQL RLS), automated recurring payment lifecycles, UPI AutoPay / e-mandate integration, and operational state machines.

⚙️ SYSTEMS & PIPELINE RUNTIMES
Rust Workspaces · DAG Runners · Hardware Auto-Dispatch
Modular, low-latency runtimes, directed acyclic graph (DAG) task execution, SIMD / GPU accelerator detection, and standards-compliant API surfaces.

🤖 EDGE AI & HARDWARE INTEGRATION
Computer Vision · Embedded Linux · Physical Sorting
Real-time object detection on edge devices (YOLO + Raspberry Pi), electromechanical actuation, sensor telemetry, and offline-first edge compute loops.

⚡ AI-NATIVE EXECUTION
Augmented Velocity · Human Architectural Ownership
Leveraging intelligent agentic workflows to accelerate exploratory prototyping and eliminate repetitive code, while maintaining rigorous human judgment on boundaries, security, and schema invariants.

Commercial multi-tenant platform automating end-to-end hostel operations, occupancy tracking, and recurring financial reconciliation. Independently architected, developed, and deployed to production.

• Multi-Tenant Boundary Isolation: Database-level isolation built on Supabase PostgreSQL with strict Row-Level Security (RLS) policies, guaranteeing ironclad data separation across tenant contexts.
• Automated Billing & Reconciliation: Recurring billing pipeline integrated with UPI AutoPay (e-mandates), handling automated invoicing, payment state transitions, and reconciliation.
• Dynamic Operations & Pricing: Operational state machine tracking rooms, beds, resident onboarding/offboarding lifecycles, and occupancy-based dynamic rate adjustments.
• Full-Stack Delivery: Production Next.js web application paired with a cross-platform React Native Android mobile client.

Next.js Web & React Native App
      │ HTTPS / JWT Auth
      ▼
┌──────────────────────────────────────────┐
│            DORMICO ECOSYSTEM             │
│  ┌────────────────────────────────────┐  │
│  │ Supabase PostgreSQL + RLS Policies │  │
│  │ (Strict Multi-Tenant Isolation)    │  │
│  └───────┬────────────────────┬───────┘  │
│          ▼                    ▼          │
│  ┌───────────────┐    ┌───────────────┐  │
│  │ UPI AutoPay   │    │  Dynamic Bed  │  │
│  │ Mandate Engine│    │ State Machine │  │
│  └───────────────┘    └───────────────┘  │
└──────────────────────────────────────────┘

• Web Interface: Next.js, React, Tailwind CSS
• Mobile Client: React Native / Expo (Android)
• Data & Auth: PostgreSQL, Supabase (RLS), Supabase Auth
• Payments: UPI AutoPay, Mandate Workflows, Webhook Handlers
• State & Cloud: REST APIs, Cloud Functions, Edge CDN

Modular speech synthesis server and visual workflow runner. Unifies 10+ local and cloud speech engines behind a single Rust core with zero-latency streaming.

• Modular Rust Workspace: Decoupled crates (voxforg-api, voxforg-hardware, voxforg-pipeline, voxforg-cli) powered by Axum.
• Hardware-Aware Adaptive Dispatch: Auto-detects CPU vector extensions (AVX2, AVX-512, NEON) and GPU acceleration (CUDA, Apple MPS, DirectML) to dynamically allocate optimal engine models.
• DAG Pipeline Runner: Node-based directed acyclic graph builder to chain multi-speaker audio graphs, prosody controls, and pause markers.
• Tri-Tier Storage: Zero-dependency SQLite (WAL mode) for desktop, PostgreSQL for Docker self-hosting, and Supabase RLS for multi-tenant deployments.
• API & Security: OpenAI-compatible /v1/audio/speech endpoint, token-bucket rate limiting, and granular scope permissions (tts:read, tts:write, pipeline:admin).

Client App (Web / OpenAI SDK)
      │ HTTP / WebSocket
      ▼
┌──────────────────────────────────────────┐
│             VOXFORG DAEMON               │
│  ┌────────────────┐  ┌────────────────┐  │
│  │  voxforg-api   │  │voxforg-hardware│  │
│  │ (Axum 0.8/Auth)│  │(CUDA/MPS/AVX)  │  │
│  └───────┬────────┘  └───────┬────────┘  │
│          ▼                   ▼           │
│  ┌────────────────────────────────────┐  │
│  │          DAG Audio Runner          │  │
│  │ (Piper / Kokoro / Edge-TTS Relays) │  │
│  └────────────────────────────────────┘  │
└──────────────────────────────────────────┘

Stack: Rust · Axum · React 19 · TypeScript · Docker · SQLite/PostgreSQL

Automated waste classification and physical mechanical routing system engineered for real-time edge execution.

• Edge Computer Vision: Custom-trained YOLOv11 model running locally on Raspberry Pi 4 for real-time item detection and 4-way stream classification (Plastic, Metal, Paper, Glass).
• Physical Actuation: Dual-axis servo mechanical guide powered by a PCA9685 16-channel PWM driver and high-torque MG996R servos.
• Sub-2-Second Cycle: IR proximity sensor triggers image capture only on insertion, completing inference and mechanical sorting in under 2 seconds.
• Telemetry & Monitoring: Four HC-SR04 ultrasonic sensors track fill levels per compartment with automated alert thresholds.
• Offline-First Resilience: Self-contained edge inference runs without requiring persistent cloud network connectivity.

Waste Insertion ──► IR Trigger ──► Pi Camera Module
                                          │
                                          ▼
┌──────────────────────────────────────────────────┐
│           EDGE RUNTIME (RASPBERRY PI 4)          │
│  YOLOv11 Tensor Inference (<2s Latency)          │
│  [Plastic]     [Metal]     [Paper]     [Glass]   │
└─────────────────────────┬────────────────────────┘
                          ▼
             PCA9685 PWM Servo Mechanism

Stack: Python · YOLOv11 · Raspberry Pi 4 · OpenCV · PCA9685/PWM · Sensors

• Rapid exploratory prototyping and API contract mocking.
• Elimination of repetitive boilerplate across client/server boundaries.
• Generating edge-case test vectors and synthetic validation scenarios.
• Accelerated documentation and structural refactoring.

• Multi-tenant data isolation and security boundary design.
• Database schema modeling and strict invariant validation.
• Concurrency, memory profiling, and low-level performance tradeoffs.
• Critical path debugging, telemetry instrumentation, and failure-mode analysis.

Product & Interfaces

• Next.js
• React
• React Native / Expo
• TypeScript
• Tailwind CSS

Backend & Data

• Node.js / Express
• FastAPI / Python
• PostgreSQL
• Supabase (RLS)
• Redis

Systems & Infra

• Rust (Axum, Cargo)
• Docker / Multi-Arch
• Linux Environments
• Cloudflare Workers / Edge
• CI/CD & Git Automation

AI & Edge

• YOLO (Computer Vision)
• OpenCV
• OpenAI API Architecture
• Raspberry Pi (GPIO / PWM)
• Embedded Linux Telemetry