08 / Deployed Systems & Projects
Flirtmetrics — Event-Driven Real-Time Matchmaking & Chat Optimization
CLIENT: Dating Startup | ROLE: Mobile Specialist & Flutter Developer | TIMELINE: 3 Months (2024)
Overview: Optimized a dating app matchmaking page and real-time chat infrastructure. Resolved critical UI thread blockages causing MATCH cards to freeze on swipe, and reduced chat delivery latency from 8 seconds to under 200ms by replacing HTTP short-polling with WebSockets.
The Challenge: Flirtmetrics experienced severe user churn because matchmaking screens froze for up to 1.5 seconds during card swipes (due to synchronous Riverpod state rebuilds of the entire card deck). Additionally, chat delivery suffered from an 8-second delay because the client relied on high-frequency HTTP short-polling, overwhelming network threads and triggering API rate limits.
Solution & Implementation: Designed and deployed a custom WebSocket connection manager in Flutter with heartbeat pinging and auto-reconnect logic. Implemented a local SQLite sync cache, allowing messages to render instantly offline while background threads sync remote state. Rewrote the card swiping widget using isolated state listeners to isolate builds to the swiped card only.
Architecture: Clean architecture implementation using Flutter Presentation layer (Riverpod states), Domain repositories, and Data sources (WebSocket stream client + SQLite offline DB cache). Back-end WebSockets route messages through a lightweight gateway.
Diagnostics: Overcoming CPU thread lockups on low-end mobile devices during card deck recalculations. Bridging dynamic UI transitions with concurrent local SQLite writing and WebSocket message streaming.
Key Metrics: Chat Latency: <200ms (from 8.2s delay) | UI Frame Rate: 60 FPS (stable swiping) | User Retention: +32% (post-release analytics) | App Rating: 4.8★ (iOS & Play Store)
Stack: Flutter, Riverpod, WebSockets, SQLite, Firebase, REST API
Links:[Optimization Report][Play Store][App Store][Website](GitHub: Private Repository (Access available upon request))
ERP Platform — Enterprise Supply Chain, Redis Caching & Ledger Performance Engineering
CLIENT: Agro-Industrial Corp | ROLE: Full-Stack Developer & Database Architect | TIMELINE: 5 Months (2025 - 2026)
Overview: Engineered a high-performance enterprise ERP suite for supply chain management, dealer orders, and multi-warehouse accounting. Implemented an asynchronous Redis micro-batch audit queue, pattern-based Redis cache invalidation for RBAC security, connection-pooled PostgreSQL with Prisma PG adapter, and an automated promotional bonus product lifecycle with COGS tracking.
The Challenge: An agro-industrial firm managing 100+ dealers relied on manual Excel ledgers and paper signature systems. This resulted in an average 24% stock discrepancy between warehouses and a 4-day latency to process orders. Financial reports took minutes to generate because raw SQL queries scanned millions of unindexed records under heavy lock contention, and audit log write spikes dragged down checkout throughput.
Solution & Implementation: Built an asynchronous Redis audit logging queue with micro-batching (50 records or 2s intervals) and a resilient in-memory fallback with a 5000-item backpressure cap. Designed pattern-based Redis caching (`invalidatePrefix`) with automated invalidation on RBAC role/user/warehouse updates. Added promotional bonus product support with promotional COGS tracking across sales orders, deliveries, and invoices, with balanced Journal Voucher (JV) posting for transaction fees.
Architecture: Decoupled Enterprise Architecture: Next.js App Router frontend communicating with a modular NestJS backend. PostgreSQL database layer optimized via Prisma PG adapter connection pooling. High-throughput mutations stream to an async Redis audit log queue, while WebSocket gateways broadcast real-time inventory updates and approval notifications.
Diagnostics: Preventing audit log writes from blocking critical order submission transactions during peak dealer dispatches, and eliminating security vulnerabilities caused by stale permissions cached in Redis. Resolved by building a non-blocking RxJS queue subscriber with batch flushing and hook-based cache eviction on user/role/warehouse mutations.
Key Metrics: Stock Error Rate: <0.8% (from 24% discrepancies) | Order Processing: <30m (from 4-day delays) | Audit Log Throughput: 50/batch (async Redis micro-batching) | Cache Latency: <5ms (Redis + auto fallback)
Stack: Next.js, React, NestJS, Node.js, Redis (ioredis), Prisma ORM, PostgreSQL, WebSockets, Tailwind CSS
Links:[Optimization Report][Live Demo](GitHub: Private Repository (Access available upon request))
NEGMP Proposal — National Environmental GIS Monitoring Platform
CLIENT: Ministry of Environment, Forests and Climate Change (Govt. of Bangladesh) | ROLE: System Architect & Proposal Author | TIMELINE: April 2026
Overview: A humble design proposal for a National Environmental GIS Monitoring Platform (NEGMP), submitted to the Ministry of Environment, Forests and Climate Change, Government of Bangladesh. Combining my background in Agriculture with local context from living in the Rajshahi pilot region, I designed a multi-layer monitoring blueprint. I treat this design as an open starting point, eager to adapt and refine it based on feedback from experienced GIS experts and forestry officials.
The Challenge: National plantation monitoring has historically relied on manual field logs, which can lead to reporting gaps. The government sought a way to integrate GPS and satellite-based confirmation. My goal was to design a conceptual path to close this gap, keeping in mind that actual field implementation requires deep listening and adapting to the workflows of local officers.
Solution & Implementation: Designed a conceptual 5-layer architecture centered around a flexible, universal GeoEntity data model. I proposed an offline-first Flutter application to support field workers in low-connectivity areas like the Barind Tract, and a satellite verification pipeline using Google Earth Engine API. I approached this design as a learner, understanding that production-grade remote sensing would rely on collaboration with experienced GIS specialists.
Architecture: Proposed 5-layer system: Backend API (NestJS + PostgreSQL/PostGIS/Prisma), Field Mobile App (Flutter + PWA fallback), Interactive Web Dashboard (Next.js + Leaflet.js / MapLibre GL), Satellite Verification Pipeline (Google Earth Engine API), and Identity/Auth (Keycloak OIDC).
Diagnostics: Designing a flexible data structure that allows future modules (like water level or weather) without complex database redesigns, while recognizing my own learning curve in Google Earth Engine remote sensing workflows.
Key Metrics: Plantation Target: 250M (trees over 5 years) | Pilot Region: Rajshahi (Barind Tract focus) | Verification: NDVI (Google Earth Engine) | Data Model: GeoEntity (universal spatial core)
Stack: NestJS, Next.js, Flutter, PostgreSQL, PostGIS, Google Earth Engine API, Keycloak, Leaflet.js, MapLibre GL, Redis, Prisma
Links:[Optimization Report](GitHub: Proposal Document (Submitted/Under Review))
HR Interview System — AI-Powered Autonomous Video & Voice Mock Interview Platform
CLIENT: Enterprise HR & Talent Acquisition | ROLE: Applied AI Engineer & Full-Stack Architect | TIMELINE: Nov 2025 – Apr 2026
Overview: Architected and engineered an end-to-end autonomous HR interview and assessment system inside WordPress. Orchestrated multi-modal AI pipelines utilizing OpenAI Whisper for speech-to-text transcription, OpenAI TTS for dynamic voice question synthesis, and GPT-4o for rubric-based candidate evaluation. Designed an interactive React 18 frontend with WebRTC recording, live waveform monitoring, and proctoring snapshots.
The Challenge: Enterprise hiring teams face bottlenecked recruitment pipelines: screening hundreds of candidate interviews consumes hundreds of manual engineering hours, produces inconsistent subjective evaluations, and introduces high scheduling latency. Off-the-shelf SaaS alternatives are rigid, cost-prohibitive, and lack explainable multi-parameter scoring rubrics for verbal, vocal, and non-verbal candidate performance.
Solution & Implementation: Engineered a standalone WordPress plugin with custom database schemas, tokenized candidate invitations, and a dual-build React 18 application (Candidate SPA & Super Admin Portal). Implemented an asynchronous background evaluation engine with status polling to prevent gateway timeouts during heavy LLM execution. Built an integrated site-wide token credit calculation subsystem with automated CSV exports.
Architecture: Decoupled WordPress & React Architecture: WordPress REST API (`/wp-json/his/v1/`) powering a modular React 18 frontend (Webpack 5, CSS Modules). Backend orchestrates OpenAI Whisper audio ingestion, TTS generation, GPT evaluation prompts, and relational tracking across sessions, invitations, and audio/video artifacts.
Diagnostics: Handling synchronous timeout thresholds on HTTP requests when transcribing long multi-question candidate audio answers and computing multi-metric AI scoring rubrics. Resolved via asynchronous job dispatching, status polling, and optimistic UI transitions. Mitigated client-side WebRTC audio capture inconsistencies across mobile and desktop browsers.
Key Metrics: Screening Time: -75% (from 45m manual screening) | STT Accuracy: 98.5% (Whisper audio transcription) | Async Latency: <3.2s (background status polling) | Completion Rate: 92% (React SPA step-by-step UX)
Stack: WordPress Plugin, React 18, OpenAI Whisper, GPT-4o, OpenAI TTS, WebRTC, PHP 8, REST API, CSS Modules, OneCloud Credits
Links:[Optimization Report](GitHub: Private Repository (Access available upon request))
Medical Interview Bot — Specialized Clinical AI Mock Interviewer & Diagnostics Viva Simulator
CLIENT: Medical Education & Healthcare Residency | ROLE: Applied AI Engineer & Clinical System Integrator | TIMELINE: Feb 2026 – Apr 2026
Overview: Engineered a specialized clinical mock interview and viva examination platform for medical doctors and residency candidates. Features multi-instance custom post type architecture allowing hospitals and institutions to deploy tailored AI examiners across clinical specialties (Surgery, Internal Medicine, Pediatrics), complete with automated CV document ingestion and tailored differential diagnosis questioning.
The Challenge: Medical candidates require rigorous viva voce examination simulations before high-stakes board certifications and residency matching. Generic AI chatbots fail to assess clinical reasoning, cannot parse complex medical CVs or surgical logbooks, lack clinical safety boundaries, and cannot evaluate vocal bedside communication style or differential diagnostic precision under pressure.
Solution & Implementation: Developed a multi-instance WordPress platform with custom post types (`interview_bot`) and CMB2 administration. Integrated document parsing engines (`smalot/pdf-parser`, `phpoffice/phpword`, `phpspreadsheet`) to extract candidate clinical background and dynamically formulate case scenarios via GPT-5-Nano and GPT-4o-mini. Integrated real-time WebRTC audio recording, Whisper transcription, WordPress media library cached TTS, and physical/voice diagnostic analysis.
Architecture: Custom WordPress CPT architecture with localized REST endpoints (`/wp-json/medbot/v1/`). Frontend WebRTC audio/video capture engine connects with modular PHP service layers that handle document parsing, OpenAI clinical persona prompt templates, credit metering per question, and diagnostic report generation.
Diagnostics: Ensuring strict clinical realism and terminology consistency across varied medical specialties while eliminating hallucinated medical protocols. Handled by structured clinical prompt engineering, differential diagnosis rubrics, and fail-safe fallback question repositories from curated Excel datasets.
Key Metrics: CV Question Gen: <2.4s (zero-shot clinical parsing) | Persona Accuracy: 99% (department-specific rubrics) | Candidate Rating: 4.9★ (clinical simulation reviews) | Audio Latency: <400ms (TTS media stream caching)
Stack: WordPress Plugin, OpenAI GPT-5-Nano, GPT-4o-mini, Whisper STT, OpenAI TTS, WebRTC, smalot/pdf-parser, PhpWord, PhpSpreadsheet, CMB2
Links:[Optimization Report](GitHub: Private Repository (Access available upon request))
Mentoro (Study Mentor) — Decoupled AI Study Mentor & Intelligent Learning Pack Generation Engine
CLIENT: EdTech Startup & University Learning | ROLE: Applied AI Engineer & Distributed Systems Architect | TIMELINE: May 2026 – Jul 2026
Overview: Architected and built a decoupled AI educational mentoring ecosystem consisting of a high-concurrency NestJS AI backend and a WordPress React SPA workstation frontend. Ingests multi-format study material—including dense lecture PDFs, Word documents, PowerPoint slides, and YouTube lecture transcripts—to automatically generate comprehensive study packs (flashcards, quizzes, revision notes) and provide rubric-based automated grading for student answers.
The Challenge: Students and educators spend hours distilling complex lecture slides, textbook PDFs, and video lectures into revision materials. Existing tools only offer fragmented features: simple flashcards without conceptual context, or generic multiple-choice quizzes with zero automated grading for open-ended comprehension answers (CQ) requiring mathematical formulas or diagrams.
Solution & Implementation: Designed a microservice architecture where a headless NestJS engine handles heavy document ingestion (`pdf-parse`, `mammoth`, `officeparser`, `youtube-transcript`) and structured prompt generation via GPT-4o. On the frontend, built a modern WordPress React SPA featuring a Question Player with an interactive HTML5 drawing canvas and LaTeX formula editor. Engineered an automated AI Evaluation engine with custom grading rubrics for student comprehension submissions.
Architecture: Decoupled Microservice Architecture: NestJS backend API with JWT authentication, Swagger documentation, and TypeORM relational data stores; paired with a WordPress plugin client hosting a React SPA Question Player. High-payload pipeline supports up to 25MB uploads and asynchronous job tracking via `mentor_processing_jobs`.
Diagnostics: Parsing heterogeneous file formats (Word, PDF, PowerPoint) without losing structural context, and extracting captions from YouTube videos with variable subtitle tracks. Solved by building a resilient multi-driver parser with fallback caption extractors, combined with structured JSON schema enforcement on OpenAI completions.
Key Metrics: Study Pack Gen: <8s (from 60m manual drafting) | Payload Capacity: 25MB (heavy PDF & lecture decks) | Rubric Precision: 96% (human evaluator benchmark) | Ingestion Formats: 4+ Types (PDF, DOCX, Office, YouTube)
Stack: NestJS, TypeScript, WordPress Plugin, React SPA, OpenAI GPT-4o, mammoth, officeparser, pdf-parse, youtube-transcript, Tailwind CSS, JWT Auth
Links:[Optimization Report](GitHub: Private Repository (Access available upon request))
WP AI Tools — Enterprise Multi-Model AI Productivity Suite & Vector Search RAG Hub
CLIENT: WordPress Enterprise Ecosystem | ROLE: Applied AI Engineer & Multi-Model Integrator | TIMELINE: Feb 2026 – Apr 2026
Overview: Engineered an all-in-one multi-model AI productivity suite plugin for WordPress. Integrates OpenAI Chat Completions, DALL-E 3 image generation, Whisper speech-to-text, OpenAI TTS, OpenAI Assistants API with Vector Stores for semantic document retrieval (RAG), and RunwayML video generation under a unified glassmorphic React interface with Mantine UI.
The Challenge: WordPress site owners and agencies face tool fatigue and high subscription overhead by installing 5+ disparate plugins for text generation, AI image creation, audio transcription, and internal file search. These disparate tools lead to security vulnerabilities, plugin conflicts, inconsistent UX, and an inability to govern and budget API costs across organization members.
Solution & Implementation: Built a consolidated multi-tool AI suite plugin with a modern React 18 SPA frontend (Mantine UI, `@wordpress/scripts`). Devised a three-tier configuration architecture (Global Options → Custom Post Type Instance Overrides → User Meta Budgets). Integrated the OpenAI Assistants API with vector stores for fast RAG file queries, alongside standardized AJAX gateways for DALL-E, Whisper, TTS, and RunwayML video advertising synthesis.
Architecture: Hybrid WordPress & React Architecture: WordPress backend with Custom Post Type (`wp_ai_tools`), custom tables (`wp_wat_img_to_ads`), and secure AJAX handlers (`includes/wat-ajax.php`). Modular React frontend with dedicated tool panels, streaming state updates, and real-time token credit gauges.
Diagnostics: Designing a flexible configuration inheritance system where site administrators can set global API keys and model parameters while allowing individual page builders to override models per widget instance. Resolved by engineering a three-tier settings resolution hierarchy (`wat_setting_value`).
Key Metrics: Unified Tools: 6-in-1 (Text, Vision, Audio, RAG, Video) | Token Cost Reduction: -40% (3-tier credit & cache logic) | Vector Query Time: <1.2s (Assistants API Vector Store) | UI Response: <150ms (Mantine & React App Router)
Stack: WordPress Plugin, React 18, Mantine UI, OpenAI Assistants API (Vector Stores), GPT-4o, DALL-E 3, Whisper STT, OpenAI TTS, RunwayML Gen-3/4, PHP 8
Links:[Optimization Report](GitHub: Private Repository (Access available upon request))