MuhammadFazeel
Full-stack, backend-focused software engineer building products, systems & infrastructure.
I work primarily in Node.js and TypeScript — designing scalable APIs, distributed systems and data architectures, and carrying complete products from the database schema to the shipped interface.
I build systems that have to work.
Most of my work lives in the part of software users rarely see — the systems underneath the product. Six areas cover almost everything I do.
Most of my work is consumed by other teams — web portals, native iOS and Android apps — through a shared API layer. That means contracts that don't surprise anyone: versioned endpoints, consistent error handling, proper validation, and authentication and authorisation built in from the start.
RESTExpress.jsJWTRBACOpenAPI-style documentation
Nine principles, learned in production. Not aspirations — the way the systems I've shipped actually got built.
Build for scale.
Concurrent users and steadily growing datasets are the baseline, not the edge case.
Design the data model carefully.
Schemas, relationships and indexes decide what the system can become.
Keep APIs predictable.
Versioned, documented, consistent — other teams build on top of them.
Separate responsibilities.
Clear service boundaries mean independent deployment and fault isolation.
Measure performance.
Production bottlenecks are found, not guessed at.
Use asynchronous processing where it makes sense.
Slow work belongs on a queue, not on the request path.
Make systems observable and maintainable.
The next engineer — often future me — should understand what's happening and why.
Prefer simple architecture over unnecessary complexity.
Every component you add is a component that can fail.
Own the feature from database to interface.
End-to-end ownership changes how you design every layer.
Seven years, three chapters, one direction.
Full-stack foundations
MEAN Stack DeveloperNew Vision Technologies
Where it started: full-stack web applications across the MEAN stack, contributing to both the API and the interface. Building RESTful APIs with secure authentication on one side, converting designs into responsive cross-browser interfaces on the other — and learning how the two halves of a product actually meet.
- Full-stack web applications across the MEAN stack
- RESTful APIs with secure authentication & authorisation
- Responsive, cross-browser interfaces backed by those APIs
MongoDBExpress.jsAngularNode.jsAngular UIExpress APIMongoDBBackend specialisation
Senior Node.js DeveloperInfinity Bits
The specialisation years. Leading backend development across multiple enterprise applications — translating business requirements into scalable system designs, shaping modular services and database architectures for concurrent users and steadily growing datasets, and keeping server-side performance stable under high-traffic conditions.
- Led backend development across multiple enterprise applications
- Modular services & database architectures for growing datasets
- Server-side logic and queries optimised for high-traffic stability
- Production-ready releases shipped on schedule with cross-functional teams
Node.jsJavaScriptReactSystem designQuery optimisationReact frontendsREST APIsModular servicesDatabasesNational-scale systems
Senior Backend DeveloperNEOM
Nearly four years as a backend engineer on the NEOM Public Services platform — the resident-facing portal for requesting and tracking public services across NEOM, serving a web portal and native iOS and Android apps from a shared API layer. Enterprise-grade, high-availability services where performance work and reliability are not optional.
- Scalable Node.js & TypeScript services for high-availability applications
- MongoDB & MySQL schemas and query strategies for the highest-traffic endpoints
- Redis caching & distributed sessions enabling horizontal scaling
- Microservices communicating asynchronously over RabbitMQ
- Versioned REST APIs consumed by web and native mobile teams
- Docker, CI/CD and production performance under real-world load
Node.jsTypeScriptMongoDBMySQLRedisRabbitMQDockerCI/CDWeb · iOS · AndroidShared API layerNode/TS microservicesRabbitMQMongoDB · MySQLRedisDocker · CI/CD
Things I've actually built.
No side-project filler. A national-scale public services platform, a complete SaaS product, and the distributed systems underneath — each one below is a miniature case study.
Public services for a city being built from scratch.
The NEOM Public Services platform is the resident-facing portal for requesting and tracking public services across NEOM — service request submission and lifecycle tracking, real-time status notifications, and digital ID issuance. A web portal and native iOS and Android apps, all served from a shared API layer.
I spent nearly four years as a backend engineer on this platform — the systems below are the ones I worked in every day.
One shared API serves every client
Versioned · authenticated · validated
Node.js · TypeScript microservices
Asynchronous — services deploy & fail independently
Schemas · queries · cache · distributed sessions
Containerised, shipped through pipelines
What I owned
Scalable Node.js & TypeScript services
Architected and maintained the services underpinning enterprise-grade, high-availability applications.
Database schemas & query strategies
Optimised MongoDB and MySQL schemas, improving response times on the platform's highest-traffic endpoints.
Redis caching & distributed sessions
The layer that enabled horizontal scaling across service instances.
Asynchronous microservices
Services communicating over RabbitMQ — independent deployment, fault isolation between services.
Secure, versioned REST APIs
Consumed by multiple frontend and mobile teams — authentication, authorisation, validation, error handling.
Production performance
Diagnosed and resolved real bottlenecks, sustaining high availability under real-world load.
One product. Two sides. Built end to end.
Kinevie is a two-sided SaaS platform for physiotherapy & wellness, connecting patients with clinics. I designed, built and shipped it end to end — the relational data model, the Node.js API layer, the business logic, and the React and Next.js frontend on top.
Two very different audiences, one system underneath. The deepest work is where it usually is with me: the backend and the data layer.
Finding & receiving care
- Searchable clinic directoryFind the right clinic
- Booking flowFrom search to confirmed appointment
- Personal care portalCare, in one place
- Subscription plans
- Online shop
- Content hub
- Multi-language
Running the practice
- Operations dashboardThe clinic's daily control room
- Staff & shift schedulingWho works, and when
- Patient records & intakeStructured from the first visit
- InvoicingBilling built into the workflow
- AnalyticsThe numbers behind the practice
The build — schema to shipped
Data model
Relational schema — the product's foundation
Backend / APIs
Node.js API layer
Business logic
Bookings, scheduling, invoicing
Frontend
React & Next.js
User experience
Two audiences, multiple languages
Shipped
kinevieapp.com — live
Full-stack ownership of the product — every layer in that pipeline is mine.
kinevieapp.comMicroservices-Based Enterprise Platform
A distributed backend built from Node.js microservices with RabbitMQ for asynchronous communication, Redis for caching and MongoDB for persistence — containerised with Docker.
Independent deployments, improved resilience and clearer service boundaries — services publish work to the broker and move on, so a slow consumer never blocks the request path.
Event-Driven Processing System
A real-time processing pipeline built on Apache Kafka to handle background jobs and cross-service communication.
Improved reliability and reduced end-to-end processing latency by moving cross-service communication onto durable event streams that consumers process at their own pace.
Tools are chosen by the problem.
Node.js
The core of my career — scalable services underpinning enterprise-grade, high-availability applications.
This is the pattern behind the Redis work at NEOM — caching plus distributed sessions, so service instances could scale horizontally without pinning users to a machine.
Work that was noticed.
A Certificate of Excellence from NEOM — “for the outstanding performance in 2024” — issued by Mazin Althunayan, NEOM Public Services.
- Certificate of Excellence
- Mazin Althunayan — NEOM Public Services
- For the outstanding performance in 2024
BS Software Engineering
International Islamic University — Islamabad, Pakistan
Curiosity is the real engine.
I got into engineering because I like understanding how things work — and building software turned out to be the rare craft where understanding something and creating it are the same act. Seven years in, that hasn't worn off.
The problems I enjoy most are the difficult, unglamorous ones: the query that shouldn't be slow but is, the service boundary that isn't quite right, the data model that needs to survive requirements nobody has thought of yet. Solving those well is quiet work, and it's the work I'm proudest of.
Building Kinevie taught me the other half — that an idea only becomes real when someone carries it all the way to a product people can use. So I keep doing both: going deeper into systems, and turning ideas into shipped things. Every year the tools change; lately that includes working with AI as part of the workflow. The habit of learning is the constant.
What's next?
Seven years took me from full-stack foundations to national-scale public services and a shipped product of my own. The next chapter is more of the direction, at greater depth: systems that are simpler than the problems they solve, products owned end to end, and engineering that holds up under real-world load.
Based in Islamabad, Pakistan · open to relocation