Agentic AI Backend Engineer

WasteHero builds the operating system for modern waste management. Our SaaS platform runs route planning, CRM, billing, citizen services, and container logistics for municipal and private waste operators across the Nordics and the Middle East.

We have long-term contracts serving millions of citizens, and institutional backing. We are preparing for Series A.

We are building an engineering organisation where agentic AI is how we build product. Not a tool on the side. The method. Every engineer we hire is measured by their ability to ship production-grade software through AI-assisted and agentic workflows.

The Role

We are hiring an Agentic AI Backend Engineer who builds production software through agentic AI workflows — and who builds the engineering environment that makes agentic AI effective.

That second part is what makes this role different. OpenAI recently described an experiment building an entire product with zero manually written code. Their core insight: the engineer’s job shifts from writing code to designing environments, specifying intentions, and building feedback loops that enable AI agents to execute reliably. They call it “harness engineering.”

That is what we are building at WasteHero.

You will work on the core services that power CRM, billing, route optimisation, and container logistics. You will build new services, redesign data models, and solve real domain problems. And you will build and refine the engineering environment the architecture, the context systems, the feedback loops, the tooling that makes you and your team dramatically faster at all of it.

You work inside a domain-based squad alongside a Technical Product Owner, a Tech Lead, and frontend engineers. The squad owns its domain end-to-end.

Harness Engineering: What This Means

The most valuable engineers are no longer the ones who write the most code. They are the ones who build the systems that enable AI agents to write great code — reliably, at scale, and aligned with the architecture.

At WasteHero, this means:

You build product through AI agents. Your development environment is AI-native. Cursor, Claude, Copilot, or your own setup. But you have gone beyond autocomplete. You orchestrate multi-step agentic workflows: from spec to implementation to test to PR to review. Your output reflects it you ship more, at higher quality, than you could manually.

You design the environment agents work in. AI agents are only as good as the context, structure, and constraints they operate within. You organise the codebase, documentation, architecture, and domain knowledge so agents can navigate and build effectively. A well-structured context layer, indexed domain docs, and machine-readable architecture constraints are engineering output not overhead.

You enforce architecture through automation. Instead of relying on code review alone, you build custom linters, structural tests, and CI checks that enforce architectural invariants mechanically. Service boundaries, dependency rules, schema conventions — encoded so agents and humans both stay within guardrails. The constraints enable speed without decay.

You build feedback loops for agent validation. Agents need to observe the effect of their work. You build tooling that lets agents run the application, validate changes, inspect logs and metrics, and iterate — without human intervention for every cycle. The more observable and testable the environment, the more autonomous agents become.

You make the codebase agent-readable. Knowledge only exists for agents if it is in the repository. Slack discussions, decisions in people’s heads, context that is “obvious” none of it exists for the agent. You push context into the repo: architecture docs, domain models, decision logs, execution plans. The repository is the single source of truth for humans and AI.

You manage entropy. Agent-generated code introduces drift. Patterns replicate even when suboptimal. You build automated cleanup processes recurring agents that scan for deviations, outdated patterns, documentation drift and treat technical debt as continuous, not quarterly.

If this is how you already think about engineering, keep reading.

What You Walk Into

A platform in evolution. Production is a Django monolith. We are building with Python/FastAPI, event-driven messaging, and React. Both run in parallel.

Real domain complexity. 47 waste fractions, conditional pricing by zone, property hierarchies spanning thousands of addresses, route optimisation for hundreds of vehicles.

Multi-tenant, multi-country. Denmark, Finland, Norway, the Netherlands, the Middle East. Localisation, compliance, and data isolation are architectural concerns.

A distributed team. Developers across locations and time zones. Code is self-documenting, PRs have context, decisions are written down for humans and agents.

AI-native engineering culture in motion. Head of AI Engineering building the production pipeline. Agentic workflows already exist. You join and accelerate.

What You Will Build

Product Services

CRM & Customer Management Customer data models, agreements, case workflows, custom fields, cross-service queries, migration pipelines.

Products & Pricing Flexible pricing hierarchies, conditional logic, zone-based pricing, service levels.

Assets & Properties Hierarchical property models, container lifecycle, fleet tracking.

Route & Navigation Route optimisation, real-time event processing, driver mobile integration.

Platform DevOps, IAM, audit logging, deployment pipelines.

Engineering Environment & Agent Tooling

Context systems Codebase indexing, structured documentation, architecture docs, domain models making the repo the source of truth for AI agents.

Architecture enforcement Custom linters, structural tests, CI checks for service boundaries, dependency rules, conventions.

Agent feedback loops Tooling for agents to run the app, validate changes, inspect observability data, and iterate autonomously.

Development pipelines Automated PR analysis, test generation, migration scripting, deployment validation.

Entropy management Recurring cleanup agents, quality scoring, automated refactoring for pattern drift.

Tech Stack

• Backend: Python (FastAPI, Django), event-driven messaging (NATS)
• Frontend: React, TypeScript (you collaborate with, not write)
• Infrastructure: Kubernetes, cloud-native, CI/CD
• Data: PostgreSQL, migration pipelines, multi-tenant architecture
• AI Tooling: Agentic workflows, AI-powered issue creation, code analysis agents, context indexing
• Architecture: Microservices with hybrid migration from monolith

What We Expect

Engineering Skills

• 4+ years professional backend development with Python
• Strong relational database skills (PostgreSQL), data modelling, migrations
• Experience building APIs (REST, event-driven patterns)
• Comfortable with microservices service boundaries, data ownership, cross-service communication
• Cloud-native deployment (Kubernetes, Docker, CI/CD)
• Writes clean, testable, well-documented code

Agentic AI & Harness Engineering

• You already build software through AI-native workflows this is how you work today
• You have built agentic development pipelines automated code analysis, test generation, architecture enforcement, or similar
• You think about structuring code and documentation for agent readability
• You have side projects or experiments that demonstrate your passion for agentic AI engineering
• You stay current with the evolving AI development tool landscape and bring what you learn into your work

Domain Thinking

You understand why a pricing engine matters to a municipal finance team and why a 2-second loading time is unacceptable for a dashboard used 200 times a day. You think about the user, not just the implementation.

Nice to Have

• Experience with Django and FastAPI specifically
• Background in logistics, municipal software, utilities, or regulated industries
• Experience with platform migrations (monolith to microservices)
• Experience with event-driven architecture (NATS, Kafka, RabbitMQ)
• Familiarity with frontend (React, TypeScript)
• Scandinavian language skills are a plus

How We Evaluate

A technical conversation. A real architectural challenge. Trade-offs, service boundaries, data models and how you would make the codebase more agent-readable.

A code task. Practical, relevant, time-boxed. We assess quality, design thinking, edge cases, and how you structure work for agent effectiveness.

Show us your agentic workflow. The most important interview. Screen-share your environment. Walk us through how you build with AI. Show a pipeline, a tool, a workflow working, not theoretical.

Team fit. Code reviews, architecture disagreements, cross-timezone communication, pushing context into the repo.

What You Get

• You build product, and the engineering environment that agents build product in both are first-class work
• Hard domain problems route optimisation, complex pricing, multi-tenant architecture, platform migration
• An AI-native engineering culture: Head of AI Engineering, Principal Engineer, agentic workflows as standard practice
• Real engineering ownership your squad owns a domain end-to-end
• A mission that matters: critical infrastructure. Millions of collections. Real environmental impact.
• Series A timing: competitive salary plus equity. Early enough to shape everything.