Staff Engineer (AI-Native Delivery)

ABOUT VAILENT

• Vailent is the AI infrastructure for the materials industry — chemicals, polymers, elastomers, rubber. The companies
• in this space run on a mess of CRMs, ERPs, point tools, and flat files. We're replacing all of that with one system that
• turns every interaction, transaction, and physical asset into usable commercial data.
• Materials are the foundation of the physical economy: they're in everything. Every product humans build, ship, eat,
• wear, or drive starts here. But the industry is still massively under-instrumented, running on fragmented tools and the
• institutional knowledge of people who've been doing it for decades. At Vailent, we're building the infrastructure that
• will transform this industry for the next century, capturing multi-modal industry context across both software and
• hardware.

About the Role

• 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.
• These principles are non-negotiable, because at this volume they're what keep the work correct. If you don't already
• work this way, the throughput becomes a liability instead of an asset.
• 01 — Prove it in the real environment. “Done” means demonstrated, not asserted. A green badge over $0 /
• insufficient data is a failure. subrc=0 means nothing until the record reads back. The data wins, never the badge.
• 02 — Never guess. Verify what's knowable in the code; ask about what's a genuine product decision; assume
• nothing in between. Confident fiction is worse than an honest “I don't know yet.”
• 03 — Diagnose before you touch. “Look into it” means read-only until told to fix — especially on anything live. Root
• cause and a proposed fix come first; the change waits for an explicit go. Production is sacred.
• 04 — Copy what works. If working examples already solve a problem, read the proven pattern and adapt it. Don't
• invent a fresh approach and burn an afternoon proving it wrong.
• 05 — Enhance in place, never fork. Generalize the existing path — add an optional parameter where today is the
• degenerate case — rather than shipping a parallel reimplementation. Design the capability; a single customer is the
• validating example, not the spec.
• 06 — Risk isn't size. Bigger isn't worse; riskier is. Risk is load-bearing code modified × silent-failure potential × blast
• radius. A large additive change can be safer than a one-line edit to a hot path.
• 07 — Build to scale — or name the debt. Ship the agreed slice now, but flag anything that won't scale as explicit,
• revisit-able debt. Hardcoded shortcuts are fine only when chosen out loud, never smuggled in.
• 08 — Own the correction. Verify findings adversarially — a second pass whose job is to refute the first. When the
• evidence turns, reverse yourself out loud. The best catches are corrections of your own confident conclusions.
• 09 — Words are a feature. Terminology has precise internal meaning. Inventing loose language for things that
• already have names is a real defect — caught and corrected on the spot, not waved through.
• 10 — Leave a trail. Every session ends with a handoff so the next one — human or agent — starts informed. Specs,
• runbooks, tracked tickets, and durable notes are part of the deliverable, not overhead.

The 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 — not “I’ve used Copilot.”
• 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 — auth, pagination, dependency
• conflicts, integration mismatches — and don't stop at the first plausible story.
• 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 —
• raising your own efficiency floor instead of re-doing toil.
• 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 — or the nerve to
• reverse-engineer a customer's system to that depth.
• Tooling-builder streak. You've built the scaffolding that makes other agents and engineers effective: nav maps,
• indexes, skills, guard hooks, templates.
• Architectural taste under constraint. You reach for the boundary that keeps future cost flat, and can name why a
• rewrite or a scatter is the wrong move.
• 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.

#vailent