Software Engineer

Flume Health; New York (NY); On-site; USD 180,000 - 230,000; Full time

Benefits offered by this job

Equity

Health/dental/vision coverage

401(k)

Great PTO policy

Job summary

Flume Health builds an AI platform for healthcare data. It orchestrates data exchange between trading partners and enables exploration of data estates through conversation, with HIPAA-compliant safeguards.

We are an AI-native engineering team where agentic tooling drives daily work. You’ll own backend systems, data pipelines, and integrations end-to-end, balancing performance, security, and reliability in a healthcare context.

Qualifications

• 7–10 years backend development experience in Go or Python.

Responsibilities

• Turn product vision into functioning software; own end-to-end execution.

Skills

Backend development

Cloud architecture

Agentic AI development tools

Code review

Verification mindset

System design

Product judgment

SQL (PostgreSQL)

Containerization

Communication

Low ego

Ambiguity tolerance

Tools

Kubernetes

Docker

Google Cloud (GKE)

Azure

AWS

MCP servers

Claude Code

Codex

Gemini

Anthropic API

Job description

Flume Health builds an AI platform for healthcare data. It orchestrates data exchange between trading partners, and it lets users investigate and analyze entire data estates through conversation. Nobody thinks about this data until it breaks. Then a claim doesn't pay, coverage doesn't work, and someone's care is on the line.

We are past the early-stage gamble: we have paying customers, real claims data at scale, and a product that measurably changes what healthcare costs. This is the sweet spot for an engineer who wants to build something that matters without taking founder-level risk.

We are an AI-native engineering team. Agentic coding tools are how we build software here — not an experiment on the side, but the daily workflow for feature development, integration building, production debugging, code review, and documentation. What that changes is where an engineer's leverage comes from: less from typing code, more from specifying problems precisely, making sound design decisions, reviewing machine-written code critically, and verifying that what shipped actually works. Engineers on our team help build the systems and workflows that do the coding, so they can focus on being the engineer. You'll own systems, workflows, and the internal AI tooling itself end-to-end; those systems will own backend services, data integrations, and infrastructure touchpoints, all in a domain where correctness and compliance are non-negotiable.

AI-native engineering is being figured out across the industry right now. You won't inherit a settled playbook here; you'll help write it, building the tooling and practices this way of working runs on.

How We Build

Flume believes in using the best models and tooling available.

Every engineer works with Claude Code, Codex (or other TUIs) extended by our in-house plugins: MCP servers that give agent sessions governed access to the Flume API, Jira, and internal knowledge bases.

Production investigation, PR management, and multi-model adversarial code review run through agentic workflows we built and continue to improve.

Velocity is high, and accountability stays human. You are responsible for the correctness, security, and HIPAA compliance of everything you ship, no matter who or what wrote the first draft.

We run an on-call rotation shared by the whole team. Serious incidents are rare, and we work to keep it that way.

What You'll Do

• Product engineering, first and foremost: turn product vision into product. Vision and direction come from leadership; you are a trusted partner in executing them — you understand the vision well enough to fill in the lines on your own, and you own everything between it and the running system.
• Own execution end-to-end: from ambiguous requirement to designed, implemented, reviewed, verified, and monitored solution.
• Build and operate workflows that themselves build and operate backend services for transaction processing, data pipelines, and third-party integrations, and design the workflows and APIs that connect them.
• Direct AI agents through implementation while owning the parts that matter most: system design, code review, edge cases, and verification.
• Strengthen the pipeline that all code (human- and AI-written) flows through: tests, CI, observability, and deployment on GCP/Kubernetes.
• Extend and build our internal AI software workflows using agent skills, MCP servers, knowledge bases, evals, and more, so the whole team gets faster and safer.
• Work directly with product, delivery, and customers. Explain a technical decision to a non-engineer and take pushback well.
• Uphold security and compliance (HIPAA) when handling PHI, including in workflows where AI agents have governed access to sensitive data.

What You'll Need

• 7–10 years of backend development experience building scalable, distributed systems in Go or Python.
• Deep cloud architecture experience: you have designed systems on GCP or AWS, not just deployed to them, and you can defend the tradeoffs. This one is non-negotiable.
• Demonstrated fluency with agentic AI development tools (Claude Code, Cursor, Codex, or similar). You can show us real work you've built this way and explain your workflow: how you specify tasks, manage context, and catch what the agent gets wrong. This is a core requirement, and our interviews are built around it.
• Strong code-review instincts. When much of the code is machine-generated, the engineer's judgment about what's correct, idiomatic, and safe is the quality bar.
• A verification mindset: you treat tests, observability, and end-to-end checks as the contract that makes fast shipping safe, not as overhead.
• Solid command of system design: scalability, API design, third-party integrations, and the tradeoffs between them.
• Product judgment. You ask what a feature is for before you ask how to build it, and you notice when the spec solves the wrong problem.
• Strong SQL and relational database fundamentals (PostgreSQL).
• Hands-on experience with containerized environments (Kubernetes, Docker).
• Strong communication, written and spoken. Precise written specifications are how work gets delegated to teammates and to agents, and you can hold a room of non-engineers — including executives — and leave everyone satisfied.
• Low ego. You challenge constructively, and you adopt the better idea even when it is not yours.
• Comfort with ambiguity and rapidly evolving tooling. Our workflow six months from now will not look like our workflow today. If that sounds exciting rather than exhausting, you'll like it here.

Nice to Have

• Experience building AI tooling: MCP servers, agent skills, evals, or LLM-powered product features.
• Exposure to healthcare data and standards (X12 834/837 EDI, claims, eligibility, enrollment, payments).
• Experience with data pipelines or distributed data processing (Spark, Dataproc, Trino, Iceberg).
• Python data tooling (pandas, Polars) for analysis and validation work.
• TypeScript or Rust: parts of our platform (frontend, graph database engine) use both.

Where We Work

Flume is a distributed team. For this role we have a preference for candidates in the New York City area. We come together as a full company for onsites a couple of times a year, and you'll need to be able to travel to them. In an age of AI, meeting face to face also serves a simple purpose: we know exactly who we're working with, and you know us.

How We Interview

You’ll use AI tools during our technical interviews, because that’s how the job actually works. We’re not testing whether you can code without assistance; we’re evaluating how you leverage best in class tools to build.

The loop also includes a communication exercise: explain a technical decision to a non-engineer and take pushback.

We verify that every candidate is a real person, and we will meet face to face when needed.

The process is multi-step and includes a technical interview. We aim to complete the whole process within three weeks, start to finish.

Technologies We Use

• Languages: Go, Python, SQL, TypeScript, Rust
• AI tooling: Claude Code, Codex, Gemini, and other LLMs, with custom plugins and MCP servers, Anthropic API, LLM observability
• Cloud: Google Cloud (GKE), Kubernetes, Docker; select services on Azure and AWS

• Equity, health/dental/vision coverage, a 401(k), and a great PTO policy.