Staff Software Engineer
Summary
Own and improve a live patient-facing clinical product: a React/TypeScript widget, a clinician portal, and a Python service layer, while partnering with AI engineers to integrate AI Intake features.
Staff Software Engineer
Location: United States
Department: Engineering
Location Type: REMOTE
Employment Type: FULL_TIME
About the Role
There is a live, patient-facing clinical product running today: an embeddable widget patients talk to, a portal clinicians read, and a Python service layer stitching the two together. Much of it was built quickly by a small number of people, and realistically, parts of it need a durable owner before they need new features. That is the job. You will own the application surfaces of this product end to end, advise on and make the full-stack architectural decisions that shape it, and go deep enough into the system to independently find what needs shoring up and where it should go next.
The widget and portal are TypeScript and React; most of what sits behind them is Python. The team's flagship product, AI Intake, is an agent-based system, but a great deal of critical application work supports it: encounter plumbing, data flow, integration against someone else's platform, and every surface a new customer touches. There is generally one of those in flight and another right behind it. Alongside the customer-facing application sits a growing set of internal tools your own team and clinicians depend on, and you will own both, working shoulder to shoulder with the AI engineers so the application and the models move together rather than past each other. You will also mentor engineers earlier in their careers, starting with the entry-level engineer who sits beneath this seat.
This is a small, high-trust team that does much of its thinking in writing and backs every change with test coverage, because a system with this many moving parts depends on it. We lean hard on AI coding tools and keep reworking how we build around them, and you would have a real voice in what we try next. Expect to ramp fast. In your first month, you will have gotten deep enough into the widget, the portal, and the service layer to be the second name on any of them, shipped meaningful changes to each, and formed a working relationship with the data scientists whose work yours carries. By three months, you own whichever integration or platform initiative the team is carrying, and you are the reviewer we route application-side design decisions through. By six months, you have delivered something end to end that people outside the team depend on, and you have brought an engineer earlier in their career far enough along that they own surfaces of their own.
What You'll Do
As a Staff Application Engineer on the Applied AI team, you will be the durable owner of every application surface the product touches, from the code patients interact with to the tools clinicians rely on. Your primary responsibilities will include:
- Owning the application surfaces of a live, patient-facing clinical product end to end: the embeddable widget patients talk to, the clinician portal, and the Python service layer between them.
- Owning and advising on full-stack architectural decisions, going deep enough into the system to independently identify key areas for improvement and future directions of development.
- Building and operating the application work that supports AI Intake: encounter plumbing, data flow, integration against partner platforms, and every surface a new customer touches, with one such initiative typically in flight and another behind it.
- Owning the growing set of internal tools your team and clinicians depend on, right alongside the customer-facing application.
- Partnering closely with the AI/ML engineers who own the conversation pipeline, prompts, evaluation, and clinical-safety layer, keeping the application and model work well coordinated and moving together.
- Shipping and versioning shared surfaces that other teams consume as a dependency, and protecting those consumers from expensive breaking changes.
- Keeping dependencies current and operating what you build, so maintenance stays a habit rather than becoming a quarterly crisis.
- Mentoring engineers earlier in their careers, starting with the entry-level engineer on the team, and making other people's work easier through clear written thinking and reliable review.
Why You Might Be a Good Fit
- You are a builder who stays: You are drawn to systems you can own and live with, not just ship and hand off, and you take real satisfaction in making something quickly-built durable.
- You care about the patient on the other end: This is a live clinical product with real safety stakes, and you want your work to matter to the people using it.
- You are a strong full-stack engineer with range: You are fluent from a React widget down through a Python service and its data layer, and you make sound architectural calls across all of it.
- You are a genuine partner to data scientists: You know enough about LLM application development to speak the language of prompts, evaluation, and latency and cost tradeoffs, without needing to own the models yourself.
- You think in dependencies and blast radius: You understand why breaking changes are expensive and you design shared surfaces with the teams that consume them in mind.
- You make other people better: You write clearly, you mentor generously, and you treat "making other people's work easier" as core to the role, not a side effect.
This Might Not Be The Right Fit If...
- You want to design the models and the prompts. This role partners with the people who do that; it does not do it, and we would rather it did not.
- You prefer greenfield builds you hand off, over inheriting and shoring up systems other people started quickly.
- You would rather specialize narrowly in the frontend or the backend than own the full stack and the architecture across it.
- You see keeping dependencies current, operating what you ship, and mentoring less-experienced engineers as overhead rather than part of the job.
- You are looking for a large, heavily-structured team; this is a small, high-trust group where you will own broad surface area with real autonomy.
Your Qualifications
- Substantial experience shipping and operating production full-stack web software, including architecture you owned and then had to live with. Successful candidates will have 8+ years of professional experience, including at least 1 year at a staff level.
- Depth in TypeScript and React, with fluency in a modern server-rendered framework. We use Next.js.
- Strong Python and experience with an async web framework, plus the data layer around it: relational schema design, migrations, and caching.
- Experience building something other teams consumed as a versioned dependency, whether a widget, an SDK, or a component library. You know why breaking changes are expensive.
- Comfort operating what you build, and the discipline to keep dependencies current so they never become a quarterly crisis.
- Enough fluency with LLM application development to be a real partner to data scientists: prompts, evaluation, and the latency and cost tradeoffs. You don't need to be the person designing the models or the prompts, and we'd rather you weren't.
- Clear written communication and a genuine appetite for mentoring. Much of this role is making other people's work easier.
Bonus Points
- Healthcare experience, particularly anything involving PHI, HIPAA, clinical workflows, or a patient-facing surface with real safety stakes.
- Agent or workflow orchestration frameworks such as LangGraph.
- Accessibility and internationalization designed in from the start.
- AWS, especially Bedrock, and infrastructure-as-code.
- Eval tooling such as Braintrust or LangSmith, or something equivalent you built yourself.
- Having been the first or second engineer on a greenfield product, and having later had to live in it.
