/subham
Available for senior frontend / platform roles

Subham Sengupta

Senior Frontend Engineer · Bengaluru, India

Building scalable web platforms, design systems, and agentic developer tooling.

See experienceGitHubLinkedInsengupta335@gmail.com
// about

Frontend that scales — and that thinks.

Senior Frontend Engineer with 8+ years shipping product and platform software — from consumer-scale web at Zomato to enterprise logistics dashboards at Locus (acquired by Ingka/IKEA).

Today I work on the boundary between frontend platforms and AI — building config-driven UI systems, internal app-builders, and agentic pipelines that turn PRDs into shippable code using LLM agents and MCP integrations.

I care about the craft: design systems, performance budgets, scheduler-friendly UIs, and the quiet details that make a dashboard feel alive under real enterprise load.

// under the hood

My career, explained by the frontend runtime.

Eight scenes through the concepts every senior FE interview loves — each animated with real chapters from my actual career.

Scene 01 · The Event Loop

Eight years of work, scheduled through a single thread.

Watch my career tick through the runtime: setTimeout(Zomato, 2.9y) resolves as a macrotask, await Ingka.acquire(Locus) settles as a microtask, ship(MCPAgenticPipeline) runs synchronously on the stack.

↳ Same mental model I use when designing Locus dashboards that track 1.5B+ deliveries without ever blocking the main thread.
Scene 02 · Closures

Three companies. Three private counters. Same function.

Each career() call captures its own shipped queue — click a company to invoke its closure and reveal the next real project I shipped there.

↳ The same primitive behind every hook, every memoized selector, and every self-contained UI module I've written since 2018.
function career(company, ships) {
  let shipped = 0;                              // private to this closure
  return () => ships[shipped++];                // each call advances one step
}

const zomato    = career("Zomato",    [...4 things I shipped]);
const locus     = career("Locus",     [...6 things I shipped]);
const mountBlue = career("MountBlue", [...1 bootcamp]);
Each closure holds its own private shipped counter. Same source, three career arcs.
// call log appears here — click any closure above
Scene 03 · Debounce

Why a Locus operator never takes down the fleet API.

Every keystroke fires on the left — raw events. Only the last one wins on the right, after 400ms of calm. The difference between 40 wasted calls and 1 good one.

↳ Non-negotiable at the scale I worked — consumer web at Zomato, enterprise dashboards at Locus with 200+ clients in 30+ countries.
// Locus dashboard: operator filtering 1.5B+ deliveries.
// Without this, every keystroke hammers the fleet API.
const debounced = debounce((q) => searchOrders(q), 400);
input.addEventListener("input", (e) => debounced(e.target.value));
raw events
(silence)
every keystroke fires — 0 in the window
debounced fires
// waiting for 400ms of calm
one call after 400ms of inactivity
Scene 04 · Reconciliation

A Locus dashboard ticking through its day.

Click through three moments of a real shift — dispatch, warehouse pick, last-mile delivery. React diffs the new virtual tree against the old and commits only the amber/green/red nodes you see highlighted.

↳ The reason config-driven Locus dashboards can repaint on live telemetry without jitter, even under enterprise load.
state → 08:00 · morning dispatch
<LocusDashboardclient="Unilever-IN"/>added
<Headeroperator="Subham"/>added
<FleetStatusstate="online"/>added
<OrderListvisible="3"/>added
<Orderid="ZO-8421"state="pending"/>added
<Orderid="ZO-8422"state="pending"/>added
<Orderid="ZO-8423"state="pending"/>added
changed propsaddedremoved
Scene 05 · Fiber

Why an operator can type while the map reflows.

Fiber slices my dashboard's work into units and yields every frame. Urgent work (<OrderSearch>, <ShipmentToast>, <MCPAgentInput>) preempts low-priority reflows (<FleetHeatmap>, <DeliveryAnalytics>). Red bars jump the queue.

↳ The scheduler behind every smooth-feeling Locus interaction I've shipped since React 18.
// Fiber slices work into units and yields back to the browser
// every frame — so urgent work (input, toasts) never waits on
// low-priority work (charts, analytics).
frame #0 · budget 2 units · 0 fibers in flight
// idle frame — nothing to reconcile
urgent (input, toast)normal (lists, forms)low (charts, analytics)
Scene 06 · Rendering Pipeline

Not every CSS change is priced the same.

Toggle between width, background-color, and transform. Watch which of the six pipeline stages actually re-fire — and how fast the demo marker moves when only the compositor is invited.

↳ The difference between a 60fps Locus fleet overlay and a page that jitters every time a vehicle moves.
// The pixel pipeline. Every update retraces some subset of these stages.
// Senior FE = knowing which subset each CSS change triggers.
Parse HTML$
tokens → DOM
Build CSSOM$
style rules
Render Tree$$
style recalc
Layout$$$
geometry
Paint$$
rasterize
Composite$
GPU layers
live demo
fleet marker · ZO-8421
$ el.style.transform = "translateX(28px)"
why it matters

Composite-only on the GPU. Cheapest. 60fps territory.

Scene 07 · Core Web Vitals

Same product. Two deploys. A critical-path story.

Flip between the naive build and the tuned one. Render-blocking JS, lazy-too-late heroes, and FOIT fonts wreck FCP / LCP / CLS / INP. Inline critical CSS, preload the hero, defer JS, and the numbers fall into the green.

↳ Exactly the game I was playing on Zomato's web surfaces — shrinking the critical path for a platform serving millions.
// Same page. Same product. Two deploys.
// Critical-path discipline is the only thing between them.
page-load waterfall · 0 → 5s
index.html
main.css
vendor.js
app.js
hero.webp (lazy)
fonts.woff2
hydrate
FCP
LCP
TTI
FCP
2.2s
LCP
4.8s
CLS
0.21
INP
480ms
TBT
610ms
↳ Render-blocking JS/CSS pushes FCP. Lazy-loaded hero blows LCP. No font preload = FOIT and CLS. Long tasks block input = INP misses.
Scene 08 · Component Library

Tokens in. Themes out. No rebuilds.

One OrderCard. Three themes — Locus default, IKEA white-label, a consumer-web variant. Flip a token preset and every primitive re-themes live: colors, radii, density, button variants.

↳ Co-authored Zomato's React component library; maintain Locus's shared library powering every surface, from ops consoles to white-labeled client portals.
// One component library. Tokens + variants + theming.
// Flip a theme preset — every primitive re-themes live, no rebuild.
theme tokens
button variant
density
order · ZO-8421
UL
Unilever — Mumbai
last-mile · 3 stops
dispatched
↳ theme = locus · variant = primary · density = cozy
// experience

Where I've shipped.

Eight years across consumer-scale web and enterprise platforms.

Dec 2020 – Present · 5 yrs 4 mos
Bengaluru

Locus

AI-powered Transportation Management System — acquired by Ingka Group (IKEA). Serves 200+ enterprise clients (Unilever, Nestlé, Tata) across 30+ countries, optimizing 1.5B+ deliveries. Gartner-recognized (2024) for Last-Mile Delivery & Multicarrier Parcel Management.

SDE 3 — Frontend
Jan 2025 – Present
  • Built a config-driven UI platform enabling dynamic product workflows — significantly reducing custom dev effort across teams.
  • Developed an internal app-builder that lets teams ship production-ready applications in hours instead of days.
  • Architected and integrated an AI browser agent (SDK + browser extension) into enterprise logistics dashboards.
  • Built an internal CLI-based agentic pipeline automating PRD-to-code workflows using Claude Code CLI + Node.js, integrated with Atlassian and Figma via MCP.
  • Designed and maintained reusable UI component libraries that improved engineering velocity org-wide.
  • Led frontend modules end-to-end, mentored engineers, contributed to architecture decisions.
Senior Frontend Developer
Dec 2020 – Dec 2024
  • Architected scalable frontend modules for real-time logistics dashboards — live fleet positions, route execution, delivery status across thousands of concurrent data points.
  • Built and maintained large-scale features serving enterprise clients in 30+ countries with React and TypeScript.
  • Contributed to shared UI systems and internal developer tooling.
  • Collaborated with product and backend teams to deliver customer-facing features across desktop and mobile.
Apr 2018 – Dec 2020 · 2 yrs 9 mos
Gurgaon

Zomato

Consumer food-tech platform serving millions of users.

Software Development Engineer
Apr 2018 – Dec 2020
  • Co-authored Zomato's internal React component library, adopted across multiple product teams to standardize UI development.
  • Led web performance optimization — improved page load and rendering efficiency for a platform serving millions.
  • Contributed to a large-scale website modernization project, improving architecture, maintainability, and DX.
  • Built production-grade UI features across consumer-facing web surfaces at scale.
Feb 2018 – Dec 2018
Bengaluru

MountBlue Technologies

Web Developer Trainee
Feb 2018 – Dec 2018
  • Completed an intensive full-stack engineering bootcamp; built production-style apps using React, Node.js, and modern web tooling.
// projects

Selected work.

A mix of platform work inside Locus and earlier consumer-web craft at Zomato.

Agentic PRD-to-Code Pipeline

Locus
2025

Internal CLI that turns Jira tickets and Figma specs into scaffolded, reviewable pull requests. A Node.js orchestrator wraps Claude Code with MCP servers for Atlassian, Figma, and GitHub.

  • Collapses PRD → first-commit from days to minutes
  • Multi-agent planning with deterministic tool use
  • Shipping to internal squads as a shared CLI
Node.jsClaude Code CLIMCPTypeScriptGitHub API

Config-Driven UI Platform

Locus
2025

A runtime-configurable React platform that lets product teams assemble bespoke enterprise dashboards from a shared component catalog — no forking, no custom builds per client.

  • Powers workflows for 200+ enterprise clients in 30+ countries
  • JSON-schema-driven composition + validation
  • Cut per-client custom engineering to near zero
ReactTypeScriptJSON SchemaDesign Systems

Internal App-Builder

Locus
2025

Visual assembly tool on top of the platform — lets non-frontend teams compose production-ready apps from primitives, preview them live, and ship in hours instead of days.

  • Drag-in-place composition with real data bindings
  • Built-in deploy + versioning pipeline
  • Unlocked product & ops engineers to ship UI
ReactTypeScriptMonacoStorybook

AI Browser Agent — SDK & Extension

Locus
2025

Embedded an AI browser agent into enterprise logistics dashboards — an SDK plus a companion browser extension that automates multi-step operator workflows from natural-language intent.

  • Cross-origin extension running inside SSO environments
  • Task runner with replayable DOM action traces
  • Zero-downtime integration with existing dashboards
ReactBrowser Extensions (MV3)Agent SDKTypeScript

Real-Time Logistics Dashboards

Locus
2020 – 2024

Operator UIs for live fleet tracking — positions, routes, delivery states — handling thousands of concurrent telemetry updates without dropping frames.

  • Sub-16ms frame budget under enterprise load
  • Backbone of Locus's Gartner-recognized 2024 product
  • Core surface behind 1.5B+ deliveries optimized
ReactTypeScriptWebSocketCanvas / Mapbox

Shared Component Library

Locus
ongoing

Maintained the internal React component library that every Locus surface builds on — primitives, tokens, theming, and patterns used across ops consoles, customer portals, and the app-builder.

  • Shared design tokens across white-labeled deployments
  • Accessibility baseline + theming baked in
  • Improved engineering velocity org-wide
ReactTypeScriptStyled ComponentsStorybook

Zomato Component Library

Zomato
2018 – 2020

Co-authored Zomato's internal React component library, adopted across multiple consumer-product teams to standardize UI development and accelerate delivery.

  • Adopted by multiple product squads at Zomato
  • Standardized UI primitives across consumer web
ReactReduxStyled ComponentsWebpack

Zomato Web Performance

Zomato
2018 – 2020

Led web-performance initiatives on Zomato's consumer web — critical-path work, JS budget discipline, and rendering-efficiency improvements for a platform serving millions.

  • Measurable page-load and CWV wins at scale
  • Modernized frontend architecture + DX
ReactWebpackPerformance APIs
// toolkit

What I reach for.

Languages
TypeScriptJavaScript (ES6+)HTMLCSS
Frontend
ReactReduxStyled ComponentsWebpackBrowser Extensions
Platform & Tooling
Design SystemsComponent LibrariesSDK IntegrationDeveloper Tooling
AI & Agents
LLM agent orchestrationClaude Code CLIMCP (Model Context Protocol)Agentic workflows
Backend / Ops
Node.jsREST APIsGitLinux
Education
B.Tech, Computer Science & Engineering
JIS College of Engineering
2013 – 2017 · CGPA 8.97
Publication
“Dynamic Referencing Data Warehouse Employing Proposed Time Integrated Seed Based Element Engendered Cryptographic Algorithm”
ACM-WIR'16 · March 2016
// contact

Let's build something.

Open to senior frontend, platform, or frontend × AI roles. Also happy to chat about agentic tooling, design systems, or web performance.

sengupta335@gmail.comLinkedInGitHub
↳ Based in Bengaluru, India