Position overview

Matrix is building its own product capability in house to extend our reach beyond the classroom. We are assembling a small team of product builders who ship the software our students, parents and teachers actually use. This high-priority role is a foundational engineering seat in that new team as we grow.

You’ll report to our Head of Technology and work closely with our Head of Digital Product and the rest of the Product Building team. You will build and ship Next.js, TypeScript and Node applications with PostgreSQL, integrating Salesforce and Snowflake through a shared business API layer. Claude Code is the primary development tool and we expect real agentic development fluency on day one. You will define and operate a modern, AI-first development lifecycle, architecting fully automated CI/CD pipelines, preview environments, automated validation, and safety guardrails that allow autonomous agents to execute end-to-end development safely and rapidly.

The part that makes this role different from a standard engineering seat is the product side. You will not be handed a finished specification. You will be in the room when the problem is framed, when the storymap is built, and when we decide what to cut. We want an engineer who has views on what should be built, argues about scope, and can tell the difference between a hard problem and an expensive one. You do not need to want to be a product manager. You do need to be comfortable when the conversation is about students and parents rather than code.

Two honest notes. The brief will move, because we are working out this way of building as we go. And prototypes can be rough, but production code is tested and reviewed. Speed comes from the pipeline, not from skipping the standards.

Key responsibilities

1. Build and ship product in a small team

[Initial priority]

• Build and ship Next.js and Node applications, from server components and API routes through to production, using Claude Code and Cursor as your primary tools
• Join the storymap and prototype work at the start of a build rather than picking up a finished spec, and push back on scope when the engineering cost does not match the outcome
• Integrate with Salesforce,  Snowflake and and other Enterprise systems through the shared business API layer so logic is written once and used by every app
• Own the review loop on agent output: find the logic errors and security gaps, and decide what to keep, what to rewrite, and what to send back with better context
• Ship at least one customer-facing release in your first quarter that real students, parents or teachers use

2. Define and scale the agentic development lifecycle

[Initial priority]

• Design and optimise an end-to-end agentic workflow where requirements translate into passing tests, generated code, preview environments, and production releases at high velocity
• Build the automated testing, branch management, and CI/CD automation necessary for AI agents to safely generate PRs and deploy without manual friction, retaining human review at strategic gates
• Instrument full observability across agent execution, automated testing, and production deployment to monitor performance, debug failures, and continuously optimize cycle times
• Apply the OWASP Top 10 for LLM Applications to any agent-facing surface, and build the guardrails before a student sees it

3. Shape what gets built and prove it worked

[Subsequent priority]

• Instrument the outcome metrics for what you ship, including first week engagement, activities per week and conversion, and build the dashboard the team reviews
• Bring the feasibility view into product decisions early: what is cheap, what is expensive, and what looks small but is a trap
• Contribute reusable components and shared patterns so the other builders do not re-solve the same integration twice

What we’re looking for

Experience and qualifications

• You have shipped Next.js and TypeScript in production, client and server rendered, with real users behind it
• 5+ years building production software, including at least 12 months where AI agents did meaningful parts of the work
• Strong with Node, REST API design, and integrating third-party SaaS systems that do not behave the way the documentation claims
• Comfortable with SQL and Postgres at a production level
• You have designed and scaled modern, AI-first or highly automated CI/CD and agentic development lifecycles, not just worked inside traditional pipelines
• You can describe a product decision you changed because of something you knew about the code

AI fluency and builder mindset

This matters to us. You don’t need an AI research background, but you do need to be shipping real work with agentic tools already and keen to go deeper every week.

• You use Claude Code, Cursor or a comparable tool daily and have opinions about what makes a prompt useful and what makes one wasteful
• You can tell the difference between code that looks right and code that is right, and you don’t ship one for the other
• You are forming a view on where agentic engineering is heading and what it means for how a small team should be shaped
• You experiment, share what you find, and ship small things without waiting for a playbook

Skills and attributes

• Genuine product instincts. You care what the thing does for a student or a parent, not only whether it builds
• Comfortable in discovery: sitting with a teacher, reading funnel data, arguing about what to cut
• High ownership. You track your own work, flag blockers early, and treat a broken build as your problem
• Pragmatic about tooling. You reach for the simplest thing that ships safely, deterministic or agentic
• Clear written communication, because most of the context you give an agent is written, and the same clarity matters in a pull request or a note to the Academic team
• Honest about what you don’t know yet

Nice-to-have

• Exposure to Salesforce or Snowflake data models
• Familiarity with MCP as a pattern for connecting agents to tools
• Observability tooling for tracing agent runs, such as LangSmith or Langfuse
• Background in education technology or student-facing consumer products

Success measures

Success in the first 90 days

• A customer-facing feature or substantial internal application shipped to production using the agentic workflow, with documented examples of where agent output was kept, changed and rejected
• An evaluation of the agentic engineering lifecycle and automated delivery path shared with the Head of Technology, with a roadmap to accelerate build-to-deploy velocity, and the first iteration live
• You run production deployments on your own, including monitoring, troubleshooting and rollback
• You have contributed to at least one storymap and changed the scope of a build based on what you found there

Success in 6 to 12 months

• Multiple products shipped, including one customer-facing product you owned from storymap through to outcome measurement
• Agentic development lifecycle and delivery automation established such that feature delivery cycles are measured in hours, supported by robust automated safety checks and high developer leverage
• Outcome dashboards live for what you shipped, with baselines set and at least one iteration shipped against what they showed
• Reusable components and patterns that the other product builders use by default