About the Role

This is the hands-on engineering role at the heart of our forward-deployed capability. Working directly to the Lead Forward Deployed Engineering Business Partner, the Forward Deployed Engineer (FDE) turns strategy and stakeholder problems into working, production-grade software — built and operated at a world-class standard.

Where the Lead sets direction and owns the business relationships, you are the builder who makes it real. You will stand up the agentic architecture, development pipelines, and security controls that let us ship AI-native solutions quickly and safely — the foundations the whole team builds on.

This is a deeply technical, execution-first role for an engineer who takes pride in craft: clean systems, reliable pipelines, and security built in from the start. It supports the same three group ambitions the Lead is accountable for — Best place to study, Great place to work, and Cradle to cradle (the alumni lifecycle) — by delivering the technology behind them.

What You'll Do

Build the Agentic Foundations

• Design agentic architecture. Build and set up the architecture for AI agents and agentic workflows — orchestration, tool and model integration, memory and context, and the guardrails that keep them reliable in production.
• Stand up development pipelines. Create and maintain the CI/CD and delivery pipelines — build, test, evaluation, and deployment — that let the team ship AI-native software quickly and repeatably.
• Engineer evaluation and observability. Put in place the testing, agent-evaluation, logging, and monitoring that prove a solution works and keep it working after it ships.

Make Security and Safety Non-negotiable

• Build in security checks. Embed security across the lifecycle — secrets management, dependency and code scanning, access controls, and automated checks in the pipeline (a DevSecOps approach), not a step bolted on at the end.
• Protect learner and staff data. Apply data-privacy and student-data governance controls in everything you build, and design agentic systems with safe, auditable human-in-the-loop boundaries.

Execute at a World-class Level

• Ship production-grade code. Turn problems handed down from the Lead — often ambiguous — into working software that real users on campus depend on, end-to-end across data, integration, and application layers.
• Move fast with AI. Work in an AI-native, agentic development lifecycle: orchestrate AI coding agents and tools to compress the path from problem to production, while owning the quality of what ships.
• Deliver across the three pillars. Build the tools behind the learner and parent experience, the staff and educator experience, and the alumni lifecycle — one deployed solution at a time.

Support the Lead & the Team

• Turn direction into delivery. Take scoping and priorities from the Lead FDE Business Partner and run them to done, flagging risks and trade-offs early.
• Generalise what you build. Fold reusable components back into shared group platforms so solutions compound instead of becoming one-offs.
• Document and hand over. Leave clean, well-documented systems that others can operate, extend, and trust.

Who You Are

Must Have

• A strong, hands-on software engineer who ships production code end-to-end and cares about doing it to a world-class standard.
• Practical experience building agentic architecture and AI-orchestrated systems — agent orchestration, tool/model integration, and the patterns that make them reliable.
• Solid engineering foundations: setting up CI/CD and development pipelines, version control, testing, and cloud deployment.
• A security-first mindset — comfortable building in security checks (secrets, scanning, access control) as part of the pipeline, not after it.
• Fluent use of AI coding agents and tools in your own day-to-day development, with judgment on where a human must stay in the loop.
• A bias for execution: you finish things, to a high bar, and take ownership of quality.

Nice to Have

• Experience with DevSecOps tooling, infrastructure-as-code, and observability / monitoring stacks.
• Applied experience evaluating and hardening LLM / agentic systems for production (evals, guardrails, red-teaming).
• Familiarity with data privacy and student-data governance in a regulated or education setting.
• Experience in education, EdTech, or another mission-driven, multi-stakeholder environment.

Technical Experience We're Looking For

The examples below are illustrative of the depth we're after across four areas. We don't expect every tool — strength in most, and the ability to learn the rest, matters more than an exact match. (Swap the named tools for the group's actual stack before publishing.)

Cloud

• Building and operating workloads on a major cloud (AWS, Azure, or Google Cloud) — compute, storage, networking, and identity/access (IAM).
• Containerised and serverless deployment (e.g. Docker, Kubernetes or a managed container service, and functions).
• Practical grasp of cloud cost, scaling, reliability, and secure network configuration.

Data

• Designing and working with databases — relational (e.g. PostgreSQL, MySQL) and NoSQL — with sound data modelling.
• Building data pipelines / ETL and integrating across systems and APIs.
• Handling sensitive learner and staff data securely; working with vector stores and embeddings for AI retrieval (RAG).

Development

• Strong coding in one or more modern languages (e.g. Python, TypeScript / JavaScript, Go).
• API design and integration (REST / GraphQL), backend services, and web or app frontends as needed.
• Git-based version control, automated testing, code review, and clean engineering practices.
• Building with AI coding agents and orchestration frameworks as part of everyday development.

Deployment

• Setting up and automating CI/CD pipelines (e.g. GitHub Actions, GitLab CI, or similar).
• Infrastructure-as-code and environment/configuration management (e.g. Terraform).
• Monitoring, logging, observability, and basic incident response.
• Secure release practices — automated security and dependency scanning built into the pipeline.

How We'll Measure Success

• First 90 days. You have set up the core development pipeline and security checks, shipped your first production solution alongside the Lead, and established the baseline agentic architecture others can build on.
• First year. Reliable, secure pipelines and reusable agentic components are in place; multiple deployed solutions are running in production across the three pillars with strong quality and safety records.
• Ongoing. Delivery velocity paired with reliability and security — measured by adopted, well-operated solutions, not lines of code.