Registered Engineer (PEC) with a B.S. (Hons.) in Electrical Engineering from COMSATS University and a published research paper in MDPI Sustainability (IF 3.125). I transitioned from hardware systems engineering into applied AI, carrying with me the discipline of embedded constraints: strict tolerances, zero margin for failure, and deterministic outputs.

I do not build thin API wrappers over foundation models. I engineer end-to-end AI systems covering ETL, RAG, LLM applications, and MLOps. My production systems have handled 1,000+ daily clinical interactions at Allama Iqbal Hospital, while e-commerce automation at NovaSole supported 500,000+ monthly visitors.

My work spans Applied AI, Healthcare AI, FinTech, E-Commerce, Telecommunications, and Renewable Energy. Each domain sharpened a different engineering muscle: applied AI demanded production MLOps, healthcare demanded absolute correctness, fintech demanded extreme throughput, e-commerce demanded scale under pressure, telecom demanded operational resilience, and solar demanded hardware-software integration from first principles.

• AI Engineering & LLM Orchestration — Multi-agent architectures using LangGraph and LangChain for stateful, cyclic reasoning workflows with deterministic output enforcement.
• Enterprise Backend & Scalable APIs — Asynchronous microservices with FastAPI, Django, and Next.js engineered for sub-100ms response times under heavy concurrent load.
• Advanced RAG & Knowledge Systems — Corrective RAG (CRAG) pipelines with hybrid retrieval (dense + BM25 sparse), semantic chunking, and automated relevance grading to eliminate hallucinations.
• Voice AI & Real-Time Systems — WebSocket-first architectures achieving sub-500ms end-to-end latency for conversational AI with barge-in handling and live database queries.
• AI Security & Compliance — PII/PHI redaction using Microsoft Presidio and spaCy NLP, prompt injection defense, and HIPAA-principled data pipelines.
• Workflow Automation — Highly parallelized n8n execution graphs (16-node branching) for cross-departmental operational synchronization.

1. Determinism over probability. LLMs are probabilistic by nature; my job is to make their outputs deterministic through evaluation pipelines, structured output schemas, and Corrective RAG. If a system cannot be tested, it cannot be trusted.
2. Latency is a feature. Every millisecond matters. I use Groq LPUs for intermediate grading (180ms), Celery workers for offloading heavy inference, and WebSocket streaming to begin TTS generation before the LLM finishes its sentence.
3. Security is architecture, not a layer. Row-Level Security in Supabase, NLP-based PII redaction before data leaves the network, zero-trust API boundaries. Security is designed in, not bolted on.
4. Observable by default. Structured JSON logging, CI/CD regression testing with DeepEval (Faithfulness, Answer Relevance), and SLA-grade monitoring. If it runs in production, it must be measurable.
5. Architecture outlasts tools. Frameworks change; well-designed system boundaries do not. I choose REST vs WebSockets, PostgreSQL vs Qdrant, and SSG vs RSC based on the problem's constraints, not market trends.

graph TD
    Client["Client Application"] -->|"REST / WebSockets"| Gateway["API Gateway"]

    subgraph Backend["Backend Infrastructure"]
        Gateway --> Auth["Auth Layer (JWT / Supabase)"]
        Auth --> Orchestrator["LangGraph Orchestrator"]
    end

    subgraph Security["Security & Knowledge Engine"]
        Orchestrator --> Guardrail["Guardrail Gateway (Presidio)"]
        Guardrail --> CRAG["Corrective RAG Pipeline"]
        CRAG --> VectorDB[("Qdrant / ChromaDB")]
        VectorDB --> Grader["Groq LPU Relevance Grader"]
    end

    Grader -- "Pass" --> LLM["Generation LLM (GPT-4o)"]
    Grader -- "Fail" --> Fallback["Web Search Fallback"]
    Fallback --> LLM
    LLM --> Response["Verified Response"]
    Response --> Gateway

Domain: Enterprise AI / Retrieval-Augmented Generation Problem: Standard RAG systems hallucinate when vector retrieval returns irrelevant documents. In regulated industries, a confidently wrong answer is worse than no answer. Architecture: LangChain DAG implementing Corrective RAG (CRAG). Qdrant for hybrid retrieval (dense + BM25). Groq LPU grades relevance in 180ms; failures trigger automated query rewriting and web-search fallback via Tavily. Stack: FastAPI, Qdrant, LangChain, Groq (Llama 3), OpenAI (GPT-4o) Impact: Drove hallucination rates to zero through multi-hop evaluation before generation, establishing the architecture later deployed at Allama Iqbal Hospital.

Domain: AI Security / Healthcare Compliance Problem: Hospitals need LLMs to summarize patient data, but sending raw medical records to external APIs violates HIPAA and GDPR. Architecture: FastAPI reverse proxy intercepting all outbound LLM requests. Microsoft Presidio (backed by spaCy NER) detects and redacts 18+ PII/PHI entity types. Optional re-identification maps placeholders back on the secure internal network. Stack: FastAPI, Microsoft Presidio, spaCy, Docker, Nginx Impact: Enabled HIPAA-principled LLM adoption in a clinical environment. Custom Presidio recognizers handle Pakistani medical ID formats with near-zero false positives.

Domain: Enterprise Voice AI Problem: Text-based LLM APIs introduce 1.5+ second latency, destroying conversational trust in automated customer triage. Architecture: WebSocket-first Django backend using Django Channels (ASGI). Integrates Vapi.ai/Retell AI telephony with a LangGraph state machine. LLM tokens stream directly to Deepgram TTS chunk-by-chunk, enabling audio generation before sentence completion. Stack: Django, Django Channels, WebSockets, LangGraph, Groq LPU (Llama 3) Impact: Achieved sub-500ms end-to-end response latency with deterministic barge-in handling, enabling real-time interruption and live database queries during active calls.

flowchart LR
    Query["User Query"] --> Router["Intent Router"]
    Router --> Retrieve["Vector Retrieval (Qdrant)"]
    Retrieve --> Grade["Relevance Grading (Groq)"]
    Grade -- "Relevant" --> Generate["Final Generation (GPT-4o)"]
    Grade -- "Irrelevant" --> Rewrite["Query Rewriting"]
    Rewrite --> WebSearch["Web Search (Tavily)"]
    WebSearch --> Generate
    Generate --> Output["Verified Output"]

Domain: FinTech SaaS Problem: Financial institutions require sub-second dashboard latency while running heavy PyTorch inference for fraud detection without blocking API threads. Architecture: Decoupled microservices. Next.js App Router frontend, asynchronous FastAPI backend. PyTorch anomaly detection models served via dedicated Celery worker pools with Redis task queues. PostgreSQL with Row-Level Security. Stack: Next.js, FastAPI, PyTorch, PostgreSQL, Redis, Docker, GitHub Actions Impact: Sub-100ms API response times maintained under load. PCI-DSS compliant architecture with OAuth2/JWT authentication and granular RBAC.

Domain: AI Developer Tools / Open Source Problem: AI assistants lack context about codebase history and structure. Developers waste tokens manually pasting diffs and file trees. Architecture: TypeScript Node.js process implementing the Model Context Protocol (MCP) specification. Communicates with AI clients (Claude Desktop) via JSON-RPC over stdio. Executes read-only git commands with strict argument parsing to prevent arbitrary code execution. Stack: TypeScript, Node.js, MCP, JSON-RPC Impact: Published to NPM registry. Enables AI assistants to natively search git history, run git blame, and analyze repository structure without manual context injection.

sequenceDiagram
    participant User
    participant Telephony as Vapi.ai / Retell
    participant Backend as Django Channels
    participant Agent as LangGraph Agent
    participant LLM as Groq LPU
    participant TTS as Deepgram TTS

    User->>Telephony: Audio Stream (WebSocket)
    Telephony->>Backend: STT Transcript
    Backend->>Agent: Process Intent
    Agent->>LLM: Generate Response
    LLM-->>TTS: Stream Tokens (chunk-by-chunk)
    TTS-->>Telephony: Audio Stream
    Telephony-->>User: Voice Response
    Note over User,TTS: End-to-end latency under 500ms

stateDiagram-v2
    [*] --> Research
    Research --> Architecture : Requirements defined
    Architecture --> Implementation : System design approved
    Implementation --> Testing : Code complete
    Testing --> Deployment : CI/CD passes
    Deployment --> Monitoring : Production release
    Monitoring --> Research : Telemetry feedback

Arshad J., Aziz M., et al. "Implementation of a LoRaWAN Based Smart Agriculture Decision Support System for Optimum Crop Yield." MDPI Sustainability, 2022; 14(2):827. Impact Factor: 3.125. DOI: 10.3390/su14020827

Award: Top Innovative FYP of the Year (2021) — IGNITE & Higher Education Commission of Pakistan.

Deepening enterprise RAG architectures with parent-child chunking strategies and metadata-filtered hybrid retrieval. Exploring on-device AI inference for latency-critical edge deployments. Building autonomous, self-correcting AI agents using LangGraph's cyclic state machines. Expanding into event-driven architectures (Kafka) and Infrastructure as Code (Terraform) for large-scale distributed AI systems.