If you have
People re-key data between tools that do not talk to each other.
You get
I connect the systems and make the handoff a job with retries and an audit trail.
Backend / systems engineer · Lahore, open to remote roles
I like difficult systems. I like figuring out why they break. Then I like making them boring.
Workflows that span systems that do not talk to each other. I make them reliable, and add AI where it helps.
Mubashir RehmanLahore · UTC+5
Now
Lead Software Engineer at TransData, leading five engineers.
Noise in, boring out.
What I deliver
Pick the problem that sounds like yours.
If you have
We want AI, but our data lives in an ERP or a scheduling system.
You get
I build the AI layer on top of the system of record, not a second copy of it.
If you have
The AI demo works. Production does not.
You get
I find what breaks between the demo and real traffic, and fix it at the root.
Proof: A production AWS backend →
If you have
Signals arrive from everywhere and nobody sees the important ones.
You get
I build ingestion, search and alerting that says why it fired.
If you have
The system runs, and nobody trusts what it shows.
You get
I trace the numbers back to their source until they add up.
Proof: An operations console for a healthcare integration engine →
When something is broken
The same four steps, every time. One real case.
-
1Notice
Something looks plausible but wrong.
An insurance carrier count on a screen I was redesigning read 80, and a reviewer model doubted it.
-
2Trace
Follow the number back to its source.
It was the exact sum of several tenants' rows. The query had no tenant filter, at a call site an earlier leak fix had missed.
-
3Fix the cause
Fix the root, not the symptom, then prove it.
I added the filter and checked it against the isolation tests.
-
4Keep the rule
Write down what to check next time.
Rule 1: Read the number that does not add up.
When nothing exists yet
From an unclear ask to something shipped. Three real cases.
-
1A vague ask
Write down what the client means, not just what they said.
-
2Pin down what is known
Turn it into numbered requirements. Mark what is still open.
-
3Design around the open parts
Keep the architecture stable while decisions are still pending.
-
4Show it early
A working demo the client can react to, traced to the requirements.
-
5Ship and hand over
Production, documentation, and a codebase someone else can own.
The ask
A SaaS that turns public filings into sales-ready leads. Requirements arrived in rounds.
What shipped
Requirements, architecture and detailed design, plus a deployed demo for client review.
Three decisions stayed open, so I designed around them. Every requirement ID traces to a screen.
The ask
Automate expense claims inside the ERP. Then the goal moved to procurement for two companies.
What shipped
AI agents working inside a live ERP: two live deployments, demo and production.
I reused the same agent layer for the new goal instead of starting over.
The ask
Turn chatter from Telegram, Discord and X into something searchable, with alerts.
What shipped
A backend built alone: ingestion, AI summaries, semantic search and alerts. 154 of 155 commits.
Built so the client's own team could take it over, then handed over at their request.
The path so far
Each step added something I still use.
- 2022
Game development intern, GameBole
Android and web games in Unity and PlayCanvas.
Added: First code that shipped to users
- Unity
- PlayCanvas
- 2022 to 2025
Teaching assistant, operating systems, ITU
Undergraduate labs for three semesters, graduate Advanced Operating Systems for two.
Added: Explaining systems from the bottom up
- C
- Linux
- Operating systems
- 2023
Software engineer, then team lead, VeritusLabs
Promoted about three months in. Led four engineers on drone-control software in C++ and Qt/QML.
Added: Leading engineers on real-time software
- C++
- Qt/QML
- AWS
- 2025
Software engineer, TransData
Backend, AI and infrastructure across healthcare, ERP and AI products. Co-authored a peer-reviewed Springer paper.
Added: Owning production systems end to end
- Python
- Django
- FastAPI
- PostgreSQL
- 2026
Lead software engineer, TransData
Leading five engineers. Took an AI voice front desk for dental clinics to production in September.
Added: Taking AI from demo to production
- AWS CDK
- PostgreSQL
- AI agents
The work behind it
Systems I have had to understand.
Ownership · August 2026 to present
An AI voice front desk for dental clinics
Took an AI receptionist for dental clinics from AI-scaffolded code to production, with three voice providers and per-practice tenant isolation.
- A total that did not add up
- A queue that would not stop growing
- A date the agent never questioned
Open source · From June 2026
HireTrack
Built an open-source, offline-first tracker that moves applications through a fixed pipeline and tailors résumés with a deterministic-first LangGraph flow.
Built for a café · 2026
The Quetta Tea 2.0
Astro site for a Lahore café; desktop PageSpeed 100 for performance, accessibility and SEO.
Systems · 2025 to 2026
A social and market signal intelligence backend
Built a client backend alone: it ingests Telegram, Discord and X, summarises with AI, searches semantically and raises alerts.
I wrote 154 of the 155 commits, then handed the backend over at the client's request.
Toolbox
What I have used to ship, grouped by where it sits in a system.
- Daily
- Used in production
- Project exposure
- Used before
Languages
- Python (daily)
- SQL (daily)
- TypeScript
- JavaScript
- C++
- C
- Bash
- QML
- C#
- Java (project exposure)
- Kotlin (project exposure)
Backend
- Django (daily)
- Django REST Framework (daily)
- FastAPI (daily)
- Node.js
- Express-style BFF
- Flask
- Sequelize
- REST APIs
- OAuth2
- JWT
- RBAC
- SSO
- WebSockets
- SSE
AI and LLM
- LLM agents and tool calling (daily)
- OpenAI API (daily)
- pgvector search (daily)
- Google Gemini
- AWS Bedrock
- LangChain
- LangGraph
- MCP
- Embeddings and RAG
- vLLM
- LiteLLM
- Retell
- ElevenLabs
- Telnyx
- YOLOv11 (project exposure)
- DeepSORT (project exposure)
- OpenCV (project exposure)
- Keras (project exposure)
- scikit-learn (project exposure)
- SciPy (project exposure)
Agentic engineering
- Claude Code (daily)
- OpenCode (daily)
- Project skills (daily)
- Subagents (daily)
- Custom agent harness
- MCP servers
- Git worktrees per agent
- Docs as skill resources
- Regression test suites for agent changes
- Model choice by task type
- GitHub Copilot (used before)
- Cline (used before)
- OpenAI Codex (used before)
- Google Antigravity (used before)
- Qwen Code (used before)
Data
- PostgreSQL (daily)
- Redis (daily)
- MySQL
- MariaDB
- SQLite
- Supabase and row-level security
- SQLAlchemy
- SQLModel
- Alembic
- Multi-tenant data design
Cloud and DevOps
- Docker (daily)
- AWS (daily)
- GitHub Actions (daily)
- AWS CDK
- ECS on Fargate
- RDS
- ALB
- WAF
- KMS
- S3
- IAM
- CloudTrail
- EventBridge
- Boto3
- Nginx
- Traefik
- Linux
- systemd
- DigitalOcean
- Cloudflare Workers
- Let's Encrypt
- Vagrant (project exposure)
Frontend
- React (daily)
- TypeScript (daily)
- Vite
- Astro
- Next.js
- TanStack Start
- Tailwind CSS
- shadcn/ui
- Accessibility
Enterprise systems
- ERPNext and Frappe (daily)
- Frappe CRM
- HRMS on Django
- ZKTeco biometric API
- HL7 integration
- Stripe billing
Async, real-time and robotics
- Celery (daily)
- asyncio (daily)
- ARQ
- MQTT
- Qt/QML
- QGroundControl
- Gazebo
- Android SDK
- ArduPilot (project exposure)
- PX4 (project exposure)
- Olympe (project exposure)
Contact