Senior/Staff Frontend Engineer

queueinc

Newark (CA)

Hybrid

USD 140,000 - 200,000

Full time

3 days ago

Be an early applicant

Application generator

Get a reply from this employer — a resume and cover letter tailored to exactly what they’re hiring for.

Get past ATS filters

Benefits offered by this job

Ownership over operator screen

Touch‑only interface challenges

Small, autonomous team

Job summary

queue.inc is hiring for Senior and Staff frontend roles to own the operator screen and the next screens in our machine‑interface product. You will lead end‑to‑end surface design from prototype to production React app, ensuring strict TypeScript contracts and a mouse‑free touch experience with robust test coverage.

You will collaborate with a product designer, work in a hybrid model three days per week at our Bay Area HQ, and shape the standard for future interfaces and cloud dashboards.

Qualifications

Ownership — you have owned a product surface used daily and can show what you changed after it went wrong.
Strict TypeScript — the strictest compiler settings are where you are at home, and you write types that make an invalid state impossible to express.
React 19 with the React Compiler — your components follow the Rules of React because they have to.
State discipline — you have built over state the server owns, delivered by WebSocket, and you understand why a screen that owns no domain state is safer.
Our tools — Tailwind 4, Vite, Vitest and Playwright, with component tests and real‑browser tests as a habit.
Work with design — you have turned a designer's living prototype into production software without losing the intent, and you can disagree with a designer and still ship.

Responsibilities

Own the operator screen including the queue, replenishment, machine health, and on‑screen sign‑in.
Own the prototype and the application, ensuring the design prototype and React app stay in sync.
Enforce touch-only interaction with 48px targets and no mouse/keyboard; ensure correct screen transitions.
Manage a three‑layer interruption model for alerts and faults.
Work within the interface contract where the screen renders machine data and TypeScript types stay in sync.
Support the cloud dashboard roadmap and later screens, all aligned to your standards.

Skills

Ownership

Strict TypeScript

React 19

State discipline

Tools

Tailwind 4

Vite

Vitest

Playwright

Job description

About Us

Queue builds robots to fill prescriptions. Our machine is designed to take stock bottles of medication and produce counted, labeled vials, so that pharmacists and technicians can spend their time on patients. Our first product is built to work behind the pharmacy counter and to be operated by pharmacy staff.

About the Role

You own the screen that pharmacy staff will use to run the machine, and then every other screen Queue ships. The operator screen is a large, touch-only panel on the front of the unit, built to be used all day by technicians who are busy with something else. You are answerable for three things: the screen that ships is the screen that was reviewed, a change in the design reaches the machine in days, and the next screen is built to the frontend standard you keep.

This posting covers Senior and Staff levels. Senior level means you own this surface end to end. Staff level means the frontend standard and review practice carry your name, and other engineers build against them. The technical interview is set at the Senior bar.

What You’ll Own

The operator screen — Its scope is the prescription queue, replenishment of drugs and consumables, machine health, administration and exception handling, and sign‑in on an on‑screen keypad.
The prototype and the application — The interface has two forms: the design prototype that is reviewed, and the React application for the machine. You are answerable for the match between them, working with our product designer.
The rules of touch — There is no mouse and no keyboard. Touch targets are never smaller than 48 pixels. Text can be read at a glance in the middle of another task. The screen advances on physical events, such as a drawer closing, and not on extra taps. An action that cannot be undone is never placed where fast fingers land.
What interrupts a technician — A model with three layers: ambient status, a call for attention, and a blocking dialog, with clear rules for which is used when. That includes the alerts for the machine's own faults.
Working in the interface contract — The screen owns no domain state: it renders what the machine sends, so a reload always lands on the truth. Its TypeScript types are generated from the Rust source on the machine, and the build fails when they drift. The engineers who own the on‑machine software own the contract; you work in it with them every day.
The quality bar — You set it and hold every screen to it: unit tests with coverage measured, end‑to‑end tests in a real browser, and lint rules that enforce the design tokens.
The screens that follow — Our cloud operations dashboard comes next, and then the screens of later products. They are built to the standard you set on the operator screen, on smaller displays as well as large ones.

First 90 Days

Day 30: You have merged a change to the screen. You know the queue, replenishment and alert flows as a technician will meet them, you have sat in a design review, and you have gone through the prototype and the application side by side with our product designer.
Day 60: Design changes reach the application through your own commits. The three‑layer interruption model is yours, alerts included. Your end‑to‑end suite runs the flows a technician will run every day.
Day 90: You are answerable for the match between the application and the reviewed design, and for the screen's readiness for security review. You keep the frontend standard: testing, tokens, review, and how screens work within the contract. You have a dated plan for the next screen, the cloud operations dashboard.

What We're Looking For

Must-Have

Ownership — you have owned a product surface that people depended on every day, from the first design conversation to the fault found in the field, and you can show what you changed after it went wrong.
Strict TypeScript — the strictest compiler settings are where you are at home, and you write types that make an invalid state impossible to express.
React 19 with the React Compiler — your components follow the Rules of React because they have to.
State discipline — you have built over state the server owns, delivered by WebSocket, and you understand why a screen that owns no domain state is safer.
Our tools — Tailwind 4, Vite, Vitest and Playwright, with component tests and real‑browser tests as a habit.
Work with design — you have turned a designer's living prototype into production software without losing the intent, and you can disagree with a designer and still ship.

Important

Working knowledge is enough, and we teach the rest.

Touch interfaces on fixed devices — large targets, keypads drawn by the application, protection against a mis‑tap.
Explicit states — you reason in states and transitions, which is how the whole system is built.

We do not ask for Rust. The types are generated for you.

Nice-to-Have

Accessibility in depth, including WCAG 2.1 AA, and responsive web work.
Interfaces for embedded browsers, point‑of‑sale or other constrained devices.
Healthcare or another regulated industry.
A design system or standard that other engineers adopted.

How We Hire

Recruiter Screen (30 min)
Technical Interview (90 min) — a walk through your take‑home exercise of 2 to 3 hours, sent at least 24 hours before, then we build on it together.
Design Interview (60 min) — an interaction and architecture problem that changes as we go.
Leadership Interview (60 min) — how you own your work and work across squads.

Two interviewers score each technical stage independently.

At Staff level, the Design Interview also looks for more than one option weighed, with the trade‑offs written down, and for how other engineers would review the design and take it up. The Leadership Interview also looks for how you have raised a standard across teams: a practice you rolled out that stuck, engineers you helped lead, and disagreement worked through.

What We Offer

Ownership — the operator screen end to end, then every screen that follows
Hard problems: touch‑only interaction, interruptions a busy technician can act on, and a typed contract with the software on the machine
Small team, zero bureaucracy, high trust

Why Join Us Now?

Impact & Growth

Direct Impact: The screen you build is the one pharmacy staff will use to run the machine
Growth: The standard you set on this screen is the one every later screen is built to

Team and Culture

Reports to the Head of Software Engineering with significant autonomy and influence
Who You Work With: You work every day with our product designer and with the engineers who own the on‑machine software
Where We Work: Hybrid, three days a week at our headquarters in the Bay Area; the screen you build is bolted to a machine

Our Values