Full Stack Developer

Role: Senior Software Engineer — Full Stack
WFO Bangalore | 5+ years | AI-native product engineering

Apply Link: https://theproducthighway.keka.com/careers/jobdetails/893

Please read the job description carefully and fill out the form to apply.

About TPH
The Product Highway is an AI-native product strategy and engineering firm that partners with businesses from the earliest spark of an idea all the way through to enterprise scale. We grew from zero to multi-million ARR within our first year, working with clients across India, APAC, Europe, and North America.

AI got very good at the "how", shipping code faster than ever. But almost nothing has changed in the what: deciding what to build, why, and in what order. That's where we live. We believe software is an approximation of the real world, and what matters isn't lines of code or sprint velocity, it's whether the solution actually maps to how a business works and how value gets created.

From in-house AI project managers to near-universal adoption of tools like Cursor and Claude, we've rethought every conventional process from first principles. AI isn't a feature we offer, it's how we think, build, and deliver.

Why we're hiring
We run small teams. Two or three people carry an engagement that most firms would staff with six. That model holds until the system gets genuinely hard: multi-tenant isolation where a leak is a client-losing event, a data model that has to survive the next three customers without a rewrite, a retrieval pipeline that has to be correct rather than impressive, a legacy migration where the old system can't go down while you replace it.

That's where this role sits. You set the architecture on an engagement and then stay accountable for it while two other engineers build inside it. When something breaks in production at a client with real money moving through the system, you're the one reading the traces at 11pm.

We already have a Product Engineer role for people whose centre of gravity is deciding what the product should be. This is the other half. You'll have opinions about the product and we want to hear them, but you're hired for engineering depth and for the judgment that comes from having operated systems long enough to know how they fail.

You'll be embedded in a client engagement rather than rotating through tickets. The constant is depth. You carry the full context of the system you're building.

Who we're looking for
Every person at TPH shares these traits:

End-to-end owners. You own outcomes rather than tasks. If something you're responsible for falls through a crack, that's on you. Bugs are easy to fix. Misalignment is expensive.
Clear, direct communicators. Bad news doesn't get better with age. You surface problems early and communicate with precision.
Uncompromising on quality. You have a quality bar that's yours rather than your manager's. You won't ship something you wouldn't stand behind, even under deadline pressure.
AI-obsessed. You see AI as how work gets done. If you're still doing something manually that AI could handle, you feel that as friction.
Structured thinkers. Faced with an ambiguous problem, you break it down, reason through the trade-offs, and arrive at a position rather than waiting to be told the answer.

What you'll own
Architecture

1. Set the architecture on your engagement. Service boundaries, data model, queue design, caching, tenancy strategy, auth model. These are your calls, and you live with them for the length of the engagement and beyond.
2. Design for the second client, not just the first. Most of what we build is multi-tenant or becomes multi-tenant. You think about isolation, noisy neighbours, and per-tenant configuration before it becomes a migration.
3. Know when the simple thing is the right thing. A cron beats a queue until it doesn't. A monolith beats three services until it doesn't. You can say why, in this specific case, at this specific stage. Delivery and operations
4. Write production code in TypeScript across NestJS and Next.js. Our stack is deliberately narrow: Node, Postgres with pgvector and row-level security, BullMQ, Next.js, the Claude API. We standardise so that any of us can pick up any engagement.
5. Take features to done, including the screen. When a feature needs UI, you build the UI. A working API handed to someone else isn't a delivered feature.
6. Own data and performance. Schema design for complex domains, indexing strategy, query optimisation, migrations that run against live data without a maintenance window. You find the cause of a slow query rather than putting a cache in front of it.
7. Deploy and operate what you ship. CI/CD, Docker, AWS or GCP, monitoring, structured logging. You're the escalation point when it breaks.
8. Build AI capability into production systems. LLM integration, retrieval, agentic workflows, structured output, streaming. With evaluation, fallbacks, cost control, and observability, because a demo that works isn't a system that works. Technical leadership
9. Review the work of the engineers on your engagement against the architecture you set, and explain the reasoning rather than just leaving comments.
10. Get a new engineer productive on your codebase in a week. Documented decisions, clear boundaries, tests that mean something, a CLAUDE.md that actually reflects the repo.
11. Make build versus buy calls, including the call to not build.

** Client context**

1. Sit in client conversations without a translator. You scope, you estimate, and you're accountable for the estimate.
2. Push back when scope moves or when a request won't solve the underlying problem. Doing this well and early is a large part of why senior engineers are worth what they cost in a services business.
3. Explain trade-offs to people who don't write code, in language they can act on.

Must-haves

1. 5+ years building production systems. The number is a floor and we care more about what you've owned than how long you've been doing it. If you have five years and have run an entire platform, apply.
2. Deep Node and TypeScript, with real Postgres depth. NestJS or equivalent. Schema design for complex domains, query optimisation, migrations, indexing. Python is a plus rather than a substitute.
3. You've made architecture decisions on production systems and lived with the consequences. Queues versus crons, when to denormalise, when to split a service, how to isolate tenants. You can walk through one you got wrong and what it cost.
4. You've shipped an LLM-backed feature to production. Prompt design, structured output, retrieval or tool use, latency and non-determinism, evaluation. You know why "it worked in the demo" isn't a shipping criterion.
5. Real React and Next.js. Components, state, data fetching, forms, server components and route handlers. Not a specialist. Also not blocked by the browser.
6. You ship your code and run it. CI/CD, Docker, cloud, monitoring, debugging distributed systems under pressure.

Strong signals

1. Multi-tenant platforms with proper isolation, especially anything using row-level security or similar at the database layer.
2. Retrieval systems you evaluated rather than eyeballed. Embeddings, chunking strategy, pgvector or equivalent, measured relevance.
3. Integration-heavy work: payments, CRMs, ERPs, industry protocols where the spec is long and the counterparty is unreliable.
4. Event-driven or realtime systems. Queues at volume, WebSockets, CRDTs and collaborative editing.
5. Consulting or services experience, or early engineer at a startup. Contexts where you shipped across several products with shifting requirements.
6. You've mentored engineers and they got better. People come to you for architecture advice because your judgment has been right before.

AI-native expectations

1. Cursor or Claude Code is your primary development environment, and has been for a while. You're past experimenting.
2. You plan before you generate. Scope and structure the work first rather than prompting your way into a mess you then have to read.
3. You can evaluate AI-generated code critically. You know when it's production-ready, when it needs work, and when it's confidently wrong. You're accountable for every line regardless of who wrote it.
4. You maintain AI workflow hygiene: CLAUDE.md files, .cursorrules, context management on large repos. You make the tools work on your codebase rather than fighting them.
5. You have a view on when AI is the wrong tool, where determinism, cost, or accuracy requirements mean the conventional solution wins.

Not the right fit if

1. You've held a senior title but have never owned an account, sat in a client conversation, or made a call without a PM or a tech lead in between you and the requirement.
2. You want to work on one product for years. This is a services role and the variety is the point.
3. You refuse to touch frontend code, or expect someone else to build the UI for every feature you ship.
4. You need detailed specs before making technical decisions.
5. You've only worked inside an established platform team where infrastructure, deployment, and data modelling belonged to someone else.
6. Your AI experience stops at calling a chat completion endpoint and hoping the output parses.
7. You build things the "right" way regardless of context. Sometimes the quick solution is the correct one. If you can't ship a v1 without a service mesh, you'll clash with how we work.

How to apply
Applications are only accepted through the form.

Apply here: [https://theproducthighway.keka.com/careers/jobdetails/893]. The form takes about ten minutes.

We read every application ourselves. If there's a fit, you'll hear from us.