SHUBHAMDIXIT

Context

Nutcake is a three-sided marketplace connecting brands, content creators, and talent agencies to run influencer marketing campaigns end-to-end — from creator discovery and outreach through contract negotiation, content delivery, and payout.

Engineering Challenge

Delivering consistent UX and rapid feature velocity across 11 separate TypeScript/Next.js applications (Brand, Creator, Talent Agency, Admin, and supporting public-facing apps), while keeping long-running, non-blocking work off the critical request path for every one of those apps.

Engineering Approach

Built and maintain core platform modules within a pnpm/Turborepo monorepo sharing a common component library and data layer, so each user-facing surface stays consistent by construction rather than by convention.

Technical Decisions

• Modeled the domain around a Mission → Deal Memo → Contract lifecycle, where a brand's campaign (Mission) fans out into individually-tracked creator agreements (Deal Memos), each progressing through its own commercial and delivery status ladder.
• Implemented async, event- and schedule-driven backend workflows on Trigger.dev (nightly sync jobs, batched messaging, social-media scraping, CRM push) instead of blocking request-time work.
• Integrated the third-party service layer — HubSpot (CRM/sales sync), Stripe (payouts), PandaDoc (e-signature contracts), Clerk (auth), Twilio/Resend/SendGrid (creator messaging), and Meilisearch (creator/ad search) — as wrapped, shared clients consumed across every app.
• Built UI features against a shared, Storybook-documented design system to ensure pixel-accurate, consistent presentation of complex workflow state to non-technical end users.

System Flow

Context

A production Next.js 16 (App Router, React 19, TypeScript) member portal — authenticated flows for login, profile, ticket transactions, giveaway entry, and referrals — plus a full admin console for role/permission management, audit logs, and platform analytics, backed by an Express/TypeORM API designed end-to-end.

Engineering Challenge

A silent-logout defect traced to Next.js's automatic <Link> prefetching triggering a GET-accessible logout/token-revocation route on Amplify SSR — a framework-level, CSRF-adjacent vulnerability class, not an isolated bug.

Engineering Approach

Diagnosed the root cause rather than patching the symptom, then refactored all destructive actions off GET routes across the app to close the entire vulnerability class.

Technical Decisions

• Architected the server/client data boundary so async Server Components fetch through server-only authenticated clients, keeping httpOnly JWT cookies out of the browser entirely.
• Used TanStack Query to drive client-side caching, polling, and invalidation, replacing ad-hoc useEffect fetching with a consistent, typed pattern shared across both layers.
• Built a 60+ component design system (UI primitives → layout → feature components) with light/dark theming, documented and visually tested in Storybook with a11y addon coverage.
• Enforced 60+ Jest/React Testing Library suites with coverage thresholds, Husky/lint-staged pre-commit hooks, and ESLint 9 flat-config + Prettier — the same zero-warning discipline as the backend API this frontend consumes.

System Flow

Context

Vialma runs a music streaming platform built with Next.js, React.js, Node.js, and REST APIs, serving listeners across a range of devices with a small, globally-distributed engineering team behind it.

Engineering Challenge

Playback-heavy views were sensitive to both initial load weight and API call volume, and any performance work had to hold up consistently across device types rather than just on a reference desktop setup — all while coordinating changes with a team spread across time zones.

Engineering Approach

Treated playback performance as an ongoing scalability concern rather than a one-off fix: paired lazy loading of playback-heavy assets with optimized API call patterns, then validated the result across devices before rolling changes out through the team's shared deployment process.

Technical Decisions

• Applied lazy loading to reduce initial load weight on playback-heavy views.
• Optimized API call patterns for scalability under concurrent listeners.
• Delivered responsive, multi-device experiences coordinated across a global team.

System Flow

Context

Worked as a remote full-stack consultant delivering web applications for multiple clients in parallel, using a consistent React.js, Next.js, Node.js, and TypeScript stack across each engagement rather than adapting to a different toolset per client.

Engineering Challenge

Each client came with its own third-party integrations and performance expectations, so the work had to stay scalable and on-time across concurrent engagements without letting one client's timeline slip because of another's scope.

Engineering Approach

Standardized the delivery stack across clients so architectural decisions and code patterns carried over between engagements, then built scalable APIs and integrated each client's specific third-party services on top of that shared foundation, keeping frontend performance and responsive design consistent throughout.

Technical Decisions

• Standardized on React.js, Next.js, Node.js, and TypeScript across client engagements.
• Built scalable APIs and integrated third-party services per client requirements.
• Ensured responsive designs and coordinated remotely with global teams for on-time delivery.

System Flow

Context

Legitify's platform handles secure, real-time document notarization, built with React.js, Redux-Saga for predictable state across complex session flows, and TypeScript throughout, serving multiple tenants on the same underlying system.

Engineering Challenge

Notarization sessions require live collaboration between multiple parties in real time, and because the platform served multiple tenants at once, any performance work had to account for concurrent sessions rather than assume a single-tenant load profile — all while keeping the security and reliability bar high enough for legal document handling.

Engineering Approach

Integrated Socket.IO specifically for the live-collaboration requirements of a notarization session, then optimized performance with multi-tenant load explicitly in mind rather than tuning for a single-tenant baseline and hoping it held up under real usage.

Technical Decisions

• Integrated Socket.IO to support live, real-time collaboration during notarization sessions.
• Optimized performance for multi-tenant systems rather than single-tenant defaults.
• Converted complex designs into responsive, reusable UI components.
• Maintained high code quality with Jest test coverage.

System Flow

Context

Worked across the full stack at Oveun — modular React component systems on the frontend, backend architecture and database performance underneath, and Web3 functionality (smart contracts, dApps) layered on top as products moved from design to production.

Engineering Challenge

Wireframes had to become production-ready applications without the backend architecture and database layer becoming the bottleneck as Web3 functionality — smart contracts, wallet integrations, dApp features — kept expanding scope.

Engineering Approach

Engineered modular React components so the frontend could scale with new features rather than being rebuilt for each one, while enhancing backend architecture, database performance, and third-party integrations in parallel so the two layers evolved together instead of one lagging behind the other.

Technical Decisions

• Led UI transformations, converting wireframes into production-ready applications.
• Enhanced backend architecture, optimizing databases and integrating third-party services.
• Developed Web3 solutions, incorporating smart contracts and dApps.

System Flow

Context

Built high-performance React applications at Yonder where load time, API latency, and overall UI/UX quality were treated as one connected problem rather than three separate workstreams competing for priority.

Engineering Challenge

Load times and API latency both needed to come down, but not at the cost of UI/UX quality or the reliability of API integrations — a common failure mode where performance work degrades the experience it's meant to improve.

Engineering Approach

Paired caching mechanisms with UI/UX optimizations in the same effort rather than sequencing them as separate initiatives, so performance gains and interface improvements landed together and reinforced each other instead of trading off.

Technical Decisions

• Developed high-performance React applications focused on reducing load times.
• Led UI/UX optimizations while ensuring seamless API integration.
• Implemented caching mechanisms to boost API efficiency.

System Flow