We're looking for a Product Lead to own the customer-facing product surface of Client Snapshot end-to-end — independently, reporting directly to the CTO.
Key responsibilities:
Leadership & Delivery Accountability
• End-to-end technical delivery ownership — you hold accountability for every workstream in the product surface: application, authentication, billing, CI/CD, security coordination, and launch. Milestone gates do not close without your sign-off on the product-surface evidence package.
• Lead the build phase — own the delivery plan, track progress against milestones, and surface risks and blockers in writing before they become slippage. The CTO is the architecture escalation point, not the day-to-day delivery manager — that is you.
• Coordinate and direct specialists — direct the fractional designer, external legal counsel, and penetration-testing vendor. You translate product and compliance requirements into actionable briefs, integrate their outputs, and hold the delivery line. You do not need to be the expert in each specialism — you need to ensure the right work gets done by the right person at the right time.
• Manage delivery risk proactively — identify slippage before it happens, not after. Escalate scope or capacity risks early and in writing. If a track is at risk, raise it with the CTO and trigger the relief valve (short-term contract resource) rather than absorbing silently.
• Set and maintain engineering standards — define the quality bar for the product surface and hold it throughout the build. Code review, test coverage, architecture decision records, and launch-readiness criteria are not optional — you own them as the senior technical voice on the product surface.
Customer-Facing Application
Own the customer-facing web application from build through beta-hardening to general availability.
• Onboarding wizard — deliver the flow that captures product and facility data, pre-populated from a public-data ingestion layer where available, guided entry where not.
• Core surface — build the bill-of-materials capture, the results dashboard (screening carbon footprint, hotspots, confidence tiers), and the improve-loop prompts that let customers contribute more data to raise their confidence score.
• Report builder — produce the branded, partner-sendable screening report. You render and format the compliance-readiness mapping (e.g., CSRD, BRSR Core, Catena-X) that the AI calculation pipeline provides — you do not author the regulatory mapping logic.
• Work with a designer — a fractional product designer owns onboarding UX and the design system; you integrate their work and take it to production quality. Modern AI scaffolding tools (e.g., v0.dev, Cursor) are used to scaffold components — your job is integration, wiring to the calculation API, and hardening.
• Milestone — a working end-to-end flow (sign up → complete profile → see screening result) on staging by the five-month milestone, then beta-harden through user observation.
Authentication & Multi-Tenancy
Own the security layer that makes the product enterprise-grade from day one — as an integration, not a from-scratch build.
• Identity platform integration — self-serve sign-up and SSO (passwordless / OAuth); no accounts created on users' behalf. A managed identity platform and cloud-native row-level security do the heavy lifting; your work is entitlements, the org/team/seat model, and hardening.
• Tenant isolation — row-level security, AES-256 at rest, TLS 1.3. The acceptance criterion is absolute: one tenant cannot read another tenant's data.
• Build account-management UI, data-handling terms at sign-up, and a compliant account-deletion path.
• Co-own validation — cross-tenant isolation validated with the Cloud Architect at the Private Beta milestone.
Billing & Usage Metering
Own the financial plumbing that bills customers and protects the target gross-margin.
• Billing platform integration — subscription billing (plan tiers, recurring charges, self-serve upgrade/downgrade, dunning, invoicing) — integration, not a billing system built from scratch.
• Metering cap (non-delegable) — wire usage metering to the calculation API. The per-tenant cap is the primary guardrail against inference costs eroding margin; you validate every threshold personally. This is a financial control.
• End-to-end — sign-up → plan → payment → auto-provision, confirmed in a sandbox environment before launch, and a human billing test run at launch.
AI Pipeline Interface
• Surface outputs correctly — the pipeline's confidence-tiered outputs (screening result, lineage, provenance, compliance-readiness map) reach the app intact. No unlabelled numbers reach the customer interface.
• Co-own integrity — with the CTO and AI/ML Engineer: the surface must never present a low-confidence estimate as high-confidence.
• Flag pipeline-to-surface mismatches as blockers before milestone reviews.
CI/CD, Quality & Operations
• CI/CD — GitHub Actions, Terraform/Pulumi infrastructure-as-code, dev/staging/prod separation. Environments live and CI green at the mobilisation milestone.
• Tests — automated suites on all AI-scaffolded code; nothing AI-generated reaches production without human review and coverage.
• Observability & on-call — stand up an observability stack (e.g., Datadog/Sentry) and the initial on-call path. The ongoing support function and on-call rotation transition to the Growth/Support hire at Private Beta — you are not the permanent on-call.
• Reproducibility — maintain short architecture decision records for the product surface, so the work is transferable.
• Launch runbook — author (with AI tooling), execute on staging, test rollback, obtain dry-run sign-off.
Security & Data-Protection Readiness
Own coordination and implementation — the specialist work is externalised.
• Penetration test — coordinate the external test and remediate findings to a no-critical / no-high bar before General Availability.
• Data protection — implement controls to external counsel's specification: privacy-policy surfacing, DPA/SCCs, data-subject-request flows, and region-aware EU-default residency (GDPR + DPDP). Counsel owns the legal drafting; you own the implementation.
Milestone Gates & Launch
• Gate evidence — assemble the product-surface evidence package (auth, billing, app, ops) at each milestone. The Programme Manager combines workstream evidence; the CTO signs.
• GA co-sign (non-delegable) — co-sign the launch with the CTO; both signatures required. Production release is a human responsibility. This and the tenant-isolation sign-off are the human-owned gates.
• Handover — taper toward launch handover after Private Beta; ensure the support runbook and SLA are operational (with Growth/Support) before launch week.
Scope & Escalation
This is a scoped role, not an unbounded one.
• Specialists own the specialist work — design, legal, and penetration testing are owned by the people you work with, not by you.
• A relief valve exists — if the app or billing track slips at a milestone, a short-term contract front-end / QA resource is added rather than expecting you to absorb the overflow. Escalate slippage early and in writing.
• Independence — escalate architecture questions to the CTO; you do not need the CTO in the loop on product-surface implementation. That independence is the structural requirement the role is built around.
AI-First Delivery
• Build AI-first, using modern scaffolding, identity, billing, and CI/CD tooling. The tools do the mechanical work; you own quality, integration, and the human judgement calls.
• This is a compliance-adjacent product — its outputs answer partner carbon-data requests, so hidden defects carry reputational and commercial risk. Hold high standards on all AI-scaffolded code.
Required Qualifications
Technical
• React — production-grade component architecture, API integration, state management; you can take an AI-scaffolded or designer-provided component to production quality.
• Backend integration — REST APIs, multi-tenant data boundaries, billing webhooks, without backend-engineering supervision.
• Auth & multi-tenancy — SSO/OAuth/OIDC, a managed identity platform or equivalent, row-level security. You treat tenant isolation as a security requirement, not a config option.
• Billing — a modern billing platform (e.g., Stripe) or equivalent: subscription lifecycle, metering, webhooks, dunning. Usage-based billing is a strong plus.
• CI/CD & DevOps — GitHub Actions, environment management, infrastructure-as-code (Terraform/Pulumi), observability tooling.
• Security fundamentals — AES-256 at rest, TLS, GDPR/DPDP data-minimisation, account-deletion flows. Not a security specialist, but you know what correct looks like and can coordinate one.
• Document generation — Puppeteer, WeasyPrint, or equivalent branded export pipelines.
AI-Assisted Development
• Fluent with modern AI coding tools (e.g., Cursor, Claude Code, Copilot, v0.dev) as force multipliers, not shortcuts around standards.
• Able to review, validate, and harden AI-generated code to production, with automated tests as the safety net.
• Clear-eyed on where AI tooling is not appropriate: billing-cap logic and tenant-isolation decisions are human-owned, always.
Professional
• Delivery leadership — demonstrable experience leading the technical delivery of a product or significant workstream end to end, not just contributing to one. You have owned a plan, tracked it, and been accountable for the outcome.
• Cross-functional coordination — experience directing external specialists or cross-functional contributors toward a delivery outcome. You can brief a designer, instruct a vendor, or coordinate with legal counsel without the CTO in the loop.
• Risk and escalation discipline — you surface delivery risks early and in writing. You distinguish between what you can resolve independently and what requires founder-level input, and you act on that distinction without prompting.
• End-to-end ownership mindset — you treat gate evidence as a deliverable.
• Senior enough to operate independently — escalate architecture to the CTO; own product-surface decisions.
• Startup pace without startup sloppiness — code that would survive an enterprise security review.
• Precise written communication — status, blockers, and evidence are written artefacts in an async, distributed team.
• Collaborative with specialists — translate direction from designers, legal counsel, and domain experts into implementation without needing them to specify the how.
Preferred Qualifications
• B2B SaaS built and launched end-to-end, including billing and auth.
• Azure multi-tenant architecture familiarity.
• Enterprise compliance exposure: GDPR data-subject rights, DPDP, data residency, DPA/SCC context.
• ESG / carbon accounting / LCA curiosity (domain knowledge not required).
• Catena-X data standards or automotive supply-chain B2B context.
• Observability from scratch: alerting, on-call runbooks, incident response.
• WorkOS or similar modern identity platforms.
• Puppeteer or WeasyPrint for structured document generation.
Experience & Education
• Bachelor's degree in Computer Science, Software Engineering, or a related field.
• 5–7 years' professional software engineering experience, with 2+ years in a senior or lead capacity.
• Demonstrated shipping of production B2B SaaS — owning deployment, monitoring, and go-live, not just features.
• Full-stack breadth: React frontend, REST integration, auth and billing, CI/CD, operational readiness.