Founding Backend & AI Engineer

Parsio; Paris; Hybrid; EUR 90,000 - 130,000; Full time

Job summary

Parsio in Paris is seeking a Founding Engineer to shape the core backend, AI systems, and data pipeline. You’ll own architecture end-to-end alongside the CTO and CEO, shipping production-grade features from day one.

You’ll work in Python and TypeScript across the backend and AI stack, building should-cost engines, extraction agents, and scalable ELT processes for industrial data.

Qualifications

• 5+ years building and shipping software.
• Proficient in Python and TypeScript.
• Experience shipping production systems with APIs and SQL.
• Familiar with LLM-powered features and AI reliability.
• Fluent in French and English.

Responsibilities

• Build the core product: backend and should-cost engine.
• Develop AI systems and data extraction pipelines.
• Handle data integration from clients and ELT processes.
• Own architectural decisions end to end.

Skills

Python

TypeScript

API design

SQL

LLMs

Ownership

Tools

PostgreSQL

dbt

CadQuery

GCP Vertex

FastAPI

Job description

About us

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, including PDFs, scanned drawings, CAD files, and 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.

Backed by OSS Ventures, Parsio was founded by Fabien, CEO, and Xavier, CTO. They combine industrial and commercial experience with product and engineering expertise.

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

We’re now looking for our Founding Engineer to join us and shape the next stage of Parsio’s product, technical foundations, and engineering culture.

Why we’re hiring for this role

Every new client brings more industrial data, integrations, and use cases to solve. As Parsio grows, we need to handle more of that complexity without slowing down.

That takes two things at once:

• Shipping fast today.
• Building the right foundation for tomorrow.

That’s why we’re looking for a pragmatic builder who can own technical problems end to end, make sound architecture decisions, and isn’t afraid to get hands-on wherever needed to ship.

The role

As our Founding Engineer, you’ll work directly with the CTO and CEO, owning core backend and AI systems across Python and TypeScript.

You’ll have the autonomy to make architectural decisions on your scope, and the responsibility to turn them into production.

Your main responsibilities

• Build the core product: application backend and should-cost engine. Build the API and data model the whole app relies on, and own the engine at the heart of the product: turning a part’s specs and variables into defensible, explainable costs analysts can act on.
• Build our AI systems. Build the agents that extract and structure technical data from documents, model parts and costs, run cost analysis on top of the should-cost engine, and source external reference data. Own their reliability in production, from evals and monitoring to cost, quality, and latency trade-offs.
• The data pipeline. Process and integrate complex client data into Parsio, adapting the pipeline as new clients bring new formats, data, and use cases.
• Own the architecture with us. The foundational choices aren’t pre-baked. You’ll make them with the CTO, own them on your scope, and take them all the way to production.

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 and 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).

App backend: TypeScript, Hono, Drizzle, Postgres (Neon).

AI backend: Python, FastAPI, PydanticAI + Logfire, GCP Vertex (Gemini, Claude).

ELT: Python, dlt, dbt, cadquery (CAD / STEP), Postgres, LLM and OCR document extraction.

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

We have an opinion on every brick, but none is set in stone: several calls, including orchestration, agent architecture, and parts of the backend design, are open, and we expect you to own some of them.

What success looks like

• At 30 days. You own a meaningful slice of the system, such as a backend domain, the should-cost engine, or AI extraction, and have shipped your first improvements to production.
• At 90 days. The systems you own run reliably in production, with the tests, evals, and monitoring you put in place. You’re making architectural calls on your scope, not just implementing them.
• At 6 months. Your work measurably moves the product: faster and more accurate extraction, a should-cost engine analysts trust, and a backend that scales with new tenants. You’re one of the people the architecture of Parsio runs through.

Career path

We level engineering on a clear track: Engineer, Senior Engineer, Lead / Staff Engineer.

You join as our founding engineer, owning core systems end to end. As you grow, you’ll take on broader architectural ownership across the backend and AI stack, set the engineering standards, and mentor the engineers we hire next.

Your profile

• You’re a strong, pragmatic engineer with 5+ years building and shipping software, including significant backend experience.
• You build in Python and TypeScript, or you’re strong in one and ready to become strong in the other.
• You ship production systems. You’re comfortable with APIs, relational databases, and SQL, and write code others can read, extend, and trust.
• You’ve built on LLMs, not just with them. You’ve shipped an LLM-powered feature or pipeline and understand what it takes to make AI reliable in production.
• You want ownership, not just tickets. You can make sound architectural decisions, defend them, change your mind, and stay hands-on to ship.
• You’re AI-native in how you build, using tools like Claude Code or equivalent pragmatically to move faster.
• You’re comfortable working in French and English.

Bonus points for: experience with modern ELT / dbt, LLM evals or vision models, CAD / STEP files, rules engines or typed DSLs, product taxonomies, or industrial environments.

This role is probably not for you if…

• You want a fully defined scope with no ambiguity.
• You’d rather go deep in one narrow layer than build across the stack.
• You’re uncomfortable switching between architectural decisions and hands-on, scrappy execution.
• 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.