About the role:

This is not a role where you maintain a dashboard and close tickets. We build AI-native enterprise software. Real-time multilingual voice, heavy data pipelines, multi-tenant systems, and interfaces that thousands of people sit inside all day, across India, the UK and Europe.

The work is hard in the way good engineering work is hard. Latency budgets you actually have to hit. Queries that fall apart at scale unless you think about them properly. UI that has to stay responsive while streaming data in from three places at once.

If you like being handed a spec and told what to type, this will not suit you. If you like owning a hard problem end to end and being the person accountable for it, keep reading.

What you'll be doing:

On the backend:

- Design and own services in Node and TypeScript, sitting on PostgreSQL.

- Model data properly. Normalised where it matters, denormalised where it earns you something. You should be comfortable reasoning about foreign keys, partial and composite indexes, and what a covering index actually buys you.

- Read query plans. Kill N+1s. Understand connection pooling, transaction isolation levels, advisory locks, and why a long-running transaction on a hot table ruins everyone's afternoon.

- Build multi-tenant boundaries that hold. Tenant scoping, RBAC, row-level isolation, audit trails. Getting this wrong in enterprise software is not a bug, it is an incident.

- Work with event-driven flows. Queues, workers, retries with backoff, idempotency keys, dead letter handling, backpressure. Exactly-once is a lie, design for at-least-once and make it safe.

- Caching that is actually correct. Cache-aside patterns, TTL strategy, stampede protection, distributed locks, and knowing when invalidation is the wrong answer.

- Real-time paths. SSE and WebSockets, streaming responses, connection lifecycle, reconnection semantics.

- Integrate with enterprise systems designed in a different decade. Legacy file transfer, XML and SOAP-ish APIs, webhook contracts, OAuth flows, rate limits you do not control.

On the frontend:

- Build in React and TypeScript on a modern Next.js setup. Server components, client components, and a clear head about which does what and why.

- Streaming SSR, suspense boundaries, route-level code splitting, and hydration behaviour you can explain rather than guess at.

- Own Core Web Vitals. LCP, INP, CLS. Bundle analysis, dependency pruning, font and image strategy, no waterfalls in the data layer.

- Complex stateful UI. Server state in a proper query cache, client state kept minimal, optimistic updates, race condition handling, stale data reconciliation.

- Data-dense interfaces done well. Virtualised tables, infinite scroll, filter and sort state in the URL, forms with schema validation on both sides of the wire.

- Real-time UI that does not thrash. Streaming tokens, live status, presence, without re-rendering the world every tick.

- A design system that stays consistent. Typed component APIs, sensible primitives, accessibility that is not an afterthought.

Across both:

- Own features from schema to screen. You design the tables, write the API, build the UI, ship it, and watch what happens after.

- Review code seriously and push back when something is wrong.

- Argue about what to build, not just how.

The kind of stack you'll be in:

- Languages: TypeScript end to end, SQL.

- Frontend: React, Next.js, a component library, utility CSS, schema validation.

- Backend: Node.js, a lightweight HTTP framework, a typed query layer, REST and streaming APIs.

- Data: PostgreSQL, Redis, object storage.

- Cloud: AWS across multiple regions. Serverless functions, managed queues, CDN, managed Postgres and cache.

- AI layer: LLM APIs, function calling, streaming inference, real-time voice.

You do not need every one of these on your CV. You do need to be the kind of engineer who picks up a new one over a weekend and is useful on Monday.

What we're looking for:

- 5 to 7 years building production web systems. Real users, real load, real consequences when it breaks.

- Deep TypeScript. Generics, discriminated unions, inference. You use the type system to prevent bugs, not to decorate the code.

- Strong React. You know why a component re-rendered and how to stop it. You know when memoisation helps and when it is cargo cult.

- Genuinely comfortable in a database. You can write the SQL yourself and you know what the ORM is doing when you don't.

- You have designed an API someone else had to consume and it held up.

- You have debugged something in production under pressure and written up what went wrong afterwards.

- You write code a stranger can read in six months.

On background: We lean towards engineers who have worked at a startup where they had to own a lot without a playbook, or who come from a strong engineering school (IIT, NIT, BITS, IIIT and similar). Both is ideal. Neither is a dealbreaker if the work speaks loudly enough. Send the GitHub, the side project, the thing that got used.

Nice to have:

- Worked with LLM APIs, streaming completions, prompt and eval design, or real-time voice.

- Built multi-tenant B2B SaaS with enterprise customers.

- Performance work you can talk about specifically. What was slow, what you measured, what you changed.

- Open source contributions, or a technical blog where you explain things properly.

- You have been the first or second engineer on something.

What working here is like:

- Fast. Really fast. Decisions get made in one conversation, not across weeks of meetings. There is no ticket queue you sit in. If you see something broken you fix it.

- You get the whole picture. Founders sit in the same room. You will know what we are prioritising and why.

- The flip side is ownership. Nobody chases you for status. Ship it, tell the team, move on.

What you get:

- Competitive salary, benchmarked properly for senior engineers in Bengaluru.

- Real ownership of systems that carry weight, not a slice of someone else's feature.

- Hard problems, short feedback loops, and no layers between you and the outcome.

- A team where you will not be the smartest person in the room every day.