The role
We embed engineers directly inside enterprise clients to find, build, and ship AI and agentic systems that reach production and stay there. A Forward Deployed Engineer runs discovery with the customer's own stakeholders, scopes the use cases worth building, then writes and deploys the working system - in the customer's environment, against their data, under their security and governance constraints.
This is a build-with-the-customer role, not an advisory one. You are the person in the codebase and in the room, closing the gap between an ambiguous "we should use AI" and a governed system operators actually trust and use. You own outcomes through real production usage - you do not hand off a slide deck or a prototype and move on.
What you'll do
- Run discovery with the customer's business stakeholders and turn open-ended "we should use AI" asks into scoped use cases, ranked by ROI, data readiness, and technical feasibility.
- Build and ship production GenAI and agentic systems end to end - retrieval (RAG), agent orchestration and tool/MCP integration, evaluation harnesses, and the surrounding application and data plumbing.
- Deploy inside the customer's environment and constraints: their cloud, their security posture, their data governance - not a sandbox you control.
- Design for trust - keep business-critical logic (pricing, rules, calculations) in deterministic code paths, build evaluation and human-in-the-loop review, and know when model output is safe to put in front of operators.
- Embed and enable: document the system, run walkthroughs, and lift adoption - while owning the system through real production use, not until the demo.
- Present architecture, cost, and delivery trade-offs directly to non-technical decision-makers and keep them bought in.
What we require
- You ship code now. Recent, hands-on, first-person production work you can walk through line by line - not architecture you directed or reviewed. If your last real commit was two years ago, this isn't the role.
- Real engineering fundamentals. You can drop into an unfamiliar codebase, debug code you didn't write, and build the thing when the platform's GUI can't express it and the AI assistant is stuck. Low-code and AI-assisted development are welcome as tools, not as the whole toolbox.
- Genuine customer-facing experience. You've been embedded with customers - in their environment, their mess, their competing priorities - and navigated ambiguity and stakeholders with no direct authority. Internal-only product work doesn't demonstrate this.
- Demonstrable production GenAI depth. You've built real RAG and/or agentic systems and can explain the mechanics - retrieval strategy, orchestration, tool-calling - and, above all, how you evaluated them and made them safe to trust. A buzzword list is not depth.
- Evaluation and guardrail instinct. You keep the stochastic model out of business-critical decisions, and you can prove your AI output is trustworthy rather than hoping it is.
- Verifiable. Code we can look at and claims you can substantiate in a live session. A résumé is a starting point, not evidence.
- Ownership temperament. You can own a system through production and iteration, inside a team's codebase and discipline - not only build-and-leave proofs of concept.
Strong pluses
- Regulated-industry delivery (financial services, insurance, actuarial, wealth, pension) and comfort with its data, privacy, and governance realities - RBAC, audit, PIPEDA/GDPR.
- Governed enterprise-AI patterns: human-in-the-loop, confidence thresholds, audit logging, escalation-path design.
- Working depth in one or more of LangGraph or comparable agent frameworks, MCP, and AWS Bedrock / Azure OpenAI / GCP - real depth in one beats a shallow tour of all three.
- A track record of taking use cases from discovery to production with measurable, defensible outcomes.
- Strong written communication and the ability to teach - enablement is part of the job.
What this role is not
- Not an architect or advisory seat. You build and deploy; you don't just diagram, cost, and present.
- Not a low-code or platform-configuration role. Platforms are means; the job is engineering.
- Not prototype-and-handoff. You own outcomes through production, not until the demo works.
- Not a solo BD or fractional-consulting arrangement. This is full-contact delivery on a team.
How we evaluate
We weight what you can demonstrate over what's on the page. Come ready to build, and bring specifics.
- A live, assistant-off exercise - extend or debug an unfamiliar codebase in front of us. This is the primary signal.
- A production deep-dive - walk us through what broke in production, how you found it, and how you knew your AI output was safe to trust.
- A discovery role-play - turn an ambiguous stakeholder ask into a scoped, ROI-ranked use case, out loud.
- A depth check on your own claims - pick your strongest AI project and go as deep as we push: the graph, the retrieval, the evals, the guardrails.
Fit check
You'll thrive here if:
- You'd rather ship a working system in a customer's messy environment than produce the perfect architecture diagram.
- You're energized by ambiguity and being the most accountable person in the room.
- You treat "the model said so" as the start of the work, not the end.
This isn't for you if:
- You've moved into full-time architecture, strategy, or team leadership and don't miss the code.
- Your AI experience is mostly demos, courses, or platform configuration.
- You want to advise and hand off rather than build and own.