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.
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.
- 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.
- 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.
- 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
- 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.
- 01
Understand
Problem briefFind the real problem.
Start with the user, the constraint, and the outcome—before choosing a framework or drawing a screen.
- 02
Model
System mapGive the system a spine.
Define the states, responsibilities, data boundaries, and failure paths that make the product understandable.
- 03
Build
Vertical sliceMake the path tangible.
Connect the interface to working execution early so the riskiest assumptions meet reality fast.
- 04
Protect
Safety layerDesign the trust boundary.
Add validation, permissions, approval gates, idempotency, and recovery where mistakes become expensive.
- 05
Ship
Production releaseClose the last mile.
Deploy the complete workflow with useful telemetry and a clear path for diagnosing what happens next.
- 06
Improve
Learning loopFeed reality back in.
Use product signals and failure evidence to improve both the experience and the architecture with intent.
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.
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
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
May 2026
- Added repository import pipeline to CodeMap
- Improved selected work deep-dive and architecture surfaces
April 2026
- Refactored Execute execution engine around deterministic orchestration
- Strengthened async validation and queue-backed workflow handling
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



