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
- Remote (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 Cursor." We've reshaped how teams compose, how delivery works, and how software gets shipped around the reality that AI has changed the math. Claude Code, MCP servers, spec-driven workflows, and durable agent judgment encoded as reusable skills are how we work day to day.
Sovereignty as capability is one of the directions we're actively moving in: helping clients own their stacks, data, and agentic control points rather than rent them. It's a direction of travel on many of our engagements, not the whole story.
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. You're in rooms with clients, designers, and product managers every week, not in a silo writing architecture docs.
You don't just ship features, though. 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, test harnesses, codebase rules, reusable patterns. If it's a pattern the team will use twenty times, you're the one who shapes it so the twentieth time is faster than the first.
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.
Some of our engagements lean into platform engineering and client-owned infrastructure (Kubernetes, declarative control planes, GitOps-driven delivery); others sit entirely at the application layer. You don't need platform depth to join. We care more that you're an excellent technical lead, curious about where our substrate is going, and willing to pick up the specifics when an engagement calls for them.
What You'll Do
- 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. Shape architecture broadly, not enforcing one stack
- Build the meta-systems that scale the team: CLAUDE.md files, agent rules, Claude Code skills, MCP servers, reusable testing scaffolds, internal CLIs, and project templates. Contribute patterns back to our shared agentic template and knowledge repo so the next project starts further ahead
- Harden the agentic tooling your team depends on: configuration helpers, scaffolds, tests, and harnesses that verify agent outputs and keep AI-generated work within guardrails. If an agent can produce bad code on your project, the harness you wrote catches it before it ships
- Review PRs for system coherence, not just correctness. Catch the ripple effects before they ship
- Make the blueprint-vs-codebase call. Know when to build disposable (to iterate) and when to build integrated (to scale). Speed of iteration is a first-class concern, not a compromise
- Partner with designers and product managers on trade-offs. You represent the engineering lane at the same table, not downstream of it
- Pair with APEs while architecture is still forming, coach them on architectural thinking, and hand off cleanly once the pattern is established. Surface trade-offs to the AMD with enough clarity that they can decide quickly
- Spot bottlenecks early and build the unblocker before anyone asks
- Push back in client conversations when the ask doesn't match the goal, including advocating for client ownership over vendor lock-in when that serves them better
- Reach into the platform layer when the engagement calls for it (Kubernetes, declarative infrastructure, GitOps), without making it the center of the role
How We Work
- Cross-functional from day one. Every delivery team ships with designers, product managers, engineers, and agile practitioners working together. You won't be translating between silos or inheriting decisions downstream. 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. Headquartered in Toronto, working wherever trust and output can flow.
- 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
- Systems thinker. You see how pieces fit, where changes ripple, what breaks six months from now
- Taste. You know good from great. UI, architecture, prose, API design; you hold a standard
- Agentic-native. Claude Code (or equivalent) is a primary tool, not a novelty. You encode team judgment in rules and skills, not just one-off prompts
- 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
- Bias toward the meta-system. You'd rather invest two days in a pattern that saves five days of repeated work than ship the first instance fast
Qualifications
Required
- 5+ years of production software experience, with architectural ownership on at least two non-trivial systems
- Strong application-layer proficiency in TypeScript and React (or a clear path to fluency from a comparable modern stack)
- 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
- Demonstrated agentic fluency: daily use of Claude Code, Cursor, or equivalent, with real examples of agent configuration (rules, skills, MCP servers, subagents)
- Comfort in client-facing technical conversations. You can hold the room without taking it over
- Track record of making others faster: mentorship, internal tooling, pattern libraries, OSS contributions, or written practice
Bonus
None of these are required. Most ASEs pick them up on the job when an engagement needs them; equivalents welcome because we care about the shape of the experience more than the specific tool.
- Kubernetes or comparable container orchestration (Nomad, ECS, Docker Swarm). You've deployed and debugged real workloads, not just read about them
- Platform-engineering experience: declarative infrastructure (Terraform, Pulumi, Crossplane, Helm) and GitOps (Flux, Argo, or similar)
- Experience with long-running workflow orchestration (Temporal, Airflow, or custom) and event-driven architectures (NATS, Kafka, RedPanda, etc.)
- A systems or backend language alongside TypeScript. Go is especially useful on our platform tooling, but Rust, Elixir, Python, Java, or similar all signal the breadth we value
- Event-sourced architectures or CQRS patterns
- Experience running production on bare metal or non-hyperscale clouds
- OSS contributions to agent tooling or platform frameworks; MCP server development; Claude Code skill authorship
- Public writing on platform engineering, sovereignty, or agentic practice
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. 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 & Infrastructure
On engagements where it fits, we lean into Kubernetes, declarative control planes (Crossplane and similar), GitOps (Flux, Argo), long-running workflow orchestration (Temporal), event streaming (NATS, RedPanda), identity platforms (Ory, Keycloak), and OpenTelemetry + Grafana for observability.
Deployment Targets
Client-owned infrastructure when that serves the client (including Canadian data residency), hyperscalers when context demands it.
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.
- Technical leadership on real products. This is a delivery role, not an advisory seat. You ship into production systems real enterprise customers use.
- 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, grounded in a consistent direction of travel. 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 bias is toward 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.
What we look for
We evaluate 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.