Open to remote startup roles

I make complex systems feel

I design and ship developer tools, workflow systems, and SaaS products end to end, from the interface to the execution engine behind it.

Role
Full-stack product engineer
Focus
Developer tools · AI workflows · SaaS
Location
India / IST (UTC+5:30)
SSproutAAtlasEExecuteCCodeMapInterfaceAPIsQueuesDataAIShip
Drag a node · tap a project to open it

Now building

  • Building Sprout’s Go control API for small, agent-built applications
  • Hardening Atlas source provenance across GitHub reviews and Notion revisions
  • Hardening Execute agent proposals, approvals, and failure recovery
  • Improving architecture and dependency visualization workflows
  • TypeScript
  • Next.js
  • Go
  • PostgreSQL
  • pgvector
  • Redis + BullMQ
  • NestJS
  • LLM tool loops
  • Approval gates
  • Cited evidence
  • Tenant isolation
  • Docker
  • Observability
  • Idempotency

01 / Selected work

Enter a system.
Follow the decisions.

Developer tools and AI systems built end to end — interface, data model, execution path, and the safeguards in between. Each case study explains the decisions, not just the stack.

  1. Infrastructure ProductIn active build

    Sprout

    An agent-native cloud for deploying and sharing small, purpose-built applications.

    Key decisionValidate the complete product workflow through a typed control-plane prototype, then replace its mock adapter incrementally with one modular Go API while keeping Drizzle as the single schema and migration owner.

    • Responsive Next.js control-plane prototype spanning apps, deployments, logs, environment, access, workspace activity, and agent journeys
    • Twelve-table PostgreSQL model for workspaces, applications, deployments, resources, access grants, and agent run history
    • Tested Go 1.27 backend executable that establishes the service boundary for the future deployment and agent API

    Next.js · React · TypeScript · TanStack Query · Go · PostgreSQL · Drizzle · Docker

    The control plane and data model are built; the Go API and real deployment runtime are in progress. Walkthroughs of the prototype are available on request.

  2. Source-backed ProductDeployment pending

    Atlas

    Source-backed engineering intelligence for understanding every software change before it ships.

    Key decisionMake every impact conclusion traceable to persisted source evidence, while keeping GitHub identity separate from narrowly scoped GitHub App repository access.

    • GitHub App ingestion for repositories, commits, pull requests, reviews, actors, and bounded history
    • Notion OAuth, resource selection, document revisions, editor provenance, and incremental synchronization
    • Planned-change and pull-request analysis backed by a cross-repository graph and persisted citations

    Next.js · NestJS · PostgreSQL + pgvector · Redis + BullMQ · Better Auth · GitHub App · Notion API · Groq

    Synchronization, the evidence graph, and impact reports run end to end locally; production infrastructure and staging acceptance come next. A live walkthrough is available on request.

  3. Product FrameLive

    Execute

    An approval-gated agent for creating, inspecting, and operating deterministic business workflows.

    Key decisionKeep model reasoning separate from mutation authority: every write becomes a persisted, validated proposal that the user must approve before deterministic code executes it.

    • Tenant-scoped tools for workflows, executions, forms, contacts, and integrations
    • Persisted create, update, run, retry, cancel, and disconnect proposals with explicit approval
    • Failure monitor with deterministic classification, redacted evidence, and guided repair actions

    Next.js · TypeScript · Supabase · Drizzle · Groq · Resend

  4. Product FrameLive

    CodeMap

    Import repositories, visualize architecture, and query large codebases with context-aware retrieval.

    Key decisionCreate a structured repository context layer before enabling search so answers can stay grounded in the actual codebase.

    • Repository import surface for bringing in unfamiliar codebases
    • Architecture graph layer for mapping system relationships
    • Grounded query interface for code-aware retrieval

    Next.js · Node.js · PostgreSQL · Redis · LLMs

Earlier work

02 / Approach

From ambiguity
to operation.

The same loop runs through every project: understand the constraint, give the system a spine, make it real early, and put safeguards where mistakes get expensive.

  1. 01

    Understand

    Find the real problem.

    Start with the user, the constraint, and the outcome—before choosing a framework or drawing a screen.

    Problem brief
  2. 02

    Model

    Give the system a spine.

    Define the states, responsibilities, data boundaries, and failure paths that make the product understandable.

    System map
  3. 03

    Build

    Make the path tangible.

    Connect the interface to working execution early so the riskiest assumptions meet reality fast.

    Vertical slice
  4. 04

    Protect

    Design the trust boundary.

    Add validation, permissions, approval gates, idempotency, and recovery where mistakes become expensive.

    Safety layer
  5. 05

    Ship

    Close the last mile.

    Deploy the complete workflow with useful telemetry and a clear path for diagnosing what happens next.

    Production release
  6. 06

    Improve

    Feed reality back in.

    Use product signals and failure evidence to improve both the experience and the architecture with intent.

    Learning loop

What I can own

Skills connected to proof.

  • Product UI

    I turn complex system behavior into interfaces people can understand, trust, and operate.

    React · Next.js · TypeScript · Interaction design

  • Backend Systems

    I design APIs, state transitions, queues, and execution paths that stay observable under real use.

    Go · Node.js · API design · Deterministic workflows

  • Data & Infrastructure

    I shape data models and deployment boundaries so products can grow without losing clarity.

    PostgreSQL · Docker · Redis · Vercel

  • AI Workflows

    I connect model reasoning to grounded context, explicit controls, and deterministic application code.

    LLM APIs · Retrieval · Tool loops · Safety boundaries

  • Shipping & Reliability

    I own the final mile: validation, failure recovery, deployment, telemetry, and iteration.

    GitHub · Validation · Observability · Release loops

  • Where I’m going deeper

    Go service design for Sprout’s control API, and production operations for Atlas: deployment, backups, rollback, and release acceptance.

    Go · Docker · PostgreSQL operations

03 / Evidence

The work leaves
a signal.

Claims fade quickly. Real interfaces and a visible shipping trail make the engineering legible.

From the product archive

Real interface captures · select to inspect

Recent shipping

A visible trail of iteration, month by month.

  1. September 2026

    • Built Sprout’s responsive product prototype, PostgreSQL foundation, and first compiled Go backend command
    • Defined the incremental path from typed mock workflows to a versioned control API and isolated deployment runtime
  2. August 2026

    • Completed Atlas GitHub and Notion synchronization, cross-repository graphs, persisted impact reports, and production acceptance tooling
    • Added approval-gated agent actions, tenant-safe tools, usage controls, and failure monitoring to Execute
  3. May 2026

    • Added repository import pipeline to CodeMap
    • Improved selected work deep-dive and architecture surfaces
  4. April 2026

    • Refactored Execute execution engine around deterministic orchestration
    • Strengthened async validation and queue-backed workflow handling
  5. March 2026

    • Built async validation pipeline experiments for Execute
    • Started architecture visualization and retrieval exploration for CodeMap

04 / Final checkpoint · The next system starts with a conversation

Have a difficult product problem?

I work best with small teams building technically ambitious products where ownership matters more than job boundaries. Email is the fastest way to reach me.

Availability
Open to remote startup roles
Based in
India / IST (UTC+5:30)
Works
Remote-first / async-friendly
Elsewhere
GitHub LinkedIn X