Staff Frontend Engineer (Product UI and Design)

Story Terrace Inc.; Mumbai; À distance; INR 4 000 000 - 7 000 000; Plein temps

Résumé du poste

Lexsi Labs in Mumbai and remotely is seeking a hands-on frontend engineer to own the platform's React and TypeScript frontend, shaping flows, data models and the visual language. You will work with researchers and platform engineers to turn cutting-edge methods into usable product features.

Expect to lead the frontend architecture, maintain a shared component library and design tokens, ensure performance budgets, accessibility, i18n, and offline builds, and ship polished interfaces for

Qualifications

• 8+ years building production web applications and leading complex UIs.
• Expert-level TypeScript and React with advanced rendering/concurrency awareness.
• Led architecture or major migrations in a live frontend project.
• Experience shipping for on-premise, regulated or air-gapped environments.
• Portfolio showing decisions and code across multiple user types and locales.

Responsabilités

• Write production React and TypeScript code most of the week.
• Own the frontend architecture and the component library design tokens.
• Set and enforce performance budgets and optimize heavy views.
• Collaborate with researchers and platform engineers to turn methods into usable products.
• Ship interfaces that work for researchers, risk reviewers and business users.
• Lead testing strategies with Vitest/Jest and Playwright for end-to-end flows.
• Ensure accessibility, i18n, and enterprise UI requirements (SSO, auditability).
• Move from design (Figma) to production with strong code review standards.

Connaissances

TypeScript

React

Frontend architecture

Component library

Design system

Performance profiling

Testing (Vitest/Jest)

Playwright

OpenTelemetry / web vitals

LLM-powered features

Outils

TanStack Query

Tailwind CSS

React Hook Form

Zod

Vite

pnpm

CodeMirror/Monaco

OpenTelemetry

Storybook

Description du poste

About Lexsi Labs

Lexsi Labs is a frontier AI lab working toward aligned, interpretable and safe superintelligent systems. Our near-term mission is to build safety-aware autonomous systems for mission-critical settings such as banking, insurance, government and healthcare. We believe the institutions that deploy AI should be able to audit, correct and own the risk of the models they rely on, and we build the research and the platform that make that possible.

Our research spans AI alignment methodologies, interpretability-led system design, and foundation model research across language, structured and tabular data, and autonomous systems. We have published 25+ papers in the past 15 months across conferences including ICLR, ICML, WWW, IJCNN, MICCAI and EurIPS. Our labs are in India (Mumbai and remote), Paris and London.

We operate with a flat structure, high autonomy, and a strong bias toward engineers who take full ownership of what they build, from architecture to production behaviour.

About the Role

We are building the platform through which institutions own the AI they depend on. Post-training, alignment, evaluation, deployment and monitoring run inside the customer’s own environment, on the methods our labs publish.

The people using it vary widely. Post-training scientists and AI researchers run experiments at the edge of what current methods can do. AI and ML engineers take models and agents into production. Data scientists build and validate models on enterprise data. Platform and infrastructure teams operate the compute and services underneath. Inside banks, insurers and public institutions, model risk, validation and audit teams need to understand and sign off on results without writing code, and business owners need to see what is running and how it is performing. The same screen often has to serve a researcher and a risk reviewer.

The interface decides whether frontier model science stays in research papers or becomes something every institution can operate.

This is a hands-on individual contributor role. You will write production React and TypeScript most of the week, own the frontend architecture of the platform, and make the final call on its flows, information architecture and visual design. You will work with a product designer and one or two frontend engineers, setting the standard through code and review rather than management. Expect roughly 70% of your time on building and 30% on design decisions, review and direction.

What you’ll work on

• Own the frontend architecture of a large React and TypeScript application: routing and layout, code splitting, state boundaries, and the contracts between the UI and backend services.
• Own the component library and design tokens as a single system used across the application, evolving it incrementally in a live codebase without pausing feature work.
• Design and build data-dense interfaces: virtualised tables over large result sets, live metrics and log streams, trace and graph visualisations, side-by-side comparisons, and code and configuration editors.
• Build a real-time data layer over SSE and WebSockets with reconnection, backpressure and cache semantics that stay consistent with request-response queries.
• Build schema-driven form systems for deeply nested, conditional configuration, validated against backend schemas.
• Design interfaces that work for users with very different levels of technical depth, from researchers to risk reviewers, without splitting the product in two.
• Make the final call on information architecture, interaction and visual design, and take your decisions from Figma to production yourself.
• Set and enforce performance budgets: render profiling, bundle size, and interaction latency on locked-down enterprise machines.
• Ship builds that run in restricted and fully offline networks, with reproducible builds, self-hosted assets and no runtime dependence on external hosts.
• Meet enterprise requirements in the UI: SSO, role-aware interfaces, auditability, accessibility, and internationalisation including right-to-left layouts.
• Raise the engineering bar across the frontend: type safety, testing strategy, tooling and code review.
• Work directly with researchers and platform engineers to turn new methods into usable product, often before the method has settled.

You may be a good fit if you have

• 8+ years building production web applications, including several years as the technical lead on a complex product UI.
• Expert-level TypeScript and React, including React 19 rendering and concurrency behaviour and hands-on performance profiling.
• Owned the architecture of a large frontend codebase and improved it materially while the team kept shipping.
• Led an incremental migration in a live application, such as a component library, state management approach, router or build system.
• Built interfaces where performance was the hard problem: tens of thousands of rows, high-frequency streaming updates, large JSON or log payloads, or complex interactive charts.
• Deep, practical experience with TanStack Query or equivalent, Tailwind CSS, React Hook Form with Zod, Vite and pnpm.
• Built or maintained a design system with tokens, theming, accessibility to WCAG standards and documentation in Storybook.
• Designed and shipped product yourself, with a portfolio that shows both the decisions you made and the code that implemented them.
• Built for multiple user types with different expertise in the same product, and made it work for each of them.
• A testing discipline built on Vitest or Jest, Playwright and API mocking.
• Worked without a product manager or a full spec, decided what to build, and defended the decision with evidence.
• Clear written and verbal communication of trade-offs to engineers, researchers and leadership.

Strong candidates may also have

• Built developer tools or ML tooling, such as experiment tracking, training dashboards, evaluation or observability products.
• Visualisation depth with ECharts, D3, or canvas and WebGL rendering.
• Built graph or trace viewers (React Flow or similar) and embedded code editors (CodeMirror or Monaco).
• Shipped software into on-premise, regulated or air-gapped environments.
• Built right-to-left and multi-locale products.
• Used state machines such as XState for complex multi-step flows.
• Instrumented frontends with OpenTelemetry and web vitals.
• Shipped LLM-powered product features.
• Contributed to open-source frontend libraries.

If you meet most of this but not all, we would still like to hear from you.

What this role is not

• Not a people management role at the start. There are no direct reports, and influence comes through code, review and design decisions.
• Not a visual design role. You will design, but you will be measured on what ships to production.
• Not a ticket-implementation role. You will be expected to question specs and decide what should be built.

What we expect in the first six months

• Own a set of redesigned core flows end to end, from information architecture through to production.
• Establish the component system and tokens as the single source of truth for the application.
• Set performance budgets for the heaviest views and bring them within budget.
• Put test coverage in place across the core flows.

How we will evaluate

• A review of shipped work where you can show both the design decisions and the code.
• A build exercise on a data-dense screen, assessed on code quality, structure and performance.
• A design critique of a flow in our product, where you decide what changes and why.
• An architecture conversation on component systems, data and streaming layers, and offline deployment.