Clean architecture
Scalable application structure with clear boundaries between the interface, the service layer and the data — so features can be added without unpicking what already works.
01About
Full-stack engineering, built to last
I build scalable web applications end to end — REST APIs, authentication, databases and the interfaces on top of them.
I'm a full-stack software engineer with hands-on experience building scalable web applications using Next.js, React.js, NestJS and Node.js / Express.
My work covers REST and GraphQL API design, authentication and third-party integrations, backed by PostgreSQL, MySQL, MongoDB and Supabase. I build microservices and event-driven systems with real-time communication over WebSockets, SSE and message queues, and on the infrastructure side I work with Docker, Redis, AWS and GCP — containerising services, caching hot data paths and shipping through CI/CD pipelines on GitHub Actions.
Throughout, the focus stays the same: clean architecture, maintainable code and collaborative delivery through Git and GitHub. Based in Lahore, Pakistan, working on-site locally and remotely with distributed teams.
Full-stack ownership
React and Next.js on the front, Node.js, NestJS and Express behind it, and PostgreSQL, MongoDB or MySQL underneath — designed together rather than handed between teams.
Production-ready delivery
Authentication and third-party integrations implemented properly, performance optimised, complex issues resolved, and code kept at a standard that survives real usage.
Core strengths
What I bring to a build
- Full-Stack DevelopmentReact · Next.js · Node.js
- API DesignNestJS · REST · GraphQL · tRPC
- Database DesignPostgreSQL · MongoDB · Supabase · Prisma
- AuthenticationSSO · row-level security · access control
- Real-Time SystemsWebSockets · SSE · message queues
- AI & LLM WorkflowsRAG pipelines · vector databases
- Cloud InfrastructureDocker · Kubernetes · AWS · GCP
- Testing & QualityPlaywright E2E · integration testing
02Skills
The stack I reach for, and why
Tools are only worth listing if you know when not to use them. These are the ones I've shipped with in production.
The full toolkit · 78 technologies
JavaScript
The runtime underneath it all
TypeScript
Type-safe application code
Python
AI services and microservices
PHP
Server-side application code
SQL
Relational querying and modelling
Node.js
Async server runtime
NestJS
Modular, scalable services
Express.js
Lightweight HTTP services
FastAPI
Python services for AI workloads
Django
Batteries-included Python web
tRPC
End-to-end typed procedures
REST APIs
Secure, documented endpoints
GraphQL
Typed query APIs
Microservices
Independently deployable services
Event-driven architecture
Asynchronous, decoupled flows
BullMQ
Redis-backed background jobs
Next.js (App Router)
Server rendering and routing
React.js
Composable component UI
React Native
Cross-platform mobile apps
Redux
Predictable client state
Tailwind CSS
Design-system styling
Material-UI
Component-library interfaces
HTML5
Semantic, accessible markup
CSS3
Modern layout and styling
PostgreSQL
Relational transactional core
MySQL
Relational data workloads
MongoDB
Document data models
Redis
Caching and queues
Supabase
Postgres platform and auth
Prisma
Schema modelling and queries
TypeORM
Entity mapping for TypeScript
AlloyDB / pgvector
Vector search in Postgres
Multi-tenant SaaS
Isolation enforced in depth
WebSockets
Bidirectional real-time channels
SSE
Server-pushed event streams
Message queues
Buffered, reliable work handoff
Serverless (Lambda)
On-demand compute
AWS
Cloud infrastructure
GCP (GKE, Cloud Run)
Managed Kubernetes and containers
Docker
Containerised services
Kubernetes
Orchestrated container workloads
GitHub Actions
Automated build and deploy
CI/CD
Repeatable release pipelines
Git
Version control and review flow
S3
Object storage for files and media
RabbitMQ
Message broker for service events
Google Pub/Sub
Managed publish-subscribe
Apache Pulsar
Distributed event streaming
Terraform basics
Infrastructure as code
Vercel
Frontend deployment
Railway
Managed service hosting
OpenAI API
Model access for product features
Claude API
Model access for product features
Vertex AI (Gemini)
Managed models and embeddings
LLM workflows
Summarization and classification
RAG pipelines
Answers grounded in your corpus
Embeddings and vector search
Semantic retrieval over content
Vector databases
Storage built for similarity
Prompt engineering
Reliable, repeatable model output
Streaming responses
Token-by-token delivery to the UI
JWT auth
Stateless, verifiable sessions
RBAC and multi-tenancy
Roles scoped per tenant
Postgres RLS
Isolation enforced in the database
Keycloak SSO
Federated single sign-on
Stripe
Payments and transaction workflows
Square
Payment processing integration
HelloSign
Electronic signature workflows
Playwright
Browser end-to-end testing
Vitest
Fast unit and component tests
E2E testing
Coverage raised 5% → 70%
Integration testing
Services verified together
Turborepo
Monorepo builds and caching
Agile
Iterative, reviewed delivery
Cursor
AI-native editing workflow
Claude Code
Agentic refactoring and review
GitHub Copilot
Inline code completion
ChatGPT
Exploration and problem solving
Codex
Test generation and automation
03Experience
Professional engineering experience
Building and maintaining full-stack products that run in production.
Full Stack Engineer
Devsarch · Full-time
Apr 2026 — Present · 6 mosLahore, Punjab, Pakistan · On-siteArchitecture-through-production ownership of multi-tenant SaaS — real-time services, AI and RAG pipelines, and secure payment and healthcare integrations.
Own multi-tenant SaaS applications end to end, from architecture through production, using Next.js, React, TypeScript, NestJS, tRPC, PostgreSQL, Supabase, Prisma and REST/GraphQL APIs.
Designed microservices and event-driven systems with real-time communication over WebSockets, Pusher, SSE, Redis and message queues, optimizing applications for scalability and low latency.
Built production-grade AI/LLM workflows and RAG pipelines for summarization, classification, semantic search and automation, integrating vector databases to ground AI responses in product and customer data.
Delivered real-time platforms using Python microservices, deployed with Docker and Kubernetes on GCP/GKE through CI/CD pipelines and reliable deployment workflows.
Architected secure payment and healthcare solutions integrating Stripe, Square, HelloSign and Google APIs, implementing row-level security and secure data-access patterns for sensitive application data.
Applied Playwright E2E and integration testing alongside AI-assisted development tools (Cursor, Claude Code, GitHub Copilot, ChatGPT, Codex) to improve engineering productivity and code quality.
- Next.js
- React
- TypeScript
- NestJS
- tRPC
- GraphQL
- PostgreSQL
- Supabase
- Prisma
- WebSockets
- Redis
- Kubernetes
- GCP
- Docker
- Stripe
- Playwright
Remote
Full-time · 3 yrs 7 mos
United States · RemoteFull Stack Engineer
Jun 2024 — Mar 2026 · 1 yr 10 mosNode.js and TypeScript services behind a database-automation SaaS platform, alongside a substantial lift in test coverage and access control.
Developed and maintained Node.js/TypeScript services for database automation, monitoring, backups and failover within a core SaaS platform.
Increased Playwright E2E test coverage from 5% to 70%, reducing production regressions and improving release confidence.
Integrated Keycloak SSO and access control, and introduced a monorepo architecture for reusable components and scalable development.
Improved React/TypeScript UI responsiveness and dashboard performance across key platform modules.
- Node.js
- TypeScript
- React
- Playwright
- Keycloak
- Monorepo
Software Engineer
Sep 2022 — May 2024 · 1 yr 9 mosFull-stack product delivery with real-time features and Docker-based CI/CD pipelines deploying across four cloud providers.
Built and maintained full-stack products using React, Next.js, TypeScript, Node.js, NestJS, PostgreSQL, MongoDB and Supabase, owning features from development to production.
Developed scalable REST APIs, real-time features with WebSockets/SSE, and backend services using microservices and event-driven architectures.
Implemented Docker-based CI/CD pipelines with GitHub Actions, supporting reliable deployments across AWS, GCP, Vercel and Railway.
Added E2E and integration testing with Playwright and used AI-assisted development tools for refactoring, debugging, test generation and code exploration.
- React
- Next.js
- TypeScript
- Node.js
- NestJS
- PostgreSQL
- MongoDB
- Supabase
- Docker
- GitHub Actions
- AWS
- Playwright
Education
Education
BS in Computer Science
Virtual University
Sep 2020 — Jun 2024
04Featured case study
A SaaS platform built on clean architecture
A two-sided marketplace where homeowners buy inspection plans, receive an AI-assisted snagging report and collect bids from vetted vendors — React Native app, Next.js portals and NestJS services.
PropToc
Live SiteProperty snagging and maintenance marketplace
PropToc carries a homeowner from inspection to finished repairs without leaving the product. They buy a property inspection plan, receive an AI-assisted snagging report, and collect bids from vetted maintenance vendors. I built it end to end: a React Native customer app, Next.js admin and vendor portals, and NestJS services on PostgreSQL with file storage on S3.
My role
Full-stack development — architecture through production
- React Native
- Next.js
- NestJS
- PostgreSQL
- S3
- LLM
Live SiteGitHubprivate
Live demo — source code is private.
nestjs / modules
REST API
Scalable NestJS REST APIs serving core platform features
- Controller
- Service
- Repository
- Database
- GET /resourcescontroller → service
- POST /resourcesvalidated payload
- PATCH /resources/:idguarded route
Architecture diagram — illustrative, not a product screenshot.
What I built
01
Built a two-sided marketplace where homeowners buy property inspection plans, receive an AI-assisted snagging report and collect bids from vetted maintenance vendors: React Native customer app, Next.js admin and vendor portals, and NestJS services on PostgreSQL with file storage on S3.
02
Developed a report engine that turns structured inspection data into server-rendered PDFs with inline photos, severity indicators and a weighted Snag Score per property, with an LLM layer that cleans up inspector notes and drafts the summary.
03
Implemented anonymous sealed bidding: vendors can't see each other or the customer, and identities are revealed only once an offer is accepted.
04
Built a milestone payment flow (50% upfront, 50% on customer approval) with commission calculation on total project value, invoice generation, payout tracking and a dispute state that holds the final payment.
The problem
A homeowner has no structured way to record what is wrong with a property, price the fix fairly, or hold a vendor to the work. Defects go undocumented, quotes are not comparable because every vendor scopes the job differently, and paying up front removes all leverage once work begins.
The solution
One marketplace covering the whole chain. Inspection data becomes a severity-graded report with inline photos and a weighted Snag Score per property. That scoped defect list goes to vetted vendors who bid sealed and anonymous — no vendor sees another or the customer — so offers compare on price and timeline rather than on scope. Payment then splits 50/50 across milestones, with the final instalment held behind customer approval and a dispute state.
Architecture
01
Customer app
A React Native application where homeowners buy inspection plans, read reports and review bids.
02
Web portals
Next.js admin and vendor portals covering vendor onboarding, bidding and day-to-day operations.
03
API layer
NestJS services covering inspections, reports, bidding and the payment flow.
04
Data
PostgreSQL modelling properties, inspections, defects, bids and payment milestones.
05
File storage
Inspection photos and generated report PDFs stored on S3.
06
Payments
Commission calculated on total project value, with invoice generation and payout tracking.
Key functionality
The result
The marketplace takes a property from inspection to signed-off repairs in one place: defects are evidenced and scored rather than argued over, bids arrive comparable because every vendor quotes the same scope blind, and staged payments keep the homeowner's leverage until the work is approved.
05Selected work
Other platforms I've helped build
Product work across social media analytics and creator platforms — backend APIs, third-party integrations and the responsive interfaces on top of them.
- Cyber risk assessment and AI learning platform
Cybrology
cybrology.com
A multi-tenant platform that scores an organisation's cyber risk and turns the gaps it finds into an ordered learning path. I led the team building it, across a Turborepo monorepo pairing a Next.js web app and NestJS API with a BullMQ worker and a Python FastAPI service owning every AI feature.
- Led the team building a multi-tenant platform in a Turborepo monorepo: Next.js 16 App Router web app, NestJS 11 API, a separate BullMQ worker process and a Python FastAPI service that owns all AI features.
- Built a risk engine scoring organisations 0–100 from a versioned question bank with server-side skip logic, passive domain checks (TLS, SPF/DKIM/DMARC, breach lookups) and standalone mini tools. Scoring is deterministic and reproducible; the LLM only writes narrative on gaps the rule engine has already flagged, keeping compliance output defensible.
- Developed a RAG layer over course transcripts — Whisper transcription, semantic chunking, Vertex AI embeddings and ANN search in AlloyDB with ScaNN — with a structured re-rank that turns a user's risk gaps into an ordered learning path.
- Mapped answers to a NIST CSF control library with per-framework status reporting for GDPR, ISO 27001, PDPL, HIPAA, PCI DSS and SOC 2.
- Enforced tenant isolation at three layers (JWT claims, a tenant-scoped base repository, Postgres row-level security) with dynamic roles over a seeded permission catalogue, plus an LMS with Bunny.net video, quizzes, certificates, phishing simulations and 7 locales including RTL Arabic.
- Next.js
- NestJS
- BullMQ
- Python FastAPI
- Vertex AI
- AlloyDB
- PostgreSQL
- Turborepo
Live Demo — CybrologyGitHub - Creator Platform
Talkspresso
talkspresso.com
A creator platform where I built product features and the secure REST APIs behind them, including the payment integration that drives its transaction workflows.
- Built creator-platform features and secure REST APIs, including payment integration for transaction workflows.
- Developed responsive Next.js interfaces and used Redis to optimize frequently accessed data paths.
- Supported Dockerized services and PostgreSQL for stable development and deployment workflows.
- Next.js
- NestJS
- PostgreSQL
- Redis
- Docker
Live Demo — TalkspressoGitHub
06How I build
From requirement to running in production
The same sequence on every build — designed up front, implemented across the stack, then deployed and measured.
Understand
Start with the requirement and the constraint behind it — what the feature has to do, who it serves and where it has to fit in what already exists.
Architect
Design the shape before writing it: scalable application architecture with clear boundaries between the interface, the service layer and the data, following clean architecture practices.
- Clean architecture
- REST API design
Build
Implement across the stack — responsive interfaces, REST APIs with authentication and third-party integrations, and the relational or document schema underneath them.
- Next.js
- React
- NestJS
- Node.js
- tRPC
Verify
Cover the paths that matter with Playwright end-to-end and integration tests, and keep changes reviewable — small, readable commits over a shared branch history.
- Playwright
- Integration tests
- Git
- GitHub
Deploy
Containerise the services so the deployed environment behaves like the development one, then ship to the cloud.
- Docker
- Google Cloud
- Vercel
Improve
Optimise performance where the measurements point — caching frequently accessed data, resolving complex technical issues and keeping the code production-ready.
- Redis
Every tool named above appears on my CV — this is the workflow I actually use, not an idealised one.
07Engineering philosophy
The rules I don't negotiate on
Opinions earned from shipping and then maintaining what I shipped.
Full-Stack Development
Comfortable across the whole stack — the interface, the service behind it and the database underneath are one system, not three handoffs.
REST API Design
APIs designed as contracts: predictable resources, secure endpoints and responses the frontend can rely on.
Database Design
Relational and document schemas modelled around the domain, across PostgreSQL, MySQL and MongoDB.
Software Architecture
Clean architecture and scalable application structure, so features can be added without unpicking what already works.
Cloud Deployment
Containerised services with Docker, deployed to Google Cloud Platform and Vercel with consistent environments.
Performance Optimization
Caching frequently accessed data and optimising slow paths, so applications stay responsive under real usage.
Clean Code
Maintainable, high-quality, production-ready code — written to be read by whoever picks it up next.
Team Collaboration
Collaborative delivery through Git and GitHub — reviews, shared conventions and a history that explains itself.
08Services
What I Build
The kinds of systems I'm brought in for — and what I make sure gets designed in rather than retrofitted.
Full-Stack Applications
Scalable web and mobile applications.
End-to-end delivery in JavaScript and TypeScript — React and Next.js on the front, Node services behind them, styled with Tailwind CSS.
- React.js & Next.js
- TypeScript
- Tailwind CSS
API Development
Robust backend services and RESTful APIs.
Backend services and REST, GraphQL and tRPC endpoints built with Node.js, NestJS and Express, structured for scale and owned from architecture through production.
- NestJS & Express
- REST & GraphQL
- tRPC
Database Design
Schemas designed and managed properly.
Relational and document data modelled with Prisma across PostgreSQL, MongoDB and MySQL — and maintained as the product grows.
- PostgreSQL & MySQL
- MongoDB
- Prisma
Authentication & Integrations
Secure access and third-party services.
Authentication and authorization on protected routes, plus third-party integrations wired into real application workflows.
- Authentication
- Authorization
- Third-party APIs
Performance Optimization
Faster applications, fewer surprises.
Profiling and optimising application performance, caching frequently accessed data with Redis, and resolving complex technical issues in production code.
- Redis caching
- Query optimisation
- Production debugging
Real-Time & Event-Driven Systems
Microservices that talk to each other as things happen.
Event-driven services with real-time communication over WebSockets, SSE and message queues, with Redis in the middle — designed for scalability and low latency.
- WebSockets & SSE
- Message queues
- Microservices
Testing & Quality
Confidence before release, not after.
Playwright end-to-end and integration coverage built into the pipeline — the approach that took one platform's E2E coverage from 5% to 70% and cut production regressions.
- Playwright E2E
- Integration testing
- CI/CD pipelines
Cloud & Deployment
Containerised delivery to the cloud.
Services containerised with Docker and deployed to Google Cloud Platform or Vercel, with environments that behave the same everywhere.
- Docker
- Google Cloud Platform
- Vercel
09Contact
Let's Work Together
Open to full-stack engineering roles and remote opportunities worldwide.