Reliable systems and applied AI, shipped to production.

Loewen Tech is a senior engineering consultancy for software development, system design, observability, and applied AI. We build, ship, and advise on production systems for teams that need to move quickly without compromising what they already depend on.

// logs.tail --follow tailing
events / sec 12.4k
warn · 1m 3
err · 1m 0
// 01. services

Four practices. One bar.

Hands-on engagements across architecture, AI, and operations, from two-week diagnostics to multi-month embedded engineering.

// 01

Software Development

Production code, built and shipped end to end. Greenfield services, hands-on rewrites, and integration work, delivered alongside your team or as a standalone engagement.

build · ship · refactor · integrate Discuss
// 02

System Design & Architecture

Distributed systems, observability, and scale. Services designed to be operated and debugged by engineers who didn't write them.

distributed · observability · scale Discuss
// 03

Applied AI & Integrations

LLM integrations, RAG, agent systems, and evals. AI features that behave predictably in production, not just in demos.

llm · rag · agents · evals Discuss
// 04

Fractional & Advisory

Senior engineering on retainer. Software development guidance, architecture review, on-call support, and strategic input, without adding headcount.

advisory · review · leadership Discuss
// 02. about

Built for engineering teams.

Loewen Tech is an engineering consultancy focused on building and shipping production-grade software: hands-on development, distributed systems and observability, and the AI integrations that increasingly sit on top of them.

We work as builders and as advisors. Some teams need code shipped; some need guidance on what to build, how to architect it, and how to keep it running. Both come from the same discipline: careful design, honest measurement, and the rigor to deliver work that holds up in production.

// 03. how we work

A predictable shape for unpredictable problems.

Every engagement is different; the structure is consistent. Four stages, clear artifacts, realistic timelines.

// 01

Discovery

Read the code, map the system, talk to the team. Understand goals and constraints before proposing a direction.

// 02

Design

Architecture, integration plan, evaluation strategy. Written decisions with tradeoffs named explicitly, so teams can review and push back.

// 03

Implementation

Hands-on code, paired with your team. Observability in from day one. Ship behind flags, measure, iterate.

// 04

Handoff

Documentation, dashboards, and runbooks your team will actually use. No undocumented dependencies left behind.

// 04. contact

Let's talk. hello@loewentech.dev

Working on something difficult? A system that needs to stay up, an AI feature that needs to ship? We'd like to hear about it.

hello@loewentech.dev Book on Calendly