Tech Lead- Forward Deployed Engineering

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.