Skip to content

Available for senior engineering roles

Muffeez KhalidSenior Software Engineer

I build enterprise-scale platforms in Angular, NestJS and PostgreSQL — multi-tenant, event-driven, and correct under retry — and the AI automation layer that increasingly sits on top of them: agents, RAG assistants and n8n workflows wired into systems that already run.

View selected workGet in touchRésumé (PDF)

  • 6+

    years building enterprise MEAN platforms

  • 99.8%

    production stability across releases

  • Millions

    users served on multi-tenant deployments

How I think about building software

Six years across enterprise Angular and NestJS platforms, most of it where a user-facing surface meets a system that has to stay correct for many organisations at once.

I started in front-end work, building Angular and React applications where the visible problem was almost always a symptom of something structural. A slow dashboard is rarely a slow component; it is usually a request waterfall or a query nobody planned. That is what pulled me toward the backend.

Since then I have spent most of my time on multi-tenant platforms — NestJS services over PostgreSQL and MongoDB, Kafka and RabbitMQ between them, Redis for caching and pub/sub — serving millions of users across organisations that each expect the product to feel like theirs. The two ends inform each other: knowing a consumer is idempotent is what lets a client retry safely, and knowing what the user actually waits for tells you which queue matters.

More recently that work has extended into AI automation: retrieval-augmented assistants grounded in an organisation’s own content, agents with a narrow and auditable set of tools, and n8n or Make.com orchestrating the steps that cross system boundaries. The engineering discipline is the same one as everywhere else — bound the blast radius, make the failure legible, and keep the facts somewhere you can correct them.

I care about the team as much as the system. Design reviews, real code review and TDD compound faster than any individual optimisation, and they are what make a codebase survivable eighteen months after the person who wrote it has moved on.

Education
BS Software EngineeringUniversity of Gujrat · 2017–2021
Based in
Lahore, PK · RemoteComfortable across EU and US time zones

  • Constraints over conventions

    The best bug fix is a constraint that makes the bug unrepresentable. Multi-tenant isolation enforced by the schema survives every code path written after you leave; the same rule checked in a service guard survives until the first batch job that forgets it.

  • The right tool for the delivery guarantee

    Kafka and RabbitMQ are not interchangeable. A replayable log and an acknowledged work queue solve different problems, and naming which one a feature needs settles most arguments about reliability before any code is written.

  • Ground the model, don't trust it

    Most reported AI hallucinations are retrieval failures in disguise. Facts belong in an index you can correct today, not in weights you would have to retrain. Fine-tuning is for tone and format; retrieval is for anything that can change.

  • Boring releases beat careful ones

    99.8% production stability came from Jest and Cypress suites gating every merge in CI, not from cautious deploys. When the pipeline is the gate, shipping stops being an event.

Experience

Roles where I owned an outcome rather than a ticket queue — with the numbers that actually moved.

  1. toPresent

    Senior Software Engineer (MEAN) · Classera

    Remote

    Architect enterprise-scale MEAN applications for multi-tenant education and commerce platforms serving millions of users, and build the AI automation layer on top of them.

    • Architected and maintained enterprise-scale Angular (v10+), Node.js and NestJS applications with NgRx for global state and RxJS for reactive data flows, supporting millions of users across multi-tenant environments.
    • Delivered real-time dashboards and notification systems on WebSockets, Firebase Realtime Database and Redis pub/sub for low-latency event broadcasting and session caching.
    • Built multi-tenant e-commerce and school administration platforms on PostgreSQL and TypeORM, ensuring secure data isolation and per-organisation customisation.
    • Implemented event-driven microservices with Apache Kafka for high-throughput streaming and RabbitMQ for reliable asynchronous queuing, improving decoupling and scalability.
    • Integrated AI assistants and agent workflows — retrieval-augmented generation over tenant content, LLM-backed chatbots, and n8n / Make.com automations wired into existing services.
    • Integrated third-party services via webhooks (Stripe, GitHub) and REST/GraphQL APIs for near real-time backend processing and instant UI updates.
    • Reached 99.8% production stability through TDD with Jest and Cypress, and shortened release cycles with automated GitLab CI/CD pipelines.
    • Angular
    • NestJS
    • Node.js
    • TypeScript
    • PostgreSQL
    • Kafka
    • RabbitMQ
    • Redis
    • RAG / LLM

  2. to

    Software Engineer · Emblem Technologies

    Lahore, Pakistan

    Full-stack MEAN engineer on real-time products, a high-traffic e-commerce platform and the analytics surfaces on top of them.

    • Developed real-time MEAN applications with Angular, Node.js, WebSockets and Firebase, using Redis for session caching and pub/sub messaging.
    • Built reusable, scalable Angular components and modules with TypeScript, RxJS and NgRx, cutting development time roughly 30% and keeping design consistent across products.
    • Contributed to a high-traffic e-commerce platform on Angular, NestJS, MongoDB and PostgreSQL with TypeORM, improving query performance and scalability.
    • Integrated RabbitMQ for asynchronous order processing and background jobs, decoupling core services and improving reliability under load.
    • Designed data-driven analytics dashboards with Angular and D3.js over REST APIs and Kafka-streamed events, delivering real-time insight to stakeholders.
    • Enforced quality through ESLint, Prettier, Jest unit tests and active code review across Agile sprints.
    • Angular
    • NestJS
    • MongoDB
    • PostgreSQL
    • RabbitMQ
    • Kafka
    • Redis
    • D3.js

  3. to

    Frontend Developer (Angular / React) · Bester Capital Media

    Lahore, Pakistan

    Built and maintained responsive marketing and product web applications across two frameworks, chosen per project.

    • Developed and maintained responsive applications in both Angular and React, picking the framework to fit the project rather than the habit.
    • Improved site performance by optimising image loading and adding caching, reducing initial load time by 15%.
    • Shipped front-end features that measurably improved engagement and conversion on key landing pages.
    • Worked directly with UX/UI designers and backend engineers to turn wireframes into functional, accessible pages.
    • Supported senior developers on application design with a focus on scalable component architecture.
    • Angular
    • React
    • TypeScript
    • SCSS
    • REST APIs

Technical range

Six years of depth in enterprise MEAN platforms, plus the AI automation layer that increasingly sits on top of them.

AI & Automation

Putting language models behind real workflows — grounded in your data, wired into the systems you already run, and observable enough to trust in production.

Agents & assistants

  • AI agents & tool use
  • Customer-facing chatbots
  • Multi-step agent workflows
  • Function / tool calling
  • Human-in-the-loop review

Retrieval & models

  • RAG pipelines
  • Embeddings & vector search
  • LLM fine-tuning
  • Prompt engineering & evals
  • Chunking & re-ranking

Orchestration

  • n8n
  • Make.com
  • Webhook & event triggers
  • API & CRM integrations
  • Scheduled & queued jobs

  • Frontend

    Enterprise Angular at scale, and React where it fits better.

    • Angular (v10+)
    • React
    • TypeScript
    • JavaScript (ES6+)
    • NgRx / NgXs / RxJS
    • Nx micro-frontends
    • SSR & SSG
    • SCSS · Responsive · WCAG

  • Backend

    NestJS services with explicit boundaries and honest contracts.

    • Node.js
    • NestJS
    • Express.js
    • REST & GraphQL
    • WebSockets (Socket.IO)
    • TypeORM
    • Webhooks (Stripe, GitHub)
    • Multi-tenant APIs

  • Databases

    Relational and document stores, chosen per access pattern.

    • PostgreSQL
    • MongoDB
    • Redis (cache & pub/sub)
    • SQL Server
    • Firebase Firestore & Realtime DB
    • Vector stores
    • Query tuning & indexing

  • Cloud & DevOps

    Containerised services and pipelines that are boring on purpose.

    • AWS (EC2, S3)
    • Azure
    • Firebase
    • Docker
    • Kubernetes
    • GitLab CI / GitHub Actions
    • Git & GitFlow

  • Architecture

    Multi-tenancy, event-driven services and clean boundaries.

    • Multi-tenant architecture
    • Event-driven microservices
    • Clean architecture
    • Nx monorepos
    • Domain modelling
    • Caching strategy
    • Incremental migration

  • Messaging & Real-time

    Delivery guarantees stated out loud, then enforced in code.

    • Apache Kafka
    • RabbitMQ
    • Redis pub/sub
    • WebSockets
    • Background job queues
    • Async order processing
    • Dead-letter handling
Testing & quality
  • Jest
  • Cypress
  • Selenium
  • React Testing Library
  • TDD
  • ESLint
  • Prettier
  • Agile (Scrum / Kanban)

Selected work

Three problems worth the space to explain properly: what was broken, what I changed, and what it was worth.

  • 2023 — presentSenior Software Engineer · Classera

    Multi-Tenant Education & Commerce Platform

    One codebase, many organisations, millions of users

    Problem
    A single platform had to serve many independent organisations — schools, districts and storefronts — each expecting its own data, branding and rules. Tenancy handled in application code is one forgotten WHERE clause away from a data leak, and a shared request path means one busy tenant degrades everyone else.
    Solution
    Multi-tenancy pushed into the schema rather than defended in the service layer, with PostgreSQL and TypeORM enforcing isolation, and an event-driven backbone that keeps slow work off the request path. Kafka carries high-throughput streams, RabbitMQ carries work that must not be lost, and Redis handles caching and pub/sub fan-out.
    • Angular
    • NestJS
    • TypeScript
    • PostgreSQL
    • TypeORM
    • Kafka
    • RabbitMQ
    • Redis

    Impact

    users across tenant organisations
    Millionsusers across tenant organisations
    production stability
    99.8%production stability
    data isolation and customisation
    Per-tenantdata isolation and customisation

    Read the case study

  • 2024 — presentDesign and implementation

    AI Automation & Agent Layer

    Assistants, RAG and n8n workflows wired into production systems

    Problem
    A general-purpose chatbot bolted onto a product is a demo. It does not know your data, cannot take action, and confidently invents answers the moment a question falls outside its training. The useful version has to be grounded in the organisation's own content and able to actually do something at the end of the conversation.
    Solution
    Retrieval-augmented generation over tenant-scoped content, agents with a narrow set of real tools rather than open-ended autonomy, and n8n / Make.com orchestrating the steps that touch external systems. Every answer cites what it retrieved, and every action a model can take is one a human could audit afterwards.
    • LLM APIs
    • RAG
    • Vector search
    • Fine-tuning
    • n8n
    • Make.com
    • NestJS
    • TypeScript

    Impact

    answers grounded in tenant content, with citations
    RAGanswers grounded in tenant content, with citations
    workflow orchestration across systems
    n8n + Makeworkflow orchestration across systems
    always-on assistant coverage
    24/7always-on assistant coverage

    Read the case study

  • 2022 — 2023Software Engineer · Emblem Technologies

    High-Traffic Commerce & Analytics

    Async order processing and real-time dashboards over streamed events

    Problem
    Order processing sat on the request path, so traffic spikes turned into timeouts at exactly the moment orders mattered most. Meanwhile every product team was rebuilding the same Angular components slightly differently, and stakeholders were asking for insight the reporting layer could not deliver live.
    Solution
    Order work moved behind RabbitMQ so the checkout request returns as soon as the order is durable. A shared, typed Angular component library replaced the per-team reimplementations. Analytics dashboards were built on Kafka-streamed events, so what stakeholders saw reflected the system rather than last night's batch.
    • Angular
    • NestJS
    • MongoDB
    • PostgreSQL
    • RabbitMQ
    • Kafka
    • Redis
    • D3.js

    Impact

    development time via shared component modules
    −30%development time via shared component modules
    analytics over Kafka-streamed events
    Real-timeanalytics over Kafka-streamed events
    order processing under peak load
    Decoupledorder processing under peak load

    Read the case study

Systems I build

The reference shape behind the work above: a multi-tenant platform where the request path stays synchronous only for as long as it must, with the AI layer inheriting the same isolation rules. Select any component for the reasoning behind it.

Dashed edges are asynchronous. Scroll horizontally on small screens.

Legend

  • Client
  • Edge
  • Service
  • Datastore
  • Cache
  • Message log

Select a component to see why it is there and what guarantee it provides.

Writing

Notes on the decisions that were hard to make and harder to reverse.

All articles

Get in touch

Open to senior and staff engineering roles, and to AI automation work — agents, RAG assistants and workflow builds. Always happy to talk through a gnarly performance or distributed-systems problem.

Based Lahore, PK · Remote. Comfortable across European and US-East time zones.