India, working globally ch.00 / index

Nandhakumar Subramanian

I ship the whole product, not just my part of it.

My best work sits where product judgment meets production engineering — connecting frontend, backend, AI, and deployment into systems that ship and stay useful.

Email me GitHub LinkedIn
build.sh

✓ boot:init environment ready

✓ lint:clean 0 warnings

✓ test:pass 42/42 suites

✓ build:bundle tree-shaking modules

✓ build:complete 238 kB total

✓ deploy:stage pushing to preview

✓ ship:ready ✦ production live

Now

What I'm building this month.

Updated . Hand-edited; not auto-generated.

  • Hardening a multi-tenant app

    Tightening org-scoped data boundaries, deploy verification scripts, and rollback documentation.

  • Agentic dev workflows

    Building review, planning, and verification skills that compress my own iteration loop without reducing rigor.

Systems I've built

Technical depth, not buzzwords.

Real architectural decisions from production systems — the problems, the patterns chosen, and the stack behind them.

01

AI Search & Reasoning Pipeline

Multi-signal search ranking that combines semantic similarity, keyword relevance, and LLM scoring into a single ranked result without sacrificing latency.

  • Dual-search: Pinecone vector search + Supabase full-text search fused with Reciprocal Rank Fusion (RRF)
  • Multi-LLM routing via LiteLLM — OpenAI, Gemini, and Voyage AI behind a single interface
  • RAG pipeline with context caching, token counting (tiktoken), and prompt compression
  • Intent classification and query reformulation before retrieval
  • A/B testing framework for ranking algorithm variants
AI LiteLLMLangChainPineconeOpenAIGeminiVoyage AIspaCysentence-transformers
Backend FastAPIPython 3.12
02

Production Web Application

A multi-tenant SaaS frontend with real-time chat, large list virtualization, and org-scoped data isolation that stays fast under concurrent load.

  • Next.js App Router with Clerk multi-tenant auth and Supabase row-level security
  • WebSocket chat with backpressure, message acknowledgment, and connection health monitoring
  • Zustand for client state + TanStack React Query for server state — no overlap
  • TanStack Virtual for large data lists without DOM thrashing
  • Radix UI primitives + shadcn/ui pattern with class-variance-authority for variant-safe components
  • Feature flags, guided onboarding tours, and Cal.com scheduling embed
Frontend Next.js 16React 18TypeScriptTailwind CSSZustandFramer Motion
Backend SupabaseClerkUpstash Redis
03

Deployment & Observability Stack

A zero-downtime deployment pipeline for a multi-service system on ARM64 VMs with full observability and resilience patterns baked into the application layer.

  • CircleCI pipeline + GitHub Actions (CodeQL, security scans, scheduled smoke tests)
  • Docker multi-stage ARM64 builds pushed to OCI registry, orchestrated with Docker Compose
  • Nginx reverse proxy with SSL termination and Cloudflare WAF in front
  • Prometheus metrics + Grafana Cloud dashboards + Loki log aggregation + Sentry error tracking
  • Circuit breaker + bulkhead isolation + retry with tenacity in the backend service layer
  • ARQ (Redis-backed) async job queue for document parsing, entity extraction, and insights generation
Infra DockerNginxCircleCIGitHub ActionsOCI Registry
Observability PrometheusGrafanaLokiSentryOpenTelemetry
Backend ARQRedisFastAPI

AI-assisted engineering

Tools I work with daily.

I use AI coding tools as force multipliers — each one for a specific job, not as a replacement for engineering judgment.

  1. Kiro

    Spec-driven development — brainstorming, writing plans, and executing multi-step implementation tasks with persistent context.

  2. Claude Code

    Deep codebase reasoning, architecture decisions, and complex refactors that require holding large context.

  3. GitHub Copilot

    In-editor completions and inline chat for fast iteration on boilerplate, tests, and repetitive patterns.

  4. Codex

    Automated code generation for scaffolding, migration scripts, and test suite expansion.

  5. Cursor

    Multi-file edits and codebase-aware refactoring with composer mode for coordinated changes.

  6. Gemini

    Long-context analysis for large files, documentation review, and cross-file dependency tracing.

How I work

Calm systems. Clear proof.

  1. Make the product legible

    Good engineering should make the next decision easier for users, teammates, and future maintainers.

  2. Secure by default

    The cheapest security work happens early: narrow surfaces, typed data, strict headers, and no needless backend.

  3. Ship proof, not theater

    I prefer working software, test output, deployable artifacts, and clear tradeoffs over presentation-only progress.

  4. Keep craft close to code

    Visual polish, accessibility, performance, and reliability belong in the same implementation conversation.