Toore - Founding Engineer

OSS Ventures; Paris; Sur place; EUR 75 000 - 100 000; Plein temps

Résumé du poste

Toore is seeking a Founding Engineer to own delivery of core features end to end, from specification to production. You will help build the circular-industry OS, advancing data collection, BI, and client-facing surfaces while maintaining a high quality bar and strong technical leadership.

The role requires shipping backend-heavy features in collaboration with frontend work, with a focus on Postgres/SQL, Python, and modern tooling. Paris-based, CDI, reporting to CTO, ASAP start.

Qualifications

• Ships backend-focused features, from spec to production, with a strong emphasis on code quality.
• Balances frontend and backend work, contributing across the stack as needed.
• Maintains high standards: tests, migrations, and clean architecture.
• Writes clear specs and decisions in English to align the team.

Responsabilités

• Ship core features end to end from spec to production.
• Grow the shared ontology powering all clients while keeping per-client surfaces fast.
• Maintain high reliability: >90% test coverage, >99% CI/CD success, no data leaks.
• Turn client needs into shipped software with well-scoped specs.
• Reduce technical debt with future-proof fixes, tests, or linters.

Connaissances

Python backend

React/TypeScript

FastAPI

SQL databases

Product mindset

Outils

PostgreSQL

Docker

Kubernetes

Description du poste

At Toore, we are looking for a Founding Engineer to join our team.

TL;DR

Role title Founding Engineer
Also known as Product Engineer
Location Paris
Contract Permanent (CDI)
Salary range €75–100K gross + BSPCE
Reports to CTO
Start date ASAP

About us

• Our mission
  We make remanufacturing and refurbishment profitable to run at industrial scale.

  • Our story
    Toore is the decision infrastructure for industrial remanufacturing. It was founded by Thibault Geoffray (CEO) and Mathieu Seris (CTO), and is backed by OSS Ventures, the startup studio and investor. We are early-stage, closing a pre-seed round, with live commercial engagements at industrial groups across automotive, machinery and IT distribution.

    • Our ambition
      Remanufacturing is the highest-margin industrial opportunity in Europe, and the fastest to leak that margin. The companies that decide fast and right in the chaos will take share. We are building the layer that lets them do it: item-level economics on every purchase, routing and dismantling decision, driven all the way to the operator's gesture so the modeled margin becomes the realized margin. The next two to three years are about proving that on a handful of industrial accounts and turning it into a repeatable motion.

      • Our team
        You will be part of the tech team, (Founding Engineer+CTO, average experience +10yr). We are builders, hands on. Delivering impactful features, with a high quality bar (linter, guardrails, system architecture) to create the core product to tackle all our client problem.

        Thibault (+ upcoming Forward Deployed Strategist) owns go-to-market, product strategy and operations.

        The team is small, senior, and moves fast: scope is written before work starts and no function outranks another.

        • Our values
          1. Care: We care because our clients’ mission is worth it.
          2. Forward thinking: Build for tomorrow
          3. Collective Contributor: Our organization is a system of intelligence, make it smarter
          4. Ownership: Own your actions and their results
          5. Humility: No bullshit, low drama

          Why we're hiring for this role

          We're hiring our first founding engineer because product velocity has become the bottleneck: our CTO is increasingly pulled into client onboarding. This is a net-new role, not a backfill — you'll own delivery of core features end to end so engineering can scale beyond 2 persons. Without it, we stall the roadmap right as customer demand is accelerating.

          What you'll do

          In a nutshell

          You own product delivery of the circular-industry OS end to end — from spec to production — and set the technical bar that the next engineers will build on.

          Your main responsibilities

          • Ship core product features from specification to production, owning the outcome: the data collection, BI, and action layers that let industrialists run operations, sales, and diversification on Toore.

          • Grow the shared ontology that powers every client, while keeping per-client surfaces fast to build — so we apply agentic AI at scale with no slop.

          • Defend the service level our customers trust us with: >90% test coverage, >99% CI/CD success, no N+1 in production, no data loss or leakage between clients.

          • Turn fuzzy needs from clients, the CTO, or founders into shipped software with minimal back-and-forth, writing the specs and technical scoping as you go. Build component blocks that are flexible and future-proof.

          • Pay down technical debt deliberately and make every fix future-proof — a test, a linter rule, or a skill — so a bad pattern never ships twice.

            On a day-to-day basis, you will

            • Pick a feature off the roadmap, scope it in Notion, share it to the team

            • Open the PR, get it throught Greptile code review and human review, perform QA on the PR specific review app

            • Debug a client-flagged issue straight from Logfire/Sentry, ship the fix, and add the linter rule or test that kills the class of bug for good.

            • Pair with the CTO/Peer to align on direction, product or engineer bets, then execute — and write down the decision/learnings so the team gets smarter.

              Who you'll work with

              • Direct manager: Mathieu (CTO), who you'll pair with on direction and architecture — close enough to align fast, hands-off enough that you own execution.

              • Closest collaborator: Damien, our Front/Product Engineer. You own the backend and shared ontology; he owns the per-client frontend surfaces. The two of you are the product, end to end.

              • Cross-functional: Thibault (founder/CEO) and the client-facing team (Forward Deployed Strategist). You'll hear customer problems close to the source — sometimes directly, in the factory — rather than through three layers of translation.

                What success looks like

                At 2 days — You've got the full stack running e2e locally (well under the 2-hour onboarding bar — and if it took longer, you've already fixed the docs so the next hire doesn't hit it). You have shipped your first PR in production.

                At 60 days —

                • You're owning a meaningful slice of the product independently — picking work off the roadmap, scoping it, and shipping without the CTO in the critical path.

                • You've gone deep in at least one area where you bring edge — Postgres/SQL, infra, data eng, persistent workflow, machine learning, or agentic — and the team is visibly better for it (a pattern, a skill, a performance fix that holds).

                • A client-facing problem has been solved by you end to end: heard it, scoped it, shipped it, watched it land.

                  At 6 months — You're a true peer to the CTO on technical direction — trusted to make architecture and data-modeling calls, not just execute them. And you're leveling up the system itself, so the whole tech team moves faster because of how you've built it.

                  Your profile

                  Must-haves (non-negotiable — if you don't have these, this role isn't for you)

                  • You ship product (fullstack) feature to production and own it there — most of the work is backend (Python, FastAPI, SQLAlchemy), and you should be excellent at it. Comfortable in the frontend (React/TypeScript) from our component library

                  • You think like a product engineer, not a ticket-taker: you can take a fuzzy client problem, scope the what yourself, and decide what's worth building — not just execute a spec someone hands you.

                  • You hold a high quality bar without being told to: tests-first, no N+1, clean migrations, code that survives review by humans and agents.

                  • You write to think and to align — specs, decision records, scoping — in English, by default.

                    Years of experience

                    • 6+ years building and shipping production software, mostly backend

                    • 3+ years in B2B SaaS or a product-led environment where you owned features end to end

                    • Experience at an early-stage startup, or the clear appetite for one — comfortable with ambiguity, small teams, and high ownership

                      Nice-to-haves (we'll be excited if you have these, but we won't require them)

                      • Deep expertise in one of: Postgres/SQL, infra (GCP, Dokploy, Kubernetes), data engineering, async processing (Celery, Temporal), agentic workflows (pydantic-ai/Logfire), data science (evaluation, performance monitoring)

                      • French — useful with clients, but the team and all artifacts run in English

                        We'll teach you what you don't yet know about

                        • Our stack's specifics — the ontology, our skills/patterns, Spec Driven Development, the agentic tooling

                        • The circular / refurbishment industry and what our industrialist clients actually need

                          This role is probably not for you if…

                          • You want a fully scoped ticket handed to you

                          • You think of quality as someone else's job

                          • You'd rather stay purely backend and never touch a spec, a client problem, or a frontend file

                          • You don't want to apply agentic AI in the way you work

                          Our hiring process

                          • 1. Deep dive interview with Mathieu (CTO) 60 min: Career track, key experiences, scope reality, motivation check, logistics

                          • 2. Use case / Assessment with Tech team (Damien+Mathieu) 60–90 min: Real-work simulation

                          • 3. Culture fit interview with Thibault (CEO) 45 min: Values, working style, long-term fit

                          • 4. Reference calls with Mathieu (CTO) — 2 reference calls

                          • 5. Offer Mathieu (CTO) — Written within 48h of decision

                          We commit to: written feedback at every stage, a GO / NO GO communicated within 4 business days of each interview, and a final decision within 4 weeks of the first call.

                          A word to our candidates

                          We are small, and that is the point. Each person here is the culture, and this role carries more ownership than most companies hand to a first hire. If you want to take everything you've learned about how industry actually runs and turn it into margin for the people running it, this is a rare seat. We'll be honest with you the whole way through. We'd ask the same back.