• Own agents end to end. • Take a feature from prototype to production: orchestrator and sub-agent design, the tools the agent calls, system prompts, memory, and the response contract the frontend renders from. You write the code that ships. • Own the agent runtime. Design the production runtime to stay fast on the member-facing path and easy to debug when something breaks. • Make the tools trustworthy. Build the tool layer agents depend on, like search grounded in our real catalog, retrieval and reranking, and cart and account actions. • Own safety. Build the layered safety model: input and output guardrails, intent and clarification handling, refusals, and PII boundaries. • Make quality measurable. Push our evaluation work forward: structured checks plus LLM-as-judge, with a review queue for the cases the judges disagree on. • Instrument it. Make agents debuggable in production with per-session and per-turn timelines, tool and guardrail traces, and token and cost visibility. • Turn it into a platform. Take the patterns that work and make them reusable, so the next agent and the next engineer inherit the runtime conventions, the eval scaffolding, and the guardrail defaults instead of starting over. • Make the team better. Set technical direction across the agent codebases and infra, and keep design and code review sharp.

• Design and implement automated, reusable training pipelines to ensure consistent, scalable model delivery across the partner portfolio. • Build ETL pipelines with thoughtful feature engineering to guarantee clean, reliable inputs for pricing models. • Develop and deploy real-time ML pricing solutions to production, owning the full path from model to live environment. • Monitor production systems for latency, drift, and training-serving skew, optimising continuously to maintain model integrity. • Run champion-challenger tests on pricing and product construction levers to surface improvements and respond to shifting market conditions. • Partner with data scientists, engineers, and product stakeholders to translate business needs into well-scoped technical solutions.

• Design, develop, and deploy scalable GenAI applications using LLMs, RAG, AI agents, and workflow orchestration frameworks • Build production-grade AI systems integrating structured and unstructured enterprise data • Architect and optimize end-to-end AI pipelines • Develop AI-powered copilots, assistants, automation workflows, and autonomous agent systems • Design hybrid AI systems combining deterministic workflows with autonomous agent behavior • Build multi-agent orchestration workflows • Implement tracing, telemetry, observability, and monitoring • Develop automated evaluation pipelines and testing frameworks • Improve reliability through retrieval optimization and AI safety mechanisms • Optimize inference cost, latency, throughput, and scalability • Own AI systems from prototype to production • Collaborate with stakeholders, product managers, platform teams, and data engineers • Stay current with advances in LLMs, agentic AI, multimodal systems, and AI infrastructure

Role Description A full-stack platform engineer who can run a multi-app B2B platform end to end — by directing fleets of AI agents and verifying everything in the real environment. You'll own the whole stack: cloud infrastructure, backend, frontend, data, and deep enterprise-ERP integration. The job isn't writing code with AI; it's operating it — decompose, fan out, verify adversarially, ship. One seat doing what's normally three or four. We run a B2B platform spanning roughly ten applications on a shared cloud backbone, with deep integration into customers' enterprise systems (SAP/ERP). This role owns it end to end — from the Terraform and IAM underneath to the React components on top, and the SAP RFC calls in between. The differentiator isn't typing speed. It's the ability to hold an entire platform in your head and conduct AI agents through it without dropping correctness — shipping across many repositories at once while keeping the architecture coherent. AI orchestration here is not a productivity add-on; it's the core multiplier that makes the scope possible. We hire for that fluency, and for the discipline that makes it safe. What You'll Do - Own the platform end to end. Multiple applications plus shared SDKs on a single cloud backbone — React/TypeScript front ends, FastAPI/Python services, the Terraform/IAM/ECS infrastructure underneath, and a shared design system. - Stand up infrastructure and environments from scratch. New services, cloud accounts, tenants, connectors, data syncs, migrations (including cross-region) — provisioned and proven, never just stood up and assumed. - Direct fleets of coding agents. Decompose a cross-repo change into disjoint tasks, fan them out to parallel agents in isolated worktrees, run adversarial multi-reviewer passes, then reconcile the results. - Integrate with enterprise systems at depth. SAP/ERP integration via RFC/BAPI — reading and where necessary authoring ABAP, reverse-engineering business rules, handling sales-order and customer-master flows, currency/unit/sales-area mapping, and idempotent event sync. - Architect multi-tenant data. Postgres row-level security as the tenant-isolation core, JSONB-backed tenant-extensible capability platforms (custom fields, validation, masking), careful migrations, and a graph database where it fits. - Ship at volume without losing coherence. Multiple PRs across multiple repos in a working session, CI green, deployed and verified — while keeping the design clean. - Author the thinking, not just the code. Specs, design docs, discovery-question sets, and runbooks that let work be understood and resumed by others. - Build the tooling that makes AI effective here. Per-codebase navigation maps, documentation indexes, guard hooks, and custom skills — invest in making agents good at this codebase, then reap it on every task after. - Automate yourself forward. Treat every repeated task as a bug to be fixed. When a workflow recurs, capture it as a reusable Claude skill, hook, or slash command so the next run — yours or a teammate's — is one step instead of ten. - Review like an adversary, deploy like a surgeon. Catch the regression the happy path missed, separate “it renders” from “the data is correct,” refute false blockers, and touch shared state only with a reason and a green light. How We Work - Hire for the disposition. The stack is learnable; this isn't. - Prove it in the real environment. “Done” means demonstrated, not asserted. - Never guess. Verify what's knowable in the code; ask about what's a genuine product decision; assume nothing in between. - Diagnose before you touch. “Look into it” means read-only until told to fix — especially on anything live. - Copy what works. If working examples already solve a problem, read the proven pattern and adapt it. - Enhance in place, never fork. Generalize the existing path — add an optional parameter where today is the degenerate case. - Risk isn't size. Bigger isn't worse; riskier is. - Build to scale — or name the debt. Ship the agreed slice now, but flag anything that won't scale as explicit, revisit-able debt. - Own the correction. Verify findings adversarially — a second pass whose job is to refute the first. - Words are a feature. Terminology has precise internal meaning. - Leave a trail. Every session ends with a handoff so the next one — human or agent — starts informed. Environment - Frontend — React, TypeScript, Vite, TanStack Query, vitest, a token-based design system, Playwright for verification. - Backend — Python, FastAPI (async), SQLAlchemy, Alembic, Celery, Pydantic; an SNS®SQS event bus with idempotent dedup. - Data — PostgreSQL with row-level security, schema-per-app, JSONB + GIN/GIST, Neo4j (Cypher), pgvector. - Platform / Infra — AWS (ECS Fargate, Aurora, RDS Proxy, Route53, ACM, WAF, CloudFront, IAM/OIDC), Terraform, dual-account, per-branch Docker stacks, gitflow. - Enterprise integration — SAP ECC via RFC/BAPI, ABAP, pyrfc, customer/order master data, additional ERP connectors, M2M auth. - Identity & AI — Auth0 (Organizations, M2M, custom claims), JWT entitlement gating; Claude Code agents, worktrees, skills, hooks, MCP. Must have - Fluent AI orchestration. You already run agents in parallel, isolate their work in worktrees, and verify their output adversarially. - Genuine full-stack + infra range. Comfortable going from a React component to a Postgres RLS policy to a Terraform module in the same day. - Systems debugging instinct. You chase root cause across service boundaries. - The evidence reflex. You distrust green badges, demand real fixtures, and prove things with a working screenshot, a read-back record, or a live payload. - Self-correction. You can describe a time you reversed your own confident conclusion because the evidence said so. - An automation reflex. You instinctively turn recurring work into reusable Claude skills, hooks, and commands. - Operating discipline. Read-only until authorized, copy proven patterns, enhance-in-place, precise language, clean handoffs. - Thick skin & plain speech. You take blunt, fast feedback well and explain your reasoning simply. Nice to have - Enterprise ERP / SAP depth. RFC/BAPI, ABAP, customer & order master data. - Tooling-builder streak. You've built the scaffolding that makes other agents and engineers effective. - Architectural taste under constraint. You reach for the boundary that keeps future cost flat. - Multi-tenant / B2B context. Tenancy isolation, per-tenant configuration, and the failure modes they bring. - Compliance fluency. GDPR / SOC 2 / ISO 27001 — comfortable with ROPA, control mappings, and runbooks. - Design-system literacy. Tokens over hardcoded values; able to run a UX and a UI pass on your own work.