Forward Deployed Engineer

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 customer-facing engineer who lives at the intersection of deployment, integration, and product. You’ll embed

directly with our customers — chemicals distributors, polymer producers, elastomer traders — understand their real

operational environment, and build the production solutions that make Vailent work inside it. The job isn’t demoing

software; it’s owning the outcome.

The gravel road, not the superhighway.

FDEs build the rough path that proves what’s possible in a specific customer’s environment. Core product engineers

then generalize it. That means you need to move fast, ship production-quality code, and bring back what you learn —

because the patterns you surface in the field become the features that ship to everyone.

Our customers run complex enterprise stacks: SAP/ERP systems, legacy CRMs, bespoke flat-file workflows built

over decades. Integrating Vailent into that environment requires engineering depth and customer trust in equal

measure. You’ll be the person who earns both.

What You’ll Do

• Embed with customers and own the outcome. Sit alongside customer teams — in their Slack, their systems, their reality — to understand their workflows, constraints, and data before touching a line of code. Translate what you hear into a concrete technical plan, then execute it.
• Run technical discovery before every engagement. Map the customer’s existing stack: SAP configuration, CRM schema, data flows, integration points, and business rules. Ask the questions the customer didn’t know mattered. Define scope before scope defines you.
• Build and deploy production solutions, not prototypes. Stand up integrations, data pipelines, custom workflows, and tenant configurations that run in live environments. “It works on my machine” is not a deliverable.
• Own the full integration lifecycle. From first API call to stable sync: SAP/ERP data flows, CRM connections, customer-master and order-master mapping, idempotent event handling, and the edge cases that only appear in production with real data.
• Be the primary technical relationship. Serve as the customer’s technical point of contact across the engagement — from onboarding through steady state. Run technical calls, explain architectural decisions to non-technical stakeholders, and surface risks before they become incidents.
• Support sales in technically complex deals. Join pre-sales conversations to assess feasibility, design proof-of-concept scopes, and give prospective customers the confidence that Vailent can work in their environment. The close and the deployment aren’t separate jobs.
• Direct AI agents through customer-specific work. Decompose integration and configuration tasks, fan them out to parallel agents, verify outputs adversarially, and reconcile results — without letting customer data or live-system risk become casualty of throughput.
• Close the feedback loop with product and engineering. The patterns, failure modes, and workarounds you discover in the field are the most valuable signal the core team has. Document them, escalate them, and advocate for the generalized fix — not the one-off patch.
• Capture and reuse what works. Build deployment runbooks, integration templates, customer onboarding checklists, and Claude skills that make the next engagement faster. Treat every repeated setup task as a bug to be fixed once and inherited forever.
• Author the thinking, not just the code. Specs, discovery-question sets, integration design docs, and handoff notes that let the next engineer — or agent — pick up where you left off without a two-hour call.

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 engagement ends with a handoff so the next person — 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, a token-based design system.

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.

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.

Customer environment — Multi-tenant: five active tenants

Must have

• Customer-facing engineering ownership. You’ve shipped production solutions inside a customer’s environment— not demos, not PoCs that died in staging. You know what it means to make something work with their data, their constraints, and their team watching.
• Strong full-stack range. Comfortable moving from a React component to a Postgres integration to a Terraform environment variable in the same day. You don’t need to be the deepest specialist in every layer, but you can’t be blocked by any of them.
• Enterprise integration instinct. You’ve connected systems that weren’t designed to talk to each other. APIs, webhooks, file-based syncs, ERP exports — you know the failure modes and how to build around them.
• Fluent AI orchestration. You already run agents in parallel, isolate their work, and verify outputs adversarially. Not “I’ve used Copilot.” You know how to make AI leverage safe in a live-customer context.
• Clear, credible communication. You can explain a technical constraint to a commercial director, write a concise integration spec for an engineer, and run a customer call without a script. Plain language isn’t a soft skill — it’s how trust is built.
• Systems debugging instinct. You chase root cause across service boundaries and don’t stop at the first plausible story. Auth issues, data-mapping mismatches, pagination edge cases in ERP responses — you find the real problem.
• The evidence reflex. You distrust green badges and prove things with a working read-back, a live payload, or a screenshot of actual data — especially in customer environments.
• Thick skin & plain speech. You take blunt, fast feedback well and give it the same way. Customers and internal stakeholders both.

Nice to have

• Materials industry or adjacent vertical context. Chemicals, polymers, specialty materials, commodity trading, or distribution — familiarity with how these businesses buy, sell, and move product is a genuine accelerant.
• SAP / ERP depth. RFC/BAPI, ABAP, customer and order master data flows — or the confidence to reverse-engineer a customer’s SAP configuration to that level under time pressure.
• Pre-sales or solutions engineering experience. You’ve sat in discovery calls and helped assess feasibility. You understand the gap between what a prospect wants and what’s actually buildable in their environment.
• Fluency in compliance contexts. SOC 2, GDPR, ROPA — you’ve navigated vendor security questionnaires and data access approvals as part of a customer engagement.
• Tooling-builder streak. You’ve built deployment runbooks, onboarding checklists, or integration templates that made future engagements faster. You invest once and inherit the benefit forever.
• Multi-tenant / B2B experience. You understand per-tenant configuration, tenancy isolation, and the failure modes they produce — especially in enterprise environments with non-standard setups.

#vailent