Senior Engineer

Description

You own the ontology at the heart of the company: how we structure data, how it gets in, and how the codebase is built around it. You are also a central part in how we prove changes to the codebase, so that us as a fast moving AI enabled team can move even faster without slop clean up and reviewing becomes the bottleneck.

The company is the agentic platform for construction. Agents read tender documents, extract requirements, check them against what a contractor knows about itself, and draft bids, reviews and change orders. Every answer is only as good as the data that is available to the agents.

That model is hard to get right. Tenders arrive as bundles of PDFs, drawings and spreadsheets, revised mid-process. The same requirement appears in several documents in different words. Customers are groups with dozens of subsidiaries. Turning that into clean, versioned objects takes real skill and experience.

What you'll own

The ontology

The objects everything rests on: organisations and subsidiaries, projects, documents and versions, requirements (krav), company facts, standards, bids and their answers. How they relate, version and carry provenance, so every agent answer traces to a document, page and fact.

The pipelines that fill it: parsing, extraction, entity resolution and backfills that turn raw documents into those objects and rerun cleanly when the model changes.

Permissions and tenant isolation across groups with dozens of subsidiaries.

How the codebase is structured around it: schema, migrations that ship daily without breaking what's live, and the typed tools agents use to read and write it.

Shipping at agent speed

Evals and verification by default: every change to the ontology, a pipeline or a prompt comes with evidence it works.

Rules and playbooks for the repo: how code is structured, tested and shipped, so engineers and coding agents build the same way.

The systems that take review off the critical path: automated checks and small, verifiable changes, so reviewers judge decisions instead of reading every diff.

First 90 days

Day 30

Understand where we stand with the current data model. Improvements to the existing data structures shipped to production.

Day 60

3 more concepts modelled and integrated into the product. Map out and experiment with how we can improve our codebase to enable us to run event faster with agents.

Day 90

Entire product team is shipping on top of your data model and we as a team are moving faster than ever.

How we build

Agents write most of our code (Cursor, Claude Code, Devin). Writing code is no longer the slow part. Judgement and proof are: the model, the interfaces, and knowing a change works without someone reading every line.

We like how Lauren Tan (poteto) at Cursor frames it in pstack (https://github.com/cursor/plugins/tree/main/pstack): don't let agents just write more code. Go deep and get it right first, leave verifiable evidence, and only then run agents in parallel. Few teams have made that work across many engineers. You'll help us do it.

Responsibilities

• You own the ontology at the heart of the company: how we structure data, how it gets in, and how the codebase is built around it. You are also a central part in how we prove changes to the codebase, so that us as a fast moving AI enabled team can move even faster without slop clean up and reviewing becomes the bottleneck.
• The company is the agentic platform for construction. Agents read tender documents, extract requirements, check them against what a contractor knows about itself, and draft bids, reviews and change orders. Every answer is only as good as the data that is available to the agents.
• That model is hard to get right. Tenders arrive as bundles of PDFs, drawings and spreadsheets, revised mid-process. The same requirement appears in several documents in different words. Customers are groups with dozens of subsidiaries. Turning that into clean, versioned objects takes real skill and experience.
• What you'll own
• The ontology
• The objects everything rests on: organisations and subsidiaries, projects, documents and versions, requirements (krav), company facts, standards, bids and their answers. How they relate, version and carry provenance, so every agent answer traces to a document, page and fact.
• The pipelines that fill it: parsing, extraction, entity resolution and backfills that turn raw documents into those objects and rerun cleanly when the model changes.
• Permissions and tenant isolation across groups with dozens of subsidiaries.
• How the codebase is structured around it: schema, migrations that ship daily without breaking what's live, and the typed tools agents use to read and write it.
• Shipping at agent speed
• Evals and verification by default: every change to the ontology, a pipeline or a prompt comes with evidence it works.
• Rules and playbooks for the repo: how code is structured, tested and shipped, so engineers and coding agents build the same way.
• The systems that take review off the critical path: automated checks and small, verifiable changes, so reviewers judge decisions instead of reading every diff.
• First 90 days
• Day 30
• Understand where we stand with the current data model. Improvements to the existing data structures shipped to production.
• Day 60
• 3 more concepts modelled and integrated into the product. Map out and experiment with how we can improve our codebase to enable us to run event faster with agents.
• Day 90
• Entire product team is shipping on top of your data model and we as a team are moving faster than ever.
• How we build
• Agents write most of our code (Cursor, Claude Code, Devin). Writing code is no longer the slow part. Judgement and proof are: the model, the interfaces, and knowing a change works without someone reading every line.
• We like how Lauren Tan (poteto) at Cursor frames it in pstack (https://github.com/cursor/plugins/tree/main/pstack): don't let agents just write more code. Go deep and get it right first, leave verifiable evidence, and only then run agents in parallel. Few teams have made that work across many engineers. You'll help us do it.

Requirements

• You have designed and owned the data model of a product customers depend on, and evolved it through migrations and backfills.
• You have built pipelines that turn messy, unstructured documents into structured data people trust.
• Strong in TypeScript and/or Python, with relational and reactive databases.
• You have built LLM features in production: tool use, retrieval, structured output, evals.
• You ship with coding agents daily and know how to verify their work without reading every line.
• You write clearly. Decisions and interfaces get written down.
• Fluent English.
• Nice-to-haves
• Document-heavy domains: legal, construction, procurement, compliance.
• Ontology, knowledge-graph or entity-resolution work.
• Convex or Cloudflare Workers.
• You have built eval harnesses, CI checks or MCP servers other engineers rely on.
• Swedish.
• Practical
• Team
• Product & Engineering, reporting to Linus Bein Fahlander (CTO & co-founder), working daily with CJ (Engineering Team Lead)

Conditions

On-site by default, Linnégatan 89B, Stockholm

Level

Senior. What you've built matters more than years

Comp

Competitive salary and equity

Experience: 3+ years

Visa: US citizen/visa only