Location
United States
Job Type
full-time
Work Format
๐ŸŒ Remote
Salary
$180k-$240k
Posted
November 15, 2026

Job Description

NewtonX (600+ clients like TikTok, Microsoft, Salesforce, Bain, Figma and many more) is a research intelligence company helping organizations make better business decisions and train better AI models through verified human intelligence.

We turn specialized human expertise into reliable business decisions (e.g., product launches, marketing strategy, brand reputation tracking, M&A due diligence) and AI training data (frontier model improvements and evals).

We have several million domain experts that we have sourced over the last few years (150+ industries including finance, legal, coding, tax & accounting, healthcare, semiconductors, cybersecurity, STEM and more).

We have worked with AI Labs and Enterprises on topics ranging from sourcing senior electrical and SW engineers for a chip design benchmark to pediatricians and psychiatrists for clinical data to ML engineers and PhD-level statisticians proficient in 3D modeling.

About The Role

We are looking for a Staff Frontend Engineer with deep expertise in React and TypeScript. You’ll own the frontend architecture behind the data-dense applications our clients and research teams use every day, where performance, accessibility, and interaction quality are the product. This is a hands-on role: you’ll write production code, but your leverage comes from the systems and standards you leave behind.

What We’re Looking For

  • 6+ years engineering experience, mostly frontend, including 3+ at a senior level owning projects end-to-end

  • Deep React expertise — hooks, composition patterns, and the ability to reason about rendering behavior rather than guess at it

  • Strong TypeScript — typing that catches real bugs instead of decorating the code

  • Expert JavaScript (ES6+), HTML, and CSS/SCSS, including the modern layout model

  • Proven ownership of frontend architecture at scale: module boundaries, shared component libraries, and state management strategy

  • Web performance as a discipline — Core Web Vitals, bundle analysis, code splitting, virtualization, and profiling with real tooling

  • Accessibility fluency — WCAG 2.1 AA, semantic HTML, keyboard and focus management, screen reader testing

  • Design system experience: reusable, themeable, documented components built in partnership with Design

  • Testing depth — Jest and React Testing Library, plus end-to-end coverage (Playwright or Cypress) people actually trust

  • Fluency consuming APIs: REST and/or GraphQL, data-fetching and caching patterns (React Query, SWR, Apollo), and error states that hold up in production

  • Working knowledge of Python/Django — enough to read backend code, shape endpoints with backend engineers, and ship a small change yourself

  • Ability to mentor, review code with judgment, and raise the bar without becoming a bottleneck

Bonus Skills (Nice-to-Haves)

  • Server-side rendering (Next.js, Remix) and hydration tradeoffs

  • Frontend observability and performance budgets enforced in CI (Sentry, Datadog RUM)

  • Data visualization at scale (D3, Recharts, Visx, canvas/WebGL)

  • Real-time UI: WebSockets, polling strategies, streaming or collaborative interfaces

  • Styling systems (Material-UI, Tailwind) and state management (Redux, Zustand)

  • Build and monorepo tooling ownership (Vite, Webpack, CI pipelines)

  • Cloud and infra exposure: GCP, Kubernetes, Docker, Terraform

  • Internationalization, or SOLID design principles applied with judgment

What You’ll Do

  • Own the architecture of our React/TypeScript applications and the patterns the team builds on

  • Lead development of performant, accessible UIs for complex research and analytics workflows

  • Set and defend frontend standards — performance budgets, accessibility, testing, and quality gates in CI

  • Build and evolve our shared component library and design system with Design

  • Drive measurable performance work: profile, fix the real bottleneck, instrument it so it stays fixed

  • Partner with backend engineers on API contracts that make the frontend simpler, not harder

  • Pay down frontend technical debt deliberately, and contribute to Python/Django services where it speeds delivery

  • Mentor engineers and own department-wide technical initiatives from proposal through adoption

What We Offer

  • Competitive compensation with a total compensation range of $180k-$240k and equity. (Please note that salary and compensation may vary based on skills, experience, performance, and location.)

  • Excellent medical, dental, and vision insurance.

  • 401k match with immediate vesting.

  • Generous Paid time off: vacation, holidays, sick, and parental leave.

  • A diverse, collaborative, and positive culture where we invest in and celebrate each other’s success.

NewtonX is proud to be an equal opportunity workplace. We do not discriminate based upon race, religion, color, national origin, sex, sexual orientation, gender identity/expression, age, status as a protected veteran, status as an individual with a disability, or any other applicable legally protected characteristics.

๐ŸŽฏ Who is this job for?

This role is suited for a Senior-level Staff Frontend Engineer with 6+ years of experience, including substantial ownership of large-scale frontend projects, and deep expertise in React, TypeScript, JavaScript, HTML, CSS/SCSS, frontend architecture, performance, accessibility, testing, design systems, and API integration.

The ideal candidate should be familiar with building data-intensive applications, shared component libraries, state and data-fetching systems, Core Web Vitals optimization, virtualization, profiling, WCAG compliance, automated testing with Jest, React Testing Library, Playwright or Cypress, and production observability.

They should also be comfortable reading and contributing to Python/Django services, partnering on API design, mentoring engineers, reviewing code, reducing technical debt, and leading department-wide frontend standards and initiatives from proposal through adoption.

๐Ÿ’ฌ Potential Interview Questions

How would you structure a large React and TypeScript application to maintain clear module boundaries as the product grows?

I would organize the application by business domains or features, keeping UI, data access, state, and validation close to the domain they serve. Shared components and utilities should be extracted only when their APIs are stable, with dependency rules enforced through conventions or tooling.

How do React rendering behavior and hooks affect performance, and how would you investigate unnecessary re-renders?

I would use React DevTools Profiler and browser performance tools to identify expensive renders rather than adding memoization preemptively. I would then review state ownership, unstable object or callback references, effect dependencies, component boundaries, and opportunities for memoization or list virtualization.

How would you design TypeScript types for a frontend consuming REST or GraphQL APIs?

I would define explicit domain and API response types, generate types from schemas where possible, and validate untrusted runtime data at the boundary. I would distinguish loading, success, empty, and error states so invalid or incomplete API responses cannot silently propagate through the UI.

How would you implement data fetching and caching for a data-dense research application?

I would use a server-state library such as React Query, SWR, or Apollo to manage caching, deduplication, invalidation, retries, and background refetching. Query keys should reflect resource identity and filters, while stale data, optimistic updates, pagination, and error recovery should be chosen according to the workflow.

What techniques would you use to improve Core Web Vitals in a React application?

I would measure real and synthetic performance, then address the actual bottlenecks through code splitting, lazy loading, optimized assets, reduced JavaScript, efficient rendering, and virtualization. I would track metrics such as LCP, INP, and CLS in production and enforce performance budgets in CI where practical.

How would you make a complex data table accessible and performant?

I would use semantic table elements when the content is tabular, provide proper headers and relationships, support keyboard navigation and visible focus, and announce sorting or loading changes appropriately. For large datasets, I would virtualize rows carefully while preserving usable focus behavior, screen-reader context, and stable row identities.

What principles would guide the design of a reusable, themeable component library?

Components should have focused responsibilities, predictable APIs, composable behavior, accessible defaults, and tokens for typography, spacing, color, and states. I would document them with interactive examples, test critical states, and establish a contribution and versioning process with Design and consuming teams.

How would you build a testing strategy using Jest, React Testing Library, and Playwright?

I would use unit tests for pure logic, focused component tests for user-visible behavior, and Playwright tests for critical end-to-end workflows and integration points. Tests should query by accessible roles and labels, avoid implementation details, and include meaningful loading, error, permission, and empty states.

How would you diagnose and fix a slow interaction in a data visualization or analytics workflow?

I would reproduce it with representative data and profile both React work and browser main-thread activity using DevTools and the React Profiler. Depending on the bottleneck, I might reduce recalculation, debounce input, move work off the main thread, simplify rendering, aggregate data, or use canvas/WebGL, then verify the improvement with production instrumentation.

How would you collaborate with Django backend engineers to create frontend-friendly API contracts?

I would agree on resource shapes, pagination, filtering, sorting, validation errors, permissions, and stable error semantics before implementation. I can inspect Django code and make small changes when needed, while favoring explicit contracts and schema documentation that reduce frontend-specific workarounds.

๐Ÿ“‹ Job Summary

NewtonX is a research intelligence company transforming verified human expertise into better business decisions and AI training data for leading organizations. As a Staff Frontend Engineer, you’ll own React and TypeScript architecture, build performant and accessible data-rich applications, evolve the design system, improve testing and observability, and mentor engineers while collaborating with Python/Django backend teams. This is a fully remote, full-time role using React, TypeScript, JavaScript, HTML, CSS/SCSS, Jest, React Testing Library, Playwright or Cypress, REST/GraphQL, and tools such as React Query, Next.js, and D3. Compensation is $180,000–$240,000 plus equity, with excellent benefits, making it a compelling opportunity to shape high-impact products and raise frontend standards at a growing company serving 600+ clients.

Required Skills

React TypeScript JavaScript HTML CSS Jest Playwright GraphQL

Never miss a JavaScript opportunity

Subscribe to get similar jobs and weekly insights delivered to your inbox

Hiring JavaScript developers?

Post your job to 10,300+ registered developers. Starting free.

See Pricing

Related jobs

United States

Forward Deployed Engineer

DigiCert

Full-time
United States

Software Engineer

Lightyear

Full-time

Is this your listing? Claim or request removal