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 wo