Tech Lead- Forward Deployed Engineering

Fastloop; Vancouver; On-site; CAD 120,000 - 180,000; Full time

Job summary

Fastloop seeks an AI-forward engineer who covers a broad technical surface, delivering work through an AI-native loop. You own end-to-end delivery and design patterns that scale via reusable agents and libraries.

You will run diagnostics, install AI|OS, shape the engineering practice, train client teams, and ensure secure, compliant systems in production. This is a hands-on builder role with ownership and ambiguity tolerance.

Qualifications

• Real, hands-on experience with AI coding harnesses and tooling.
• Experience building or operating APIs and MCP servers.
• Strong background in automation, integration, and AI in production.
• Secure coding practices and security-first instinct.
• DevOps and infrastructure as code to enable repeatable shipping.
• Track record building real business systems, not isolated features.
• Broad tech capability anchored by depth in at least one area.

Responsibilities

• Own diagnostic work and connect client systems; manage access via MCP.
• Own AI|OS installation: architecture, memory/model decisions, orchestration extensions.
• Set engineering practices and train client technical teams to operate independently.

Skills

AI coding harnesses

APIs & MCP servers

Automation & AI in production

Secure coding

DevOps & IaC

Building business systems

Broad technology surface

Tools

Claude Code

Cursor

Windsurf

GitHub Copilot

MCP servers

Job description

This role blends a few influences: the high-leverage AI-native builder, the broad-spectrum technologist who covers wide ground through AI, and the ownership and ship-it instincts of a forward deployed engineer. None of those alone captures it. The thread through all of them is leverage: a small number of strong engineers delivering far beyond their headcount.

Why this role exists

We're building a small team of engineers who deliver what a much larger team would, by wielding AI across the full surface of the work instead of staffing a seat for every task. These aren't executors waiting on tickets. They're builders who treat each piece of work as a chance to make the next piece faster, cheaper, and better.

What you'll be part of

Fastloop helps companies accelerate becoming AI-native, without leaving their people behind. Most companies have bought the licences and run the pilots, but haven't changed how they work. We change that by installing an AI|OS (the memory, model and orchestration layers that encode how a company actually works), embedding the AI SDLC loop, and developing the people who will own it. We work with clients, not to them or for them. Our leaders work alongside client teams on real work, then step back on purpose as their people take over.

As Tech Lead- FDE, you're the technology leader on those engagements, working alongside a delivery leader and a change leader. You'll:

• Run the diagnostic and connect the client's systems, giving agents governed access through MCP.
• Own the AI|OS installation: its architecture, memory and model decisions, and extending the orchestration layer to fit each client.
• Set the engineering practice and train client technical teams until they can run it without us.

We're also client zero: we run the same loop on our own delivery before we take it to anyone else. When you solve something twice, it goes into the shared registry, so every client after starts further ahead. That's the machine.

The role in one sentence

You are an AI-forward engineer who covers a broad technical surface by wielding AI, and who runs every piece of work through a loop that compounds the team's capability over time.

What you'll own

• Taste and judgment. You can tell genuinely good work from plausible slop, and you hold the line on differentiated, fit-for-this-situation output instead of shipping the model's default. This is the scarce skill now that execution is cheap.
• Build with agents. You pair with coding agents on production software and review far more than you type. Your judgment on what ships is the bar.
• Integration and automation. You architect and build the connections between systems and remove manual steps wherever they exist. APIs and MCP servers are daily tools for you, not new concepts.
• Business systems, not just features. You build the systems the organization runs on, end to end, and you stay with them until they actually work in production.
• DevOps and infrastructure as code. You stand up and maintain the pipelines, environments, and IaC that let agents and humans ship safely and repeatedly.
• Security and compliance by default. Secure coding is an instinct, not a checklist. You also own the AI-specific attack surface: prompt injection, agent permissions and sandboxing, and the lethal trifecta of private data, untrusted content, and external communication (an MCP server wired into .mcp.json can run with full local privileges).
• AI quality. You instrument and evaluate AI behavior so quality is measured, not assumed.
• Build for humans and agents. You design systems and interfaces that agents operate, not just people. Increasingly the user is another agent, and the work has to be legible to both.
• Build and grow the library. You create, maintain, and grow the team's library of agents, skills, and patterns, and you harvest every project for what belongs in it. This is core to the role, not housekeeping. The library is the asset that compounds: each new agent, skill, or pattern makes the next project faster and cheaper. Agents and skills rot without an owner, so keeping them alive is part of the work, not overhead.

How you work: the compounding loop

The thing that separates this role from a traditional engineer using AI is that you build the machine, not just the output. The work you ship is evidence the machine ran. The patterns, skills, and tooling you sharpen are the real product of a good week.

• Start from golden paths. Compose against existing patterns and improve them. Reinventing a working pattern taxes everyone who reuses your work later.
• Contribute back continuously. A pattern you sharpen gets PR'd to the shared library that week, not held until the project closes. If it isn't worth a PR this week, it isn't worth keeping.
• Defend machine-maintenance time. A protected slice of every cycle (roughly 20%) goes to hardening prompts, extending skills, documenting decisions, and refining the harness. That's the mechanism that makes the other 80% compound.
• Commit to the AI-native way. This is how the work gets done here, not a side experiment running next to the old way. The toolset has a short half-life, so staying current with new model and harness capabilities is expected, not optional.

If "never solve the same problem manually twice" is already how you think, you'll fit.

What you bring

• Real, hands-on experience with AI coding harnesses: Claude Code, Cursor, Windsurf, GitHub Copilot, or equivalents. You've shipped with them, not just demoed them.
• You've built or operated APIs and MCP servers yourself.
• Strong background in automation, integration, and AI in production.
• Secure coding practices and a security-first instinct, especially around sensitive data.
• DevOps and infrastructure as code: CI/CD, environments, deployment, and the IaC to make it repeatable.
• A track record of building real business systems, not just isolated features.
• Range. You're a "mushroom-shaped" technologist: a broad cap of capability you cover confidently through AI, anchored by a deep specialty.

The specialty (your stalk)

You carry at least one area of genuine depth and stay sharp in it while operating broadly. Examples: a specific cloud and its IaC, data engineering, security and compliance engineering, platform and reliability, or full-stack product.

How you operate

• Ownership. You own a problem end to end, including the parts that aren't your fault.
• Comfort with ambiguity. You take a vague brief and produce a clear plan.
• Bias to ship. You get something working in the real environment early and iterate, rather than polishing in isolation.
• Product sense. You pattern-match across projects and feed what you learn back into the work.

What this is not

• Not a seat where you wait for fully specified tickets and execute them one at a time.
• Not a role where AI is a side tool you reach for occasionally.
• Not a place to rebuild from scratch what the shared library already solves.
• Not a developer role. You're a builder, and you need to be OK shipping work where you wrote zero lines of code yourself.