Lead Product Engineer

Quintegro, LLC; United States; Remote; USD 180,000 - 260,000; Full time

Benefits offered by this job

Fully remote

Flexible hours

Job summary

Quintegro is seeking a Lead Product Engineer to drive AI-first delivery for Fortune 500 clients. You will own the running system in production, turning intent into executable specs, and designing the AI-driven delivery pipeline with a cross-functional pod.

You’ll balance rapid prototyping with strict acceptance criteria and risk-aware deployment. You will work fully remotely, reporting to the CEO, with US Eastern or European hours to cover US client calls.

Qualifications

• 10+ years engineering experience
• 4+ years owning end-to-end architecture in production
• Fluent in a primary stack: TypeScript/Node, Next.js and React, and Python/FastAPI
• Experience with AI service layers and agents across eng/QA/lead roles
• Ability to run requirements sessions with Fortune 500 principal engineers and business owners
• Strong judgment on where AI helps vs. where it creates debt
• Security-aware with demonstrated incident learnings
• A track record of shipping production features and driving business impact

Responsibilities

• Own the running product in production, not just designs or docs
• Turn client intent into executable specs and system design
• Define the first vertical slice to retire major unknowns
• Configure and manage the AI delivery pipeline across engagement roles
• Decide scope and sequencing based on business risk and impact
• Establish threat models, data classification, and least-privilege infra
• Ensure test strategy for unit, integration, and end-to-end validation
• Enable reuse through blueprints and reference slices across teams
• Lead delivery harness improvements and production readiness

Skills

End-to-end architecture

Production code shipping

TypeScript/Node

Next.js/React

Python/FastAPI

AI service layer

Agent-driven development

Client engagement (Fortune 500)

Quality review of AI outputs

Tools

LangGraph

LangChain

Vector stores

Claude Code

Cursor

Codex

Job description

Quintegro builds enterprise-grade systems for US-based Fortune 500 clients. We deliver them AI-first: specifications are executable contracts, coding agents do the volume, and our engineers own the judgment, the verification, and the parts where being wrong is expensive.

We hire technical leaders — people whose authority comes from decisions that held up, not from a position on an org chart. This role designs how AI-first delivery works for a given product: the system, the spec, and the pipeline that turns one into the other. And it is fast enough by hand to prove that design before a team builds on it.

You work inside a pod: an Intent Manager who owns what the client wants, Product Engineers who build, and you — the Lead Product Engineer, who builds alongside them and is the one who turns intent into a system and pushes back at the requirement level, not just the design level. QA and design are shared across pods. That structure is why the week splits the way it does.

Fully remote, reporting to the CEO. US Eastern hours, or European hours with dependable coverage for US client calls.

What You Are Accountable For

The product working. Not the design of it, not the documents about it — the running system: in production, doing the job the client bought it for, holding up under real load and adversarial attention.

The route there is a specification our agents and engineers build from, and your own hands on the riskiest slice. Those are means. You are measured on the product.

What counts as done:

a product in production that the client is using. Nothing upstream of it counts on its own — not an approved design, not a spec, not a green build, and never a deck.

How the Week Actually Splits

• 40% — Hands in code. Prototypes, vertical slices, the hard parts, review.
• 30% — Specs, technical design, ADRs, working the design with the team.
• 30% — Client discovery, acceptance, feeding signal back into delivery.

We publish this split because it is the part candidates most often assume is decorative. It is not. If the 40% looks like a number you would negotiate down in month two, this is the wrong role for you.

What You Will Own

• Discovery → executable spec. A vague brief becomes a spec an agent executes unattended: goals, non-goals, boundaries, API and data contracts, NFRs, numbered acceptance criteria.
• The first vertical slice, in days. A walking skeleton that retires the biggest technical or product unknown, built while the shape of the system is still open.
• Scope and sequencing as product decisions. Features argued out of scope, slices ordered by the business risk they retire, non-goals written with a rationale. You are the last check that we are building the right thing — not just building it right.
• The AI delivery pipeline for your product. Our SDLC runs as a chain of agents — planner → tech-designer → engineer → qa-lead → tech-lead — over repo-level rules and skills. You configure it per engagement: decomposition, context, and how far an agent's output travels toward production.
• Decisions and their consequences. Trade-offs argued in writing, blast radius known before the change, real migration and deprecation paths, technical debt carried with a price tag.
• The security posture of the system. A threat model per engagement, secrets and credential lifecycle, data classification, least-privilege infrastructure. Agents produce the volume — you decide what they may touch, and what gate their output clears before it moves toward production.
• Verification. Test strategy across unit, integration, and E2E; for GenAI features, an eval set and a quality regression that gates the release.
• Leverage. Blueprints and reference slices other teams reuse, review that raises the engineers around you, and a second engagement that runs faster than the first.
• The delivery system itself. Every engagement is also a test of our harness. Configurations that worked become defaults; failure patterns become rules and gates, not tribal knowledge. Contributions are artifacts — a merged rule, a new check, a retired manual step — made inside delivery, not in protected R&D time.

What we need you to already have

• 10+ years engineering, 4+ owning end-to-end architecture. You have been accountable for a whole system in production, not for a slide about one.
• Production code shipped in the last six months. Bring proof that you ship: a repo, a commit history, a merged PR. If it is all under NDA, walk us through one change in enough detail that we can tell you wrote it.
• Fluent in a primary stack, literate in the rest. Our primary stacks are TypeScript / Node, Next.js and React, and Python / FastAPI — fluent in one, ideally both. Literacy with Go and PHP / Laravel is enough. The AI-service layer (LangGraph, LangChain, vector stores) is part of the job, not a specialty. You stand up your own environment and fix your own CI.
• A real, daily workflow with coding agents. Claude Code, Cursor, Codex — not "I've tried them." You have a system: repo rules, task decomposition, context management, how you review an agent's output, when you throw it away. You can describe a time an agent produced something plausible and wrong, and how you caught it.
• Spec-driven development in practice. You know the difference between describing a feature and writing a contract. Acceptance criteria have IDs, non-goals are explicit, and the spec survives contact with a requirement change without being rewritten from scratch.
• Judgment about where AI helps and where it accrues debt. Held as an opinion earned from your own failures, not from a conference talk.
• Security judgment earned the hard way. You have run an incident or caught a near-miss, and you talk about it in blast radius, credential rotation, and notification obligations — not certifications.
• Evidence of product judgment. A feature you argued out of scope, a simpler thing you shipped instead, or a business number that moved after your system launched — and you can name it.
• A workflow that changed last quarter. Model capability moves; your practice moves with it. Name something you adopted recently — and something you evaluated and rejected, with reasons. Re-deciding how far an agent's output travels unreviewed is part of this job.
• Direct client work in English. C1 or better. You run a requirements session with a Fortune 500 principal engineer and a business owner in the same call, disagree with both when needed, and leave with a written decision.

Nice to Have

• Forward-deployed, consulting, or on-site delivery experience with large enterprises
• Legacy modernization — strangler patterns, dual-write migrations, cutovers with rollback
• Event-driven and integration-heavy systems; DDD where it earns its keep
• A public trail: open source, writing, talks