Senior Full Stack Engineer

Why we built it

The loop

• Client-facing composure - scope, demo, absorb critique, iterate live; you'll lead engagements early
• LLM/agent product experience - prompting, evals, tool use / MCP

Forward-Deployed track Senior Full Stack Engineer

Deep Python + JavaScript/TypeScript

You’ll own the biggest features end-to-end as Engineer DRI from day one – frozen contracts, parallel builds with Claude Code, flag-gated launches with the metric wired first – hold the technical bar at the review gates, mentor a junior engineer, and lead forward-deployed engagements executing external projects on our pipeline.

Full-time 1 opening 5+ years

• shipped scope over tenure Python + JS/TS Backend
• Web
• App Client-facing

What you’ll do

How we build

No sprints. No staging. No hand-offs.

Every feature runs a 10-stage pipeline where Claude does the heavy lifting and a human DRI – one directly responsible engineer – drives every step.

01 Contract-first

A frozen backendfrontend contract + simulator before any code – so both sides build in parallel against the same reality.

02 AI-native execution

Claude Code writes most of the code. You direct it, review it, and verify it by running the app – not by trusting the diff.

03 One Design System

Every screen is composed from a living component library; anything new is contributed back. Build it in the system, not the feature.

04 Flags, not staging

Verify locally, merge dark behind a feature flag in production, dogfood there, flip it on. Rollback is one click.

05 Artifacts, not meetings

Each step outputs a structured doc the next step’s Claude reads directly. Three synchronous touchpoints per feature – that’s it.

06 Done = demonstrated

Screenshots, green gates, a flag, and a one-click rollback – never just “code written.”

What you do

Own it end-to-end. Raise the bar. Lead forward.

The contract is the keystone of the whole pipeline – and designing it is your craft. Two build tracks work against what you freeze; ambiguity in your writing becomes rework in two codebases.

Own features

• day one
• Design the frozen contract + simulator from the founder's PRD; lock decisions
• Build backend ∥ frontend in parallel with Claude Code across Python/Django, TypeScript web, and React Native
• Integrate against a local backend, verify every flow with evidence
• Launch behind a flag – success metric wired to a live dashboard before the flip

Hold the bar

• spine
• mentorship
• Be the human reviewer at the gates: architecture, scalability, contract adherence, design-system consistency
• Steward the persistent spine – contract registry, component library, conventions
• Mentor the junior engineer: review their contracts, hold their gates, raise their slope
• Evolve the pipeline itself – the playbook is a living repo you can PR

Lead forward

• First into the room: install the portable pipeline on the client's repos
• Scope with the client, design the contract, build with Claude, demo working software
• Absorb the punch list, come back with it fixed, launch behind their flag
• Feed what you learn back into the loop

What we look for

• 5+ years shipping production full-stack software – we index on the scope of what you've shipped, not tenure
• Python depth – Django/DRF (or comparable) in production: data modelling, migrations, auth, background jobs, tests, Postgres, performance under real load
• JavaScript/TypeScript depth - React on web plus React Native, or a shipped comparable mobile app
• Architecture judgment – API/contract design, failure modes, scalability trade-offs; you can review someone else's design and make it better in one pass
• AI-native working style – an AI coding tool is already your daily driver; you direct, review, and correct its output fast, and verify by running the app
• Written clarity – your contracts are frozen documents two build tracks work against
• Ownership and review leadership – you drive features to live without being chased, and make the people around you better
• Client-facing composure – scope, demo, absorb critique, iterate live; you'll lead engagements early

Nice-to-haves

• Feature-flag-gated rollouts; observability and product analytics (Mixpanel, Sentry)
• LLM/agent product experience – prompting, evals, tool use / MCP
• DevOps – GCP, Docker, CI, systemd; enough to self-serve a deployment
• Mobile releases (TestFlight / Play Console), push-notification plumbing
• Prior mentoring or tech-lead experience

What you get

Run the model. Shape the model.

01 The operating model – An AI-native pipeline most companies are still theorizing about – you run it daily and help evolve it.

02 End-to-end ownership – Your name on the feature from frozen contract to live metric dashboard.

03 The lead FDE seat – Client-facing, high-trust, high-leverage – entire external engagements run your way.

04 Claude, on us – Claude as your pair on everything, on the company's dime.

05 A team worth raising – A junior engineer whose slope you own, founders as your product pair.

06 Leverage, not meetings – Three synchronous touchpoints per feature; the rest is you, Claude, and the pipeline.

Hiring process

Built like the job.

01

Intro call

30 min

• bring the biggest thing you've shipped

02

Design + build

Paid

• timeboxed
• AI required

03

Architecture deep-dive

90 min

• defend your contract

04

Offer

Fast

Our contracts need no follow-up call? Let's talk.