Small teams. High leverage. Frontier work.
Rangle is engineers, designers, and product leaders rebuilding what software consulting looks like in the agentic era. We ship work traditional consultancies can't keep up with and enterprise teams can't pull off alone. If you're looking for somewhere to practice on the frontier, not just keep up with it, keep reading.
Open roles
Pick a role on the left to see the detail and apply. We read every application that comes in.
- Location
- Hybrid, remote-first (Greater Toronto Area, Canada)
- Timezone(s)
- ET
About Rangle
Rangle is a Toronto-based consultancy building quality software for enterprise clients since 2013. We're a cross-functional team of designers, product managers, and engineers working shoulder-to-shoulder on production systems for clients ranging from startups to some of the largest enterprises in pharma, finance, and retail.
We run agentic development as a first-class practice. Not "we use AI tools," not "we're experimenting with Claude." We're reshaping how teams compose, how delivery works, and how software gets shipped around the reality that AI has changed the math. We build orchestration that runs agents across a whole project, custom tooling that encodes our team's judgment, and custom products when our team needs them. Restraint, curiosity, and ambition in equal parts.
Sovereignty as capability. We help clients own what their AI runs on: the infrastructure, the data, the agents and workflows that do the work, and the freedom to switch models. We run on that same kind of stack ourselves. Our own platform is built on Kubernetes from open-source components, and it hosts our internal tools and the products we sell. For a Canadian or European client, that ownership answers the question of where their data lives and whose laws reach it.
About this Role
This is a hands-on technical leadership role. You'll work on live client projects, lead the engineering side of a cross-functional team, and ship production code alongside review, pairing, and architectural work. Most of what we build is customer-facing: products real people and businesses use directly, where the interface, the API, and the data behind it all have to hold up under real use.
You also build the meta-systems that let the rest of the team ship confidently: CLAUDE.md files, agent rules, Claude Code skills, MCP servers, evals, test harnesses, and reusable patterns. If an agent can produce bad code on your project, the harness you wrote catches it before it ships.
You work alongside an Agentic Managing Director (AMD) who owns the client relationship and Agentic Product Engineers (APEs) who move fast within your scaffolding. Your job is to make both of them faster, and to represent the engineering lane when the team is making trade-offs with design, product, and the client together.
Engagements often reach into platform work (Kubernetes, declarative infrastructure, GitOps). You don't need that background to join; we teach it when an engagement calls for it.
What a Week Looks Like
You work directly with the client as one team, often starting from little more than a framing of the goals, and you turn that into solutions built on sound architecture and good coding practice. Claude does much of the typing, and you're the one who notices where its output is subtly wrong, where the harness needs adjusting, and what the team should learn from it. You know how the features of the application fit together, so when a client asks on a call how something works, you can answer, and you raise it quickly when our approach is off.
What You'll Do
- Define the solution before the build. Turn a written problem into a sound solution the team can build from. Name the risks and rabbit holes early and decide what stays out
- Ship production code on real client projects alongside the team. This is not a purely advisory seat
- Architect the systems your team is building: component patterns, data models, API shape, testing strategy, delivery pipeline. Review PRs for system coherence, not just correctness
- Build and harden the agentic tooling your team depends on: rules, skills, MCP servers, Claude Code plugins, mods, and hooks, evals, and the harnesses that verify agent output and keep AI-generated work within guardrails. That includes durable agent workers that run on our own infrastructure, picking up work in the background and reporting back for review. Contribute patterns back to our shared template and knowledge repo so the next project starts further ahead
- Make the blueprint-vs-codebase call. Know when to build disposable (to iterate) and when to build integrated (to scale)
- Pair with APEs while architecture is still forming, coach them on architectural thinking, and hand off cleanly once the pattern is established
- Partner with designers, product managers, and clients on trade-offs. Push back when the ask doesn't match the goal, including advocating for client ownership over vendor lock-in when that serves them better
How We Work
- Cross-functional from day one. Every delivery team ships with designers, product managers, engineers, and agile practitioners working together. You'll be in the room where trade-offs get made.
- Lean agile, low process. One- or two-week sprints, regular demos, continuous client feedback. We value working software and direct conversations over documents and ceremonies.
- Project rotation and variety. Nobody stays on a single engagement forever. Roughly six to eight months on average, with a two-year ceiling. You'll work across industries, codebases, and client contexts rather than calcifying on one stack.
- Remote-first, hybrid. The team is based in the Toronto area and works remotely most of the time, meeting in person when it helps. Expect more in-person time as the team grows.
- Client-facing, not client-owned. You'll talk to clients regularly alongside a project lead, but you won't carry the commercial weight of the engagement on your own.
Qualities That Will Help You Thrive
- Taste. You know good from great. UI, architecture, prose, API design; you hold a standard
- Low ego, high standards. You multiply the team. You'd rather ship a teammate's PR than your own if it moves the project further
- Client-ready. You can sit in a room with a VP and explain a trade-off without dumbing it down or geeking out (unless that's what the audience needs to hear)
Qualifications
Required
- 5+ years of production software across several products or teams, with architectural ownership on at least two non-trivial systems
- Customer-facing products in production. You've built interfaces real users depend on, in TypeScript and React (or a clear path from a comparable stack), and owned the systems behind them
- Deep experience with data. You've worked across multiple database types (relational, document, KV, time-series, search, vector, etc.) and understand how the choice of data model shapes the system. Schema design, migrations, indexing, and performance are second nature regardless of the engine
- Deploying and operating backend systems in production. You've taken services from "runs on my machine" to "runs reliably for real users." Observability, failure modes, deploys, rollbacks, incident response. You've lived in the loop, not just consumed a managed service that hid it from you
- Built with agents, not just used them. You've designed an eval loop, shipped an agent that runs without someone watching, and can talk through the cost, latency, and failure trade-offs of its tool calls. Daily use of Claude Code or equivalent, with rules, skills, or MCP servers you wrote, is the starting point. You understand how Claude Code (or your harness) loads context: which CLAUDE.md files, rules, skills, and tool definitions land in the window, when, and what that costs.
- Skeptical of agent output. You review what an agent produces as critically as a teammate's PR, and you notice when it's confidently wrong
- Solution definition. Given a written problem, you shape a sound solution, name the risks early (rate limits, stale data, what happens when a dependency fails), and say plainly what you'd leave out
Bonus
None of these are required. Equivalents are welcome; we care about the shape of the experience more than the specific tool.
- Platform experience: container orchestration (Kubernetes or similar), declarative infrastructure (Terraform, Pulumi, Crossplane, Helm), or GitOps (Flux, Argo)
- Long-running workflow orchestration (Temporal, Airflow, or custom) and event-driven architectures (NATS, Kafka, RedPanda, etc.)
- A backend language alongside TypeScript, such as Go, Rust, Elixir, Python, or Java
- Agent tooling beyond the defaults: Claude Code plugins or hooks you've written, work in other harnesses (OpenCode, Pi, or your own), or agents that run as durable background workers
- OSS contributions to agent tooling; MCP server development; Claude Code skill authorship
- Public writing on agentic practice or engineering craft
Technologies We Use and Teach
We're pragmatic about stacks: the right tool for the context. You don't need to know all of these on day one; we teach what you don't.
Agentic Layer
Claude Code, MCP, and the Claude Agent SDK are daily tools, and we extend Claude Code with our own plugins, mods, and hooks. We use other harnesses where they fit, and we run durable agent workers on our own infrastructure: Temporal-backed workers that clone a repo, run an agent headless, and post results back for a person to review. We invest heavily in durable team judgment, encoded as skills, rules, subagents, and reusable patterns across our projects.
Application Layer
TypeScript, React, and the frameworks that fit the project. Tailwind and shadcn/ui for UI, TanStack Query for client state, Vitest and Playwright for tests, Biome for tooling. PostgreSQL as our default relational database. Other backend languages are welcome: Go, Rust, Python, and Elixir all show up in our work.
Platform & Deployment
Client-owned infrastructure when that serves the client (including Canadian data residency), hyperscalers when context demands it. Where an engagement fits, we use Kubernetes, GitOps, Temporal, and OpenTelemetry.
Why You'll Love Working at Rangle
- AI-native by default. Claude Code and agent orchestration aren't side experiments here; they're how you ship. You use them daily, and you build the patterns the rest of the team picks up.
- Products people use. You ship customer-facing software for enterprise clients, into production, with real users on the other end.
- Flight time, not seniority theater. We track reps and capability, not titles. Structured coaching moves strong ASEs toward AMD in ~18 months when the growth is real.
- Meta-system leverage. The internal tools, rules, and patterns you build flow across projects. A skill you write for one client unblocks three more.
- Small, high-trust teams. You know your colleagues and they know you. Accountability is earned, not performed.
- Client exposure without commercial weight. You're in the architecture conversations without carrying the P&L of the AMD.
- Frontier technology, production discipline. We use the newest stuff. No vibes-only demos.
Don't see the right role? We're always interested in strong candidates; pick the closest match and tell us about yourself in the cover letter.
What we're building
We run agentic development as a first-class practice. Not "we use AI tools." Not "we're experimenting with Cursor." We've reshaped how teams compose, how delivery works, and how software gets shipped around the reality that AI has changed the math.
Concretely, that looks like:
- Small integrated teams, not staffing pools. A typical engagement is 3–5 people owning an outcome end-to-end, not a line of developers handed tickets.
- AI-native from the first line of code. Claude Code, MCP servers, spec-driven development, agent orchestration. We use the tools our clients are trying to figure out.
- Real platforms, not just apps. Postgres with RLS, Kubernetes via Kilter, event-sourcing where it fits, design systems that outlive the engagement. Clients own what we build for them.
- Sovereignty as substrate. More of our clients need to own their software, their data, their models, their tooling. We help them do it.
We're pragmatic about stacks: the right tool for the context. We care about stack fluency, not stack loyalty.
Platform & Infrastructure
Container orchestration, declarative control planes, GitOps-driven delivery, long-running workflow orchestration, event streaming, identity, and observability. A solid relational database underneath. Specific tools rotate by engagement; the architecture principles don't.
Application Layer
A modern TypeScript and React foundation, paired with whichever libraries and frameworks fit the project. We favor type safety, strict tooling, and patterns that travel across engagements.
Agentic Layer
We're implementation-agnostic at the agentic layer. Claude Code is our daily driver today; the tools shift as the frontier does. What travels across projects is the durable team judgment we encode as skills, rules, subagents, and reusable patterns.
Deployment Targets
Client-owned infrastructure when that serves the client (including Canadian data residency), hyperscalers when context demands it. Our default is stacks clients can own, operate, and evolve.
How we work
We organize every engagement around a consistent core team: three roles working together end-to-end, not seniority bands.
Agentic Managing Director (AMD)
Client-facing, owns the engagement and the outcome. Builds trust, navigates ambiguity, drives value creation.
Agentic Systems Engineer (ASE)
The architecture layer. Front-end, data, infrastructure, design systems. Builds the meta-systems that let the rest of the team move fast.
Agentic Product Engineer (APE)
Ships inside the scaffolding ASEs build. Moves fast, grows toward ASE or AMD over time.
Alongside the triad, Design, Product, and Delivery sit as supporting roles: specialist expertise that joins the core team where the engagement needs it.
Design
Taste, pattern, aesthetic direction. Shapes how the team's work looks, feels, and holds together across a single engagement and across the design systems we leave clients with.
Product
Client problem depth, business value sense, trade-off judgment. Partners with the AMD to shape what gets built and why it matters, not a translation layer between business and engineering.
Delivery
Execution discipline, risk navigation, launch readiness. On our largest engagements, partners with the AMD to make sure complex, multi-stakeholder programs actually ship on time and on scope.
Moving between roles takes reps. Our internal model is 400 hours of flight time (roughly four months of real engagement work) to move from a classical developer to a fluent agentic one. We coach you through it, but you fly the hours.
Beyond flight time, we run katas: protected weekly time for deliberate practice against a diagnosed gap, with a coach who has watched your work and can name what to push on. AI compressed the incidental learning that used to come from typing code and reading senior PR feedback. Katas are the deliberate replacement, not a supplement — reading, reps, and feedback against a real surface.
We're small enough that the people you meet on day one are the people making the decisions. Culture here is a village, not a train station: trust, safety, accountability, doors left unlocked. We know each other. You'll be known.
Rangle principles
Find the right thing, build it right, keep improving it.
Show working software, not documents about it.
It's done when it runs and the client accepts it.
Let agents run only as far as your checks reach.
Code is cheap. Judgment is what we sell.
Validation is everything. Only build against a real problem.
Write down what you learn so the next team starts ahead.
You grow by enabling others to do more.
Say what's true, plainly, including what you don't know.
Work agentically by default, on every project.
What we look for
We look at every candidate across three dimensions, in this order.
Character first. We care most about people who own outcomes rather than diagnose problems from the sidelines, who hold themselves to a high internal bar without waiting for external pressure, and who make the teams around them better. Character is the hardest thing to develop after hire, so it's the first thing we screen for.
Context second. In the agentic era, AI compresses raw technical work. The gap between a good and great hire shows up in judgment: do they understand what should be built, not just what was asked for? Can they read a room? Can they hold their ground with a stakeholder when the pressure is on?
Craft third. Table stakes, but shape-shifting. We care less about accumulated expertise in any one stack than about how fast you build mental models in unfamiliar territory. Our people rotate across clients and industries. Deep domain knowledge can become a trap; investigation instinct matters more.
Across all three we run four cross-cutting lenses.
Taste
Good vs great.
Talent
Raw ceiling.
Tempo
Pace.
Tenacity
Push through.
If you already work in an agentic style (systematic, spec-first, can articulate why a workflow works and not just which tools you use), you'll be at home here.
What we're not
We're not a body shop. We don't sell seats, hours, or bodies-to-tickets. If you want a large team, a well-defined scope, and someone to hand you work each sprint, we're not the shop.
We're not Accenture-with-AI. We're not adding a Claude license to the same old delivery model. We've rebuilt the model.
We're not a soft landing. The bar is high. Character first, but craft is real, and the work is real. If you're looking for an easy ride, this isn't it.
If those three descriptions are what pushed you out of your last job, keep reading.
The basics
We cover what you'd expect: health and dental from day one, flexible hours, remote work, RRSP matching, a wellness budget, a professional growth budget, and accessibility support throughout the recruitment process.
What we don't do is make the basics the story. They're table stakes. The story is the work and the people.
Interview FAQs
Accessibility statement
Rangle is committed to meeting the accessibility needs of those with disabilities throughout our recruitment process. We believe in dignity, independence, integration, and equal opportunity for candidates of all abilities who want to be a part of our team of Ranglers.