Senior Full Stack Engineer

CtrLoop

Forward Township (PA)

On-site

USD 120,000 - 180,000

Full time

14 days+

Application generator

An application made for this job — a tailored resume and cover letter that speak straight to the posting.

Get past ATS filters

Job summary

CtrLoop is seeking a Senior Full Stack Engineer to own end-to-end features in an AI-native pipeline. You will design frozen contracts, build in parallel with Claude, and drive forward-deployed engagements on external projects.

Expect leadership, mentorship, and architectural review as core responsibilities. Required 5+ years shipping production full-stack software with Python/Django and React/React Native, plus strong API design and data modelling skills.

Qualifications

5+ years shipping production full-stack software.
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

Responsibilities

Own features end-to-end from frozen contract to live metric delivery.
Design the frozen contract + simulator; build backend ∥ frontend in parallel with Claude across Python/Django, TypeScript web, and React Native.
Lead forward-deployed engagements executing external projects on our pipeline.
Review gates for architecture, scalability, and design-system consistency.
Mentor junior engineers and evolve the pipeline playbook.

Skills

Python

Django/DRF

JavaScript/TypeScript

React (web)

React Native

Architecture judgment

AI-native working style

Ownership and leadership

Client-facing

Tools

Docker

GCP

systemd

PostgreSQL

Job description

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.

Intro call

30 min