System Architect

Fetcherr builds responsible AI that transforms market complexity into measurable profit growth. At the core of the company is the Market Model - a proprietary AI-powered model delivering accurate, granular demand predictions with 96% forecast accuracy and real-time decision intelligence for commercial teams. Built on a glass-box architecture, it uses market data - not personal data - with full transparency into logic and outcomes. First deployed in global aviation, the technology is industry-agnostic and scales across volatile markets. Fetcherr delivers a consistent average profit uplift of 7%, with corporate partners including Delta, Virgin Atlantic, WestJet, Viva, and Azul.

Fetcherr Labs is our new, founder-mode unit bringing that engine to the mid-market. Our agentic solution will be hosted inside the platforms of the world’s major technology and business software giants, the enterprise clouds, CRMs, and productivity suites our customers already live in, so it has to run natively inside each of these ecosystems and speak their language, not just one.

It’s a small, flat, deliberately senior team: no layers, no ceremony, high trust, and real ownership. We move at POC speed, ship, and let the results make the argument. If you want to sit in the room where the architecture is decided and then write the code that proves it, this is that room.

The role

We’re looking for a System Architect to own the technical foundation of the Labs product end to end, from the whiteboard to production on Azure. Working closely with our Chief AI Officer, you’ll translate complex research assumptions and decisioning methodologies into clean, self-service products. You will port the right pieces of Fetcherr’s engine into a lean new stack, make it integrate cleanly across the business environments our customers already run, and lead the coding yourself. This is a hands-on architect role, not an oversight role: you set the design and you’re in the codebase every day.

A core part of the mandate is a fully agentic SDLC, building the product with AI coding agents end to end, not just building an agentic product. We expect a small team to ship like a large one by making agent-driven development the default way we design, write, and review code. You’ll define how we do that.

What you’ll do

• Translate methodology into product. Partner with the Chief AI Officer to turn complex assumptions, math, and decisioning methodologies into clean, self-service products a customer can run without a data-science team.
• Own the architecture. Design a scalable, cloud-native system on Azure, covering services, data flow, model-serving and the end-to-end decision pipeline, and keep it coherent as it grows.
• Lead the coding. Set the standards, make the hard build-vs-buy calls, and write the core code yourself. You’re the technical center of gravity for the team. You will guide and work shoulder-to-shoulder with the other engineers through the architecture and the code, without managing them directly. Leadership here is by design and example, not by org chart.
• Stand up a fully agentic SDLC. Establish how we design, generate, review, and ship code with AI agents end to end: the tooling, guardrails and CI gates that let a small team punch far above its size.
• Stand up the environment. Establish a fresh, greenfield Azure environment for Labs on a Kubernetes-native, Everything-as-Code foundation: IaC (Terraform, Helm), GitOps (ArgoCD or similar) and CI/CD from day one. In the early days that means rolling up your sleeves on the platform groundwork (subscriptions, networking, environments), working hands-on alongside Microsoft’s teams to get us live.
• Run natively inside the giants’ ecosystems. Design the integration layer so our agentic solution is hosted within the major enterprise-cloud, CRM and productivity platforms, plugging into each one’s native agent and data surfaces so customers adopt it without leaving the tools they already use.
• Ship the POC end to end, then harden it toward a production-grade, self-service GA platform.
• Set the engineering culture. Define the bar for quality, observability, and cost-awareness for everyone who joins after you.

Who you are

• 10+ years in software engineering with vast, hands-on production experience. You have architected, shipped, and run large-scale cloud-native systems in the real world, and that scar tissue is what lets us move fast in the right direction and avoid expensive wrong turns.
• Hands-on and current: you architect and code. Strong in Python (our primary language; Go/Bash a plus) and comfortable owning a service from design to production.
• Kubernetes-native by instinct (declarative-first, controllers and operators, Docker) with real Everything-as-Code discipline: IaC (Terraform, Helm), GitOps (ArgoCD or similar), and a defined, CI-gated SDLC.
• Production-first: you design for reliability, observability, and recoverability, with clear SLOs, sound alerting and blameless postmortems, and you own what you ship.
• Real, hands-on Azure depth at production scale. Labs runs entirely on Azure and we are standing the environment up from zero, so this is a hard requirement, not a nice-to-have. You need to know Azure already rather than learn it here.
• Experience designing systems that run ML / data-science workloads in production (model serving, feature/data pipelines, inference at scale).
• A data-engineering and data-science foundation is a big plus. You are comfortable with data pipelines, feature engineering, and reasoning about data quality, and you can speak the language of the data scientists you’ll build for.
• Fluent with agentic development. You have driven real work through AI coding agents and have a point of view on running a fully agentic SDLC well and safely.
• A builder’s temperament: thrives with ambiguity, high ownership, and a flat team; makes decisions and moves.
• Fluent English for cross-team collaboration and technical documentation.

Nice to have

• Depth in Azure AI tooling (AI Foundry, Copilot, Fabric), plus a track record integrating across third-party business platforms (CRM, sales, productivity, data).
• Deep understanding of pricing systems or decision-support / decisioning systems is a strong plus (also: forecasting, optimization).
• Platform-engineering mindset, building secure, automated, self-service pathways for other engineers as internal customers.
• Track record taking a 0→1 product from POC to GA, including the messy middle.
• Experience standing up MLOps / LLMOps and pipeline orchestration (Airflow, Dagster, Kedro, Ray, Kubeflow).
• Policy-as-code and supply-chain/CI security (OPA/Conftest, Kyverno), plus SLO/error-budget and DORA-based delivery practice.

The stack you’ll work in

Python · Azure (greenfield, our only cloud) · Kubernetes · Docker · Everything-as-Code: Terraform, Helm, GitOps (ArgoCD) · CI/CD · observability & SLOs · orchestration (Airflow / Dagster / Ray) · a fully agentic SDLC. Greenfield, so you’ll help set the final choices.

Why this one is different

Most architect roles hand you a mandate and a maze of stakeholders. This one hands you a clean slate, a greenfield Azure foundation you’ll stand up yourself, a proven engine to draw from, and a team small enough that your decisions ship the same week. We’re building toward a system that runs on auto-pilot, and you will design the spine of it. If that’s the problem you want, let’s talk.