Forward Deployed Engineer

re-zoo-me; Houston (TX); On-site; USD 120,000 - 180,000; Full time

Job summary

Vailent is seeking a customer-facing engineer who operates at the intersection of deployment, integration, and product. You will embed directly with customers — chemicals distributors, polymer producers, elastomer traders — to understand their real operational environment and build production solutions that enable Vailent to work within it.

The role emphasizes ownership of outcomes, production-quality code, and close collaboration with product and engineering to generalize field learnings into

Qualifications

• Experience delivering production-grade integrations with enterprise stacks.
• Ability to map SAP/ERP configurations and CRM data flows.
• Strong customer-facing communication and technical leadership.

Responsibilities

• Own AI-enabled implementation for users, making implementations more efficient and scalable using AI-driven tooling and automation.
• Embed with customers and own the outcome by understanding workflows, constraints, and data before touching code.
• Run technical discovery before engagements to map the customer's existing stack and data flows.
• Build and deploy production solutions and tenant configurations that run in live environments.
• Own the full integration lifecycle from first API call to stable sync including SAP/ERP data and CRM connections.
• Be the primary technical relationship, communicating architectural decisions to non-technical stakeholders.

Job description

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

• Own AI-enabled implementation for users, with primary responsibility for making implementations more efficient and scalable — using AI-driven tooling and automation to reduce manual effort, shorten time-to-value, and enable the team to support more customers without linearly scaling headcount
• 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, elevate 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