Senior Python Developer

Brayns; Stockholms kommun; On-site; SEK 900,000 - 1,300,000; Full time

Job summary

Brayns in Stockholm is seeking a deeply senior Python engineer to design and scale core backend systems. You will own architecture decisions and guide the stack as we grow a product around LLM-powered workflows.

This onsite role requires you to live in Stockholm or relocate before starting; remote work is not available. You will build reliable pipelines, background jobs, observability, and collaborate with a small, strong team to ship real impact, cost-aware and resilient.

Qualifications

• Deeply senior with extensive production Python experience.
• Built a real product and owned code over years, not quick client engagements.
• Strong with LLM APIs, prompting, orchestration, and evaluation.
• Experienced with long-running jobs, monitoring, retries, and observability.
• Comfortable with infrastructure, deployments, and networking basics.
• Autonomous problem solver and technical leader.

Responsibilities

• Design, build, and scale core backend systems in Python.
• Own the LLM layer, including prompting, orchestration, and cost/latency tradeoffs.
• Build and operate long-running background jobs and monitoring.
• Set technical standards and uphold code quality across the team.
• Collaborate with ops to ensure deployable, observable, and reliable software.

Skills

Python

LLM APIs

System design

Architecture

Monitoring

Background jobs

Autonomy

Technical leadership

Job description

About Brayns

We are a small team teaching machines to run compliance work end-to-end. Brayns reads how operators actually work: documents, case history, the judgement of senior people, and turns that structure into agents that execute continuously, traceably, at scale.

About Brayns

We are a small team teaching machines to run compliance work end-to-end. Brayns reads how operators actually work: documents, case history, the judgement of senior people, and turns that structure into agents that execute continuously, traceably, at scale.

The role

We’re building what we think will be one of the next unicorns out of Stockholm, and we’re hiring the kind of engineers who can take it there. This is a senior Python role for someone who has spent serious time building and scaling a real product - not someone who has bounced between client engagements writing throwaway code.

You’ll be one of the most senior engineers on the team. That means designing systems end-to-end, making the calls on architecture, and owning the parts of the stack that need to actually hold up as we scale. LLMs are at the core of what we’re building, so this role lives close to that work.

This role is onsite in Stockholm and open only to candidates who already live in Stockholm or are ready to relocate before starting. We will not be considering remote applicants.

What you will do

• Design, build, and scale core backend systems in Python.
• Own the LLM layer of our product - prompting, orchestration, evaluation, cost and latency tradeoffs, and integrating with the broader ecosystem of tools and providers.
• Build and operate long-running background jobs and the monitoring systems that keep them honest.
• Make architecture and infrastructure calls, and work closely with whoever is running ops to make sure what we ship is actually deployable, observable, and reliable.
• Set the technical bar for the team - through code, design, reviews, and the standards you hold others to.

What we look for

• Deeply senior. You’ve been writing production Python for a long time and have the scars to show for it. You know what good looks like and what tends to bite later.
• Built a real product, not consulting work. You’ve spent years inside a single-product company, owning code that you also had to live with. We’re not looking for someone whose experience is mostly client engagements or short-lived projects.
• Strong with LLM APIs and the surrounding ecosystem. You’ve shipped real features built on LLMs - not just experimented. You understand prompting, tool use, evaluation, retries, streaming, cost control, and the practical tradeoffs between providers and models.
• Long-running jobs and monitoring. You’ve designed and operated background workers and pipelines that have to run reliably for minutes, hours, or longer - with proper monitoring, alerting, retries, and recovery.
• Comfortable around infrastructure. You don’t need to be a DevOps engineer, but you do need to understand the infra your code runs on - deployments, networking basics, queues, databases, observability - well enough to design with it in mind.
• Autonomous. Give you a problem and you go figure it out. You don’t wait for tickets, and you don’t need someone above you signing off on every decision.
• A technical leader. You can design systems and scale them, and you can bring others along - through clear thinking, good documentation, and the example you set in code.