Forward Deployed Engineer

I recently left McKinsey to build again.

After years working on business building and GenAI in regulated mid-market environments, one thing became clear:

The real bottleneck in AI is not capability. It is turning that capability into reliable systems that operate inside real businesses.

Most companies experiment with AI. Very few build systems that are governed, production-grade, and embedded in operational workflows.

We are building an AI-native company focused on closing that gap.

Not with pilots. Not with slide decks. But by deploying governed AI systems into real operational processes — and creating measurable value in weeks.

Customer operations. Claims. Servicing. Back office. Case-based workflows in regulated industries.

To deploy these systems into real customer environments and make them work under real-world constraints, I am looking for a

Forward Deployed Engineer

(Düsseldorf or Berlin)

How We Build

We do not build the platform in isolation. We build it inside real, paying client engagements in regulated industries, and we own the reusable IP that emerges. The first engagements are the birthplaces of the first platform components.

This is a deliberate choice. It means the platform runs in production from day one, in regulated environments, with real operational data and real consequences. It also means it is funded by client revenue from day one.

The Forward Deployed Engineer sits exactly at the seam where the platform meets the customer. The engagement is the engineering environment. Deployment is where the product is forged.

What This Role Actually Is

This is a senior engineering role embedded directly inside customer engagements. You are the person who takes an Operator design and turns it into a running, governed system inside a real operational environment — banking, insurance, healthcare — with executive sponsors watching and audit requirements in the room.

You will work shoulder-to-shoulder with the founder, the platform engineers, and the customer's operations and IT teams. You will own the deployment from architecture decisions down to the production incident at 9pm.

This is not support. This is not configuration. This is controlled deployment of AI systems under real constraints, where the gap between "it works on the demo" and "it runs the process" is where the value sits.

What You Will Do

Deployment of AI Operators into Production

• Translate Operator Playbooks into running systems on NXT Core
• Adapt architecture to the customer's real environment — core systems, document stores, shared inboxes, legacy workflows
• Own the integration surface: APIs, file drops, ERP connectors, identity, data flows
• Stand up the system in staging, harden it, and take it live

Safe Execution at the Agentic / Deterministic Boundary

• Design clear boundaries between agentic proposal and deterministic execution
• Decide which decisions an LLM is allowed to make and which sit on rules, validations, or human approval
• Build in the controls that make the system auditable and explainable to a regulator or an internal control function

Operating Inside the Customer

• Sit inside the customer's reality — desks, ops floors, IT meetings, steering committees
• Earn trust both with the operator who works the cases and with the executive who signed the SOW
• Close the loop between operational truth and system design — fast

Reliability and Governance in Production

• Own observability, logging, retries, idempotency, failure handling
• Build the on-call and incident posture for a regulated environment
• Make the system debuggable when something goes wrong at 11pm — because something will

Compounding the Platform

• Identify what is reusable and push it back into NXT Core
• Help the platform get sharper with every engagement
• Resist the pull toward one-off solutions that don't compound

Technical Challenges You Will Work On

• Designing safe execution boundaries between deterministic and agentic logic
• Building stateful, long-running case workflows that survive restarts, retries, and partial failures
• Document understanding at production quality across messy, real-world inputs
• Integrating with ERPs, core banking systems, document and policy stores, ticketing systems
• Making LLM-based systems observable, governable, and debuggable in production
• Designing approval flows, escalation logic, and human-in-the-loop where it actually belongs
• Working inside an engineering environment where coding agents are part of the default development model

What You Need

• Strong backend engineering background: Python, Go, or TypeScript, at least one at depth
• Experience designing distributed systems, APIs, and workflow-based architectures
• Production instincts: idempotency, retries, logging, monitoring, on-call, incident handling
• Comfort with LLM-based systems and tool-based agent architectures, or a clear track record of ramping fast on new infrastructure
• Comfort operating in client-facing contexts where the system is being built inside a live engagement
• Fluent German and English — this is a customer-facing role in DACH
• Comfort with messy environments and imperfect requirements

Bonus if you have worked on

• Workflow engines or orchestration platforms
• Document understanding or case management systems
• ERP, core banking, or insurance core system integrations
• Regulated industries — banking, insurance, healthcare
• Early-stage systems with ambiguous requirements

What This Role Is Not

• Not a support or implementation-consultant role
• Not pure platform engineering insulated from customers
• Not a research position
• Not a feature-shop job inside a stable product
• Not a place where requirements arrive cleanly defined

What Success Looks Like

Success in this role means AI Operators that run in production at our customers — governed, observable, and trusted by the operations teams that use them and the executives that signed for them. It means engagements that go live on time, stay live, and produce measurable value. And it means the platform gets stronger with every deployment, because the reusable parts of what you build flow back into NXT Core.

The first concrete proof point: an Operator you deployed end-to-end into a regulated environment, running real cases in production, with a customer who would take the call from the next prospect.

Why This Role Is Rare

Most AI companies are still focused on model capability or demos. This role is about something harder: deploying AI systems that actually run inside real businesses, from day one, with real money and real consequences.

You will help define what a Forward Deployed Engineer looks like in an AI-native operations company — not in theory, not in a blog post, but in production.

Stack

Python, FastAPI, Postgres, Celery, and Go on the backend. TypeScript and React on the front. Claude via Vertex AI in EU (Frankfurt) for the LLM layer. Coding agents are part of the default development workflow.

Structure

• Early-stage environment
• High autonomy and direct customer ownership
• Direct collaboration with the founder and the platform team
• Competitive base plus bonus
• Düsseldorf or Berlin, hybrid, with regular on-site time at customers across DACH

If you want to deploy AI systems that run real operations — not just prototypes — reach out directly.