Parsio - Founding Backend/AI Engineer

OSS Ventures; Paris; Sur place; EUR 80 000 - 90 000; Plein temps

Avantages offerts par ce poste

Equity BSPCE

On-site in Paris

Founding-level role

Résumé du poste

Parsio seeks a founding engineer to own the core backend and AI systems in Paris. You will build in Python and TypeScript, report to the Co-founder & CTO, and collaborate with the CEO daily. You will define architectural direction and ship high-impact features for cost modeling and data extraction.

This is a hands-on builder role with end-to-end ownership, CI/CD discipline, and a strong emphasis on scalable, auditable data pipelines for industrial clients.

Qualifications

• You build robust backend systems and APIs for production use.
• You ship with Python and TypeScript across AI and data pipelines.
• You are comfortable with Postgres and modern ELT stacks.

Responsabilités

• Own the core backend and should-cost engine end to end.
• Build and refine AI extraction and data modeling pipelines.
• Lead architectural decisions for backend and AI components.

Connaissances

Backend development

TypeScript expertise

Python

LLMs

English and French

Outils

PostgreSQL

Hono

Drizzle

FastAPI

Pydantic

Description du poste

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–90K 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.

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

Every new client brings more industrial data and more processes to model. We need serious engineering muscle to scale without slowing down. That takes two things at once: shipping fast today, and building the right foundation for tomorrow. We’re hiring the founding engineer to help us do both: someone who builds in both Python and TypeScript, and who we trust to make the big architecture calls with us, the decisions that set how far and how fast we can grow from here.

This is a builder’s role. If the thing that gets you out of bed is taking a hard, ambiguous problem and shipping the system that solves it, this is the seat.

The role

As our founding engineer, you will own our core backend and AI systems end to end, in Python and TypeScript. You will report to the Co-founder & CTO and work daily with the CEO.

We decide the what and the when together, out loud, then ship fast. On your scope you own the architectural calls, with the ownership, autonomy and initiative that implies.

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)

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.

Your Main Responsibilities

• Application backend and the should-cost engine. Build the Hono REST API and the Drizzle data model the whole app reads and writes, and own the engine at the heart of the product: turning a part’s specs and variables into a defensible, explainable cost analysts act on.
• AI systems (Python).
• Build the agentic harness : structured outputs, model selection, eval suites and Logfire monitoring, and the cost, quality and latency tradeoffs of running it at scale.
• Build and fine tune our different agents : spec extraction (reading pdf, cleaning data), modelling (code the data model), cost analysis (reason over the cost engine result), sourcing (retrieving reference data online)
• The data pipeline. A contained ELT pipeline (Python, dlt, dbt) that processes clients’ data and ingests it into our DB.
• Own the architecture with us. The foundational choices aren’t pre-baked. You’ll make them with the CTO and own them on your scope (see The stack for what’s deliberately left open).

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 (~1h)
• Case (~1h30)
• Meet the CEO (~1h)
• Reference calls (1–2)

Your profile

Must-haves

• You build in both Python and TypeScript, or you’re clearly strong in one and hungry to be strong in the other. This role lives on both sides.
• You ship production backends. Real APIs, real data models, real migrations, running for real users. You write code others can read, extend and trust.
• Solid with relational databases and SQL. You model data well and you’re comfortable in Postgres.
• You’ve built on LLMs, not just with them. You’ve shipped at least one LLM-powered feature or pipeline to production (structured extraction, agents, RAG) and you know that prompts without evals are guesses.
• You want to own architecture, not just tickets. You have opinions on how systems should be built, you can defend them, and you can change your mind.
• 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.
• Operational French and English (international clients).
• 5+ years building and shipping software, a good chunk of it backend.

Nice-to-haves

• Experience with a typed DSL, rules engine, or anything that evaluates expressions (interpreters, ASTs, formula languages).
• dbt and modern ELT (dlt, warehouse modeling).
• Experience with LLM eval frameworks, or vision models for document understanding.

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.