Home section

Software Architecture · Platform Engineering · Full-Stack Delivery

Mohammad Shadmaan Asif

Staff Software EngineerFounder & Solo Developer, CompareFiles.net

I design and own the architecture behind booking and e-commerce platforms across web and mobile — the SDKs, design systems, APIs, and delivery pipelines underneath React/Next.js and Node.js, not just the interface on top of them.

Dubai, UAEOpen to remote & hybrid
  • React
  • Next.js
  • TypeScript
  • Node.js

0+

Years of engineering experience

0+

Shared components in the design system

~−0%

Duplicated logic across client apps

−0%

Bundle size

~−0%

Largest Contentful Paint

~+0%

Feature delivery speed (AI-assisted)

About

About

Over 10 years moving from shipping features to owning the systems they run on — from resolving defects and building React/Redux apps at DXC Technology, Infosys, and Hexaware Technologies, to owning architecture at Almosafer since 2021.

  • Platform architecture — A shared SDK abstraction layer that decoupled business logic from presentation across multiple client applications, and a 40+ component design system giving iOS, Android, and desktop one consistent interface.

  • Backend & delivery — A Next.js and Express.js backend-for-frontend layer aggregating downstream REST and GraphQL services, plus a monorepo and micro-frontend pipeline shipped via Docker, Kubernetes, and CI/CD to AWS, Vercel, and Cloudflare.

  • Technical leadership — Mentoring engineers, running structured code reviews and design-pattern guidance, and translating architecture trade-offs into reporting senior stakeholders can act on.

  • AI-assisted engineering — Led my team's shift from experimenting with AI tools to shipping daily with Claude Code, Cursor, GitHub Copilot, MCP, and LLM integrations.

  • Independent ownership — I build JavaScript and Node.js automation tooling independently, and I founded CompareFiles.net, a live, privacy-first JSON diff tool I built, launched, and own solo, end to end.

Expertise

Depth across the stack, not just the interface

Software Architecture & System Design

  • Frontend Architecture
  • Design Systems
  • SDK & Reusable Component Libraries
  • Modular Architecture
  • Micro Frontends
  • Monorepos (Lerna)
  • Microservices
  • Design Patterns
  • SOLID
  • Clean Code

Frontend Engineering

  • React
  • Next.js
  • Vue.js
  • TypeScript
  • JavaScript (ES6+)
  • HTML5
  • CSS3 / SCSS
  • Tailwind CSS
  • JSX
  • CSS-in-JS
  • Material UI
  • Bootstrap
  • Web Components
  • Storybook
  • PWA
  • Component-Driven Development
  • Responsive Design
  • Accessibility (a11y)

State Management & Data Flow

  • MobX
  • Redux
  • Zustand
  • Context API
  • React Query
  • Client-Store Synchronization
  • Real-Time Data Flows (WebSocket, SSE, Polling)

Backend, APIs & Data

  • Node.js
  • Express.js
  • REST APIs
  • GraphQL
  • WebSocket
  • SSE
  • Next.js API Routes
  • Backend-for-Frontend Orchestration
  • Node.js API Orchestration
  • Distributed Systems Integration
  • Payment Gateway Integration
  • SQL
  • MySQL
  • PostgreSQL
  • MongoDB

Performance & SEO

  • SSR
  • Static Generation
  • Lazy Loading
  • Code Splitting
  • Profiling
  • Bundle & Asset Optimization
  • Core Web Vitals
  • SEO & Ranking

Testing & Quality

  • Jest
  • React Testing Library
  • Playwright
  • Cypress
  • Enzyme
  • Unit / Integration / E2E Testing
  • Code Reviews
  • Localization & Accessibility Standards
  • UX/UI Standards Compliance

DevOps & Cloud

  • CI/CD
  • GitHub Actions
  • GitLab CI
  • Docker
  • Kubernetes
  • AWS / Vercel / Cloudflare
  • Heroku
  • Grafana Monitoring
  • Webpack
  • Babel
  • Git

AI & Automation

  • Claude Code
  • Cursor
  • GitHub Copilot
  • Model Context Protocol (MCP)
  • Coding Agents
  • Prompt Engineering
  • LLM API Integrations
  • AI-Powered UIs
  • AI-Assisted Code Review & Automation
  • JavaScript / Node.js Scripting

Technical Leadership & Mentorship

  • Technical Leadership
  • Mentoring (6 at Almosafer, 4 at Hexaware)
  • Structured Code Reviews & Design-Pattern Guidance
  • Team Management
  • Cross-Functional Collaboration
  • Agile / Scrum
  • Stakeholder Reporting
  • Secure Development
  • Driving Team-Wide AI Adoption
  • Figma / Sketch Collaboration

Experience

From shipping features to owning the systems they run on

  1. Senior Specialist Engineer · Almosafer

    Dubai, UAE — Aug 2021 – Present

    • Own architecture end to end — architected a 40+ component design system on Next.js, React, and Material UI, cutting new-feature UI build time ~30% and giving iOS, Android, and desktop one consistent interface.
    • Decoupled presentation components from business logic behind an SDK abstraction layer, eliminating ~60% of duplicated logic across multiple client applications.
    • Built Next.js API routes and Express.js services as a backend-for-frontend layer, aggregating downstream REST and GraphQL endpoints into optimized payloads, and standardized monorepo (Lerna) and micro-frontend delivery on Docker and Kubernetes, shipping through CI/CD to AWS, Vercel, and Cloudflare.
    • Replaced ad-hoc state patterns with a predictable, testable data flow on MobX and React Query, cutting state-related defects ~35% and shortening new-engineer ramp-up from weeks to days, and implemented client-store synchronization, WebSocket, and SSE-driven polling workflows that keep distributed pricing and availability consistent across clients under concurrent load.
    • Built end-to-end booking workflows and payment integrations, engineering the responsive UI architecture behind the conversion funnel on web and mobile.
    • Cut bundle size 65% and improved LCP ~45% through SSR, SSG, code splitting, lazy loading, profiling, and asset optimization, lifting organic traffic ~25%.
    • Raised test coverage to 80%+ with Jest, React Testing Library, Playwright, and Cypress, and enforced usability, localization, and accessibility standards with UX/UI — cutting production defect escape ~40%.
    • Mentored 6 developers, instituted structured code reviews and design-pattern guidance that cut PR review turnaround ~50%, and translated architecture and delivery trade-offs into reporting senior stakeholders could act on.
    • Drove team-wide adoption of Claude Code, Cursor, and GitHub Copilot alongside MCP-based tooling, AI-powered UI prototyping, and AI-assisted code review, accelerating feature delivery ~25%.
    • Next.js
    • React
    • Vue.js
    • TypeScript
    • Node.js
    • Express.js
    • Tailwind CSS
    • Material UI
    • MobX
    • Zustand
    • React Query
    • Docker
    • Kubernetes
  2. Senior Software Engineer · Hexaware Technologies

    India — Nov 2020 – Aug 2021

    • Designed and delivered a production React and Redux application from the ground up, establishing the Webpack and Babel build pipeline and a modular component architecture that cut initial load time ~30%.
    • Led the frontend team and mentored 4 junior developers, building a review-driven culture that improved delivery consistency and reduced rework.
    • Partnered with backend engineers to resolve defects and harden the application, sustaining usability, accessibility, and performance standards across releases.
    • React
    • Redux
    • JavaScript
    • Webpack
    • Babel
    • REST APIs
  3. Senior Consultant · Infosys

    India — Nov 2019 – Nov 2020

    • Developed a front-end web application in React with Redux, Babel, and Webpack, replacing legacy patterns with a modular component structure that cut UI duplication ~40%.
    • Centralized application state and standardized component-to-component communication with Redux actions and reducers.
    • React
    • Redux
    • JavaScript
    • Webpack
    • Babel
  4. Software Engineer · DXC Technology

    India — Nov 2016 – Nov 2019

    • Built and maintained React and Redux application features, wiring component communication through Redux actions and reducers.
    • Diagnosed and resolved 100+ defects, improving application stability and release reliability across three years of continuous delivery.
    • React
    • Redux
    • JavaScript
    • Webpack
    • Babel

Architecture

Architecture & System Design

Derived directly from the architecture decisions described in my experience. Where a diagram reflects a described pattern rather than exact internal wiring, it is marked as a conceptual representation.

View full architecture deep-dive
A.01

SDK Abstraction Layer — Before → After

Conceptual representation

Business logic was duplicated across multiple client applications, coupled to their presentation components. I decoupled the two behind an SDK abstraction layer, eliminating ~60% of duplicated logic across those clients.

BEFORE — DUPLICATED PER CLIENTCLIENT APP 1UIBusiness LogicCLIENT APP 2UIBusiness LogicCLIENT APP NUIBusiness LogicAFTER — SHARED SDK ABSTRACTION LAYERClient 1 UIClient 2 UIClient N UISDK Abstraction LayerShared Business Logic
A.02

API & Platform Layer — Backend-for-Frontend Orchestration

Clients needed data assembled from multiple downstream REST and GraphQL services without each one orchestrating those calls itself. I built Next.js API routes and Express.js services as a backend-for-frontend layer that aggregates downstream endpoints into optimized payloads for client consumption.

CLIENTS → BACKEND-FOR-FRONTEND → DOWNSTREAM ENDPOINTSClient ApplicationsNext.js API Routes + Express.js ServicesBackend-for-frontend — aggregates & optimizes payloadsREST EndpointsGraphQL Endpoints
A.03

Delivery Pipeline — Monorepo to Production

Conceptual representation

I standardized a monorepo (Lerna) and micro-frontend architecture with containerized delivery on Docker and Kubernetes, shipping through CI/CD to AWS, Vercel, and Cloudflare.

MONOREPO → CONTAINERS → CI/CD → DEPLOYMENT TARGETSMonorepo (Lerna)+ Micro FrontendsDocker+ KubernetesCI/CDGitHub ActionsAWSVercelCloudflare
A.04

State & Real-Time Data Flow

Conceptual representation

A predictable, testable data flow on MobX and React Query, with client-store synchronization, WebSocket, and SSE-driven polling keeping pricing and availability consistent across clients under concurrent load.

CONCURRENT CLIENTS → CLIENT STORE → LIVE DATAClient 1Client 2Client NClient Store — MobX + React QueryPricing & Availability DataWEBSOCKET / SSE / POLLING
A.05

Impact at a Glance

Measurable delivery outcomes across my work at Almosafer, as listed on my resume.

Engineering Impact

The same body of work, read the way a platform team is judged

The same work at Almosafer, viewed across the dimensions a platform team is actually judged on.

Platform Engineering

  • SDK abstraction layer decoupling business logic from presentation, eliminating ~60% of duplicated logic across multiple client applications
  • 40+ component design system unifying iOS, Android, and desktop
  • Standardized monorepo (Lerna) and micro-frontend architecture

Performance Engineering

  • SSR, code splitting, lazy loading, and asset optimization as standard practice
  • 65% smaller bundles, ~45% faster LCP
  • ~25% organic traffic growth from Core Web Vitals and SEO gains

Developer Experience

  • Containerized delivery (Docker, Kubernetes) through CI/CD to AWS, Vercel, and Cloudflare
  • Structured code-review standards cutting PR turnaround ~50%
  • Team-wide adoption of MCP-based AI tooling and AI-assisted code review

Scalability

  • Client-store synchronization, WebSocket, and SSE-driven polling keeping pricing and availability consistent under concurrent load
  • Backend-for-frontend orchestration on Next.js API routes and Express.js, aggregating downstream REST and GraphQL endpoints into optimized payloads
  • Single codebase serving iOS, Android, and desktop

Engineering Quality

  • Test coverage raised to 80%+ with Jest, React Testing Library, Playwright, and Cypress
  • Accessibility, localization, and UX standards enforced with design partners
  • ~40% fewer production defect escapes, ~35% fewer state-related defects

Technical Strategy

  • Mentored 6 developers and instituted structured code reviews and design-pattern guidance
  • Architecture and delivery trade-offs translated into reporting senior stakeholders can act on
  • Team-wide AI adoption driven from experimentation to daily delivery

Engineering Approach

How I think about trade-offs

  1. M.01

    Architecture is a shared contract, not a frontend concern

    The SDK abstraction layer, backend-for-frontend services, monorepo, and delivery pipeline I built are shared platform decisions — decoupling business logic from presentation eliminated ~60% of duplicated logic across multiple client applications.

  2. M.02

    Performance is a default requirement, not a later optimization

    SSR, SSG, code splitting, lazy loading, profiling, and asset optimization are part of how I build, not a cleanup pass — they took bundle size down 65% and LCP down ~45%, and lifted organic traffic ~25%.

  3. M.03

    Predictable data flow over ad-hoc state

    Replacing ad-hoc state patterns with MobX and React Query cut state-related defects ~35% and shortened new-engineer ramp-up from weeks to days. Client-store synchronization with WebSocket and SSE-driven polling keeps pricing and availability consistent across clients under concurrent load.

  4. M.04

    Leverage through people, not just code

    I mentor engineers, run structured code reviews and design-pattern guidance, and translate architecture trade-offs into reporting senior stakeholders can act on.

  5. M.05

    Deliberate adoption of new tooling

    I drove my team from experimenting with AI-assisted engineering to shipping with it daily — Claude Code, Cursor, GitHub Copilot, MCP — and I independently build JavaScript and Node.js automation tooling.

AI & Innovation

AI & Innovation

I treat AI-assisted engineering as a team-wide practice, not an individual habit — adopted deliberately and measured by what it changes in delivery.

AI Pair-Programming & Coding Agents

Drove team-wide adoption of Claude Code, Cursor, and GitHub Copilot.

Prompt Engineering & LLM API Integrations

Prompt engineering and LLM API integrations.

Model Context Protocol (MCP) Tooling

MCP-based tooling adopted team-wide alongside the AI coding tools.

AI-Assisted Code Review

AI-assisted code review, adopted team-wide alongside MCP-based tooling as part of the AI-assisted delivery work.

AI-Powered UI Prototyping

AI-powered UI prototyping, part of the team-wide AI adoption.

JavaScript & Node.js Automation

Automation tooling I build independently in JavaScript and Node.js.

I drove my team's shift from experimenting with AI-assisted development to shipping with it daily.

Feature delivery speed

~25% faster with AI-assisted delivery

Engineering Decision Log

Six decisions, written as ADRs

Context, options, decision, trade-offs, consequences — for the architecture work above.

ADR-001Introducing a Shared SDK Abstraction Layer
Context
Multiple client applications were carrying duplicated business logic, coupled to their presentation components.
Options
Keep business logic embedded in each client, or extract it once behind a shared abstraction consumed by every client.
Decision
Decoupled presentation components from business logic behind an SDK abstraction layer.
Trade-offs
A shared layer means every client depends on one contract — good for consistency, but it raises the bar for changing that contract safely.
Consequences
~60% less duplicated logic across multiple client applications.
ADR-002Standardizing a Monorepo & Micro-Frontend Delivery Model
Context
Frontend work needed one standard repository structure and delivery path across micro frontends and deployment targets.
Options
Leave each app with its own repository and pipeline, or standardize on one monorepo and delivery model.
Decision
Standardized a monorepo (Lerna) and micro-frontend architecture with containerized delivery on Docker and Kubernetes, shipped through CI/CD to AWS, Vercel, and Cloudflare.
Trade-offs
A shared delivery model constrains individual apps’ tooling choices in exchange for one consistent delivery path.
Consequences
Frontend apps share one monorepo structure and one containerized CI/CD path to AWS, Vercel, and Cloudflare.
ADR-003Replacing Ad-Hoc State with MobX + React Query
Context
Ad-hoc state patterns were producing state-related defects and a slow ramp-up path for new engineers; pricing and availability also needed to stay consistent across concurrent clients.
Options
Keep ad-hoc, per-feature state handling, or adopt one predictable, testable state and data-flow model across the app.
Decision
Adopted MobX and React Query for a predictable, testable data flow, and added client-store synchronization with WebSocket and SSE-driven polling workflows for real-time consistency.
Trade-offs
An opinionated shared state model reduces per-feature flexibility, in exchange for removing the inconsistency and defect surface ad-hoc patterns created.
Consequences
State-related defects down ~35%; new-engineer ramp-up cut from weeks to days.
ADR-004Frontend Performance as a Default, Not a Cleanup Pass
Context
Bundle size and page-load speed needed to improve on a booking platform where SEO and organic traffic matter.
Options
Treat performance as a periodic optimization pass, or build SSR, code splitting, and asset optimization into how features ship.
Decision
Applied SSR, SSG, code splitting, lazy loading, profiling, and asset optimization as part of delivery, not a later cleanup pass.
Trade-offs
Raises the bar and review overhead for every feature shipped, in exchange for not accumulating a performance debt that has to be repaid later.
Consequences
65% smaller bundles, LCP improved ~45%, organic traffic up ~25%.
ADR-005Adopting AI-Assisted Engineering as a Team Practice
Context
The team was experimenting with AI-assisted development.
Options
Leave AI tool adoption to individual engineers' discretion, or drive a deliberate, team-wide shift to daily AI-assisted delivery.
Decision
Drove team-wide adoption of Claude Code, Cursor, and GitHub Copilot alongside MCP-based tooling, AI-powered UI prototyping, and AI-assisted code review.
Trade-offs
Standardizing shared AI tooling and workflow means investing in team-wide guidance and review norms, in exchange for consistent, compounding gains instead of isolated individual speedups.
Consequences
Feature delivery accelerated ~25%; the team moved from experimenting with AI-assisted development to shipping with it daily.
ADR-006Introducing a Backend-for-Frontend Layer on Next.js + Express.js
Context
Clients needed data assembled from multiple downstream REST and GraphQL services; without an orchestration layer, each client would call every downstream service directly.
Options
Let each client orchestrate and shape downstream calls itself, or introduce a dedicated backend-for-frontend layer that aggregates and optimizes payloads once.
Decision
Built Next.js API routes and Express.js services as a backend-for-frontend layer, aggregating downstream REST and GraphQL endpoints into optimized payloads for client consumption.
Trade-offs
Adds a service to build, deploy, and keep available, in exchange for clients that stay simple and downstream systems that can change shape without every client changing with them.
Consequences
Clients receive optimized, aggregated payloads from one orchestration layer instead of assembling them from each downstream service.

Engineering Notes

Short-form reasoning behind the decisions above

Not published articles — just the thinking written down.

Why I extracted business logic into a shared SDK layer

Multiple client applications were each carrying the same business logic. Decoupling presentation components from it behind an SDK abstraction layer eliminated ~60% of the duplicated logic.

Performance is a default, not a later optimization pass

SSR, SSG, code splitting, lazy loading, profiling, and asset optimization took bundle size down 65% and improved LCP ~45% — which lifted organic traffic ~25%.

Predictable data flow beats ad-hoc state

Replacing ad-hoc patterns with MobX and React Query gave a predictable, testable data flow — state-related defects fell ~35% and new-engineer ramp-up dropped from weeks to days.

Moving a team from AI experiments to shipping with AI daily

Team-wide adoption of Claude Code, Cursor, and GitHub Copilot, alongside MCP-based tooling, AI-powered UI prototyping, and AI-assisted code review, accelerated feature delivery ~25%.

Turning architecture trade-offs into reporting stakeholders can act on

I translate architecture and delivery trade-offs into clear technical reporting that senior stakeholders can act on.

Why aggregation belongs in a backend-for-frontend layer

Letting each client orchestrate its own calls to REST and GraphQL services looks simpler until another client needs the same aggregation logic. Next.js API routes and Express.js services aggregate those downstream endpoints into optimized payloads once, instead of in every client.

Contact

Contact

I'm open to remote and hybrid roles where I can set technical direction across teams. If that's what you're hiring for, reach out.

Dubai, UAE