Parsio - Founding Backend/AI Engineer

OSS Ventures; Paris; On-site; EUR 80,000 - 95,000; Full time

Benefits offered by this job

Founding BSPCE equity

Job summary

Parsio is hiring a Founding Engineer to build and own core backend and AI systems in Paris. You will work directly with the CTO and CEO, shaping architecture, internals, and production deployment of the should-cost engine and data extraction pipeline.

The role blends hands-on coding with strategic decisions to prepare Parsio for rapid growth. You should be fluent in Python and TypeScript, capable of shipping end-to-end features, and comfortable operating in French and English.

Qualifications

• 5+ years building and shipping software with strong backend experience.
• Proficiency in Python and TypeScript; able to ship production systems.
• Experience with APIs, relational databases and SQL; write maintainable code.

Responsibilities

• Build the core product: backend and should-cost engine; API and data model.
• Develop AI systems and agents to extract/structure data and run cost analysis.
• Design and evolve the data pipeline to handle new clients/formats.
• Make architectural decisions and ship them to production with CTO/CEO collaboration.

Skills

Backend engineering

Python

TypeScript

LLMs / AI systems

APIs

Tools

PostgreSQL

Drizzle ORM

FastAPI

Job description

Build Parsio's core backend and AI systems, and help turn our clients' messy industrial files into typed, auditable, decision-ready data that makes them more competitive.

The role at a glance

• Location: Paris
• Contract: CDI · On-site・ 3–4 days/week
• Compensation: €80–95K gross
• Equity: Founding-level (BSPCE)
• Reports to: Co-founder & CTO
• Start date: ASAP

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 (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.

Backed by OSS Ventures

Parsio was founded by Fabien CEO and Xavier CTO, combining 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, 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; 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 (orchestration, agent architecture, 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 (a backend domain, the should-cost engine, or the 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, 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.

The process

• Intro call with the CTO (~45min)
• Case (~1h30)
• Meet the CEO (~1h)
• Reference calls (1–2)

Your profile

• You’re a strong, pragmatic engineer with 5+ years building and shipping software, with 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.