Forward Deployed Engineer

We started Parsio with one intention: help make European industry competitive for the 21st century. It’s a domain where deep technical skill still turns into real, measurable impact, and that’s the leverage we want.

What we do: help procurement teams buy better and buy smarter. Manufacturers sit on huge piles of unstructured technical data (PDFs, scanned drawings, CAD files, spreadsheets). We turn it into something a human and an AI can both understand, then build a cost modeling layer on top that can simulate anything: a supplier change, a part redesign, a commodity price hike, and more. Weeks of expert work become a cost-saving strategy a team can act on.

We’re a small, synchronous, trust-first team in Paris: side by side most of the week, decisions made out loud, no org chart between you and the two founders.

Why we’re hiring for this role

AI is easy to try. Making it work inside an industrial enterprise is a different problem entirely. The gap between a demo that impresses a procurement director and a system their team actually sources on is where deals are won or lost, and today that gap is crossed by the two founders.

What we’re building wasn’t possible six months ago. The bottleneck was never insight, it was capacity, and that constraint just disappeared. This is an 18-month window to build the category winner in AI-native procurement intelligence for industry, and the teams that deploy fastest now will lock in advantages the incumbents can’t catch.

We’re hiring the person who takes clients beyond the POC and into production, and who turns everything learned in the field back into the platform.

The role

You’re a full-stack engineer who works directly inside the customer’s environment , alongside their buyers, engineers and operators. You report to the Co-founder & CTO and work daily with the CEO.

You operate like a startup CTO embedded in the account: you own end-to-end execution of a high-stakes deployment. In practice:

• You write real production code. This is an engineering role, not a solutions-consulting one.
• You integrate with legacy systems and brittle data pipelines: ERPs, PLMs, supplier portals, twenty years of Excel.
• You model messy institutional workflows: how this client actually sources, costs and decides.
• You build specialized skills, workflows and integrations on top of Parsio, so our agents behave like a highly trained teammate for this client, not a vanilla chatbot.
• You sit alongside analysts, operators and decision-makers and adapt continuously as requirements evolve.

This work is intentionally uncomfortable. It exposes you to edge cases, organizational friction and failure modes that never surface in a controlled product environment.

The feedback loop. You are the closest person to the customer, and what you learn flows straight back into the platform: you deploy into a real institution, solve a concrete operational problem that delivers measurable savings, identify the structural challenges that recur across clients, abstract them into reusable primitives, and incorporate those into core Parsio. The goal isn’t one heroic deployment. It’s making the next one cheaper because of what you fed back from this one.

How we ship. Every change goes through review and CI before it merges; tests, evals and monitoring are part of “done”, not a follow-up. Because we trust our CI, we deploy to production whenever we need to.

The stack

The product is made of several blocks with distinct roles:

• App client: An SPA, the user-facing UI.
• App backend: A REST API with direct DB access; it serves the SPA and the AI backend, and computes the cost models.
• AI backend: A dedicated API that runs the AI agents; reaches data only through the App backend.
• ELT: A data pipeline that processes our clients’ input files and loads the results into our DB through the App backend.

Client: React, React Router, TypeScript, Vite (SPA).

ELT: Python, dlt, dbt, cadquery / FreeCAD (CAD / STEP), Postgres, LLM and OCR document extraction, ML with Bruin and scikit-learn.

Infra: GCP Cloud Run, GCS, Cloudflare, CI/CD on GitHub.

You’ll work across all of it. On your deployments, you own the integration layer end to end and you’ll be the one telling us which parts of it deserve to become product.

Your main responsibilities

• Own a deployment end to end. From the first on-site workshop to a production system their sourcing decisions run on: scoping, integrations, data quality, rollout, adoption.
• Get their data in. Build the integrations and pipelines that pull from ERPs, PLMs, supplier portals and twenty years of spreadsheets, and make the output typed, auditable and trustworthy.
• Make the agents client-specific. Build the skills, workflows and evals that turn Parsio’s agents into a teammate trained on this client’s parts, suppliers and cost logic.
• Ship product code, not just glue. Extend the app, the should-cost engine and the AI backend where the deployment needs it.
• Abstract and feed back. Turn recurring client‑specific work into reusable primitives that ship into the core platform, and be the voice of the field in what we build next.

What success looks like

The job has two outputs: a client getting real value, and a product that’s better for having deployed there. That’s why we measure abstraction extracted, not just deployments delivered.

• At 1 month. You’re embedded on-site with your first client, you understand how they actually source and decide, and your first integrations are live in production.
• At 3 months. Parsio runs reliably end to end inside that client, from their raw files and systems to typed data driving real sourcing decisions, with the monitoring, tests and auditability you put in place.
• At 6 months. Your deployment delivers savings the client can point to, and you’ve turned your first recurring patterns into reusable primitives that shipped back to the core platform.
• At 12 months. You run multiple deployments, the playbook and primitives you built make each new one faster and cheaper, and you’re trusted to make the architectural calls on your scope.

Your profile

We hire curious hustlers. This work requires high agency, insatiable curiosity and a healthy disregard for the status quo.

Must-haves

• Full-stack and pragmatic. You move from a React fix to a SQL pipeline to an API integration without friction.
• Business acumen. You walk into a manufacturer, sit with the buyers and the engineers, find where the real money and the real friction are, and connect that diagnosis to a product hypothesis.
• Client-facing by default. You build trust quickly at every level of an organization, communicate with clarity and tailor your depth to the room. This is a deeply on-site role: you’ll spend a large share of your time at clients.
• Owner mindset under ambiguity. You take a vague client problem and drive it to a production system that delivers value.
• Pragmatic with AI tooling. Claude Code (or equivalent) as your primary coding interface, not a curiosity. You know when to trust it and when not to.
• Willing to travel. Expect 25–50% on‑site presence with clients.
• Operational French and English (international clients).

Nice-to-haves

• Real industrial exposure (manufacturing, procurement, automotive, aerospace, steel…).
• Experience integrating with ERP / PLM systems.
• Familiarity with CAD / STEP files (cadquery, FreeCAD).
• You’ve shipped a typed product taxonomy or ontology ( , UNSPSC, or an internal one).
• Experience with LLM eval frameworks, or vision models for document understanding.
• dbt and modern ELT (dlt, warehouse modeling).

This role is probably not for you if…

• You want a fully defined scope with no ambiguity.
• You’d rather stay behind a laptop than spend days on a factory floor reading the room.
• You’re uncomfortable switching between architectural decisions and hands‑on, scrappy execution.
• You’d rather perfect one deployment than turn it into something the whole platform inherits.
• You need a large team and established processes to be effective.
• You see AI tooling as a gimmick rather than a core part of how you ship.
• You’re not comfortable operating in both French and English.

You join owning a deployment end to end. As you grow, you take broader ownership across accounts, turn field learnings into platform standards, set the engineering standards for how we deploy, and mentor the FDEs we hire next.

The process

• 01 Intro call with the CTO (~30min)
• 02 Case (~1h30)
• 03 Meet the CEO (~1h)
• 04 Reference calls (1–2)