The Foundry platform is a federation of six squads - Sizer, DES, GCM, Emulator, Layout Designer and Applied AI - each owning their mission autonomously. The Platform / Integration Principal is the technical authority that holds this federation together: you own the cross-squad contracts, define the API boundaries that allow squads to evolve independently, and set the architecture that will scale the platform from an internal tool to a customer-facing product used by System Integrators. You operate at the highest individual-contributor level in Foundry - no engineering management, pure technical leadership - and your decisions have multi-year consequences. You are the go-to authority on platform architecture, will represent Foundry in external technical discussions with SI partners, and will set the engineering standard the rest of the organisation aspires to.
What You'll Do
- Own the cross-squad integration contracts - Define and maintain the interface contracts between squads: the DES↔Sizer reverse-flow (cycle times back into sizing), the DES→Emulator handoff (simulation state to virtual commissioning), and the SI-partner API platform; ensure contracts are versioned, tested and backward-compatible.
- Architect the Layout Service - Design and own the Layout Service: the shared representation of a warehouse design that the Layout Designer, DES and Emulator all read from and write to; define its schema, versioning model and access patterns.
- Define the SI-partner API platform - Design the external REST/gRPC API that System Integrators (Dematic, Sistemo, Envista) use to submit solutioning requests, receive results and embed Foundry capabilities in their own tools. Set the technical-debt and scalability strategy - Identify the current architectural constraints that will limit growth; propose and sequence remediation with minimal disruption to squad delivery.
- Lead architecture review - Chair the cross-squad architecture review process; approve or challenge architectural decisions that cross squad boundaries; author and maintain the Architecture Decision Record (ADR) library.
- Represent Foundry in external technical discussions - Participate in technical discovery sessions with SI partners; understand their integration needs and translate them into platform requirements.
- Mentor Principal/Staff and Staff engineers - Raise the technical ceiling of the organisation through code review, design critique, pairing and written guidance; be the person engineers go to for the hardest problems.
- Drive hiring quality - Participate in technical interviews; define what principal-level means in Foundry; help calibrate the bar.
Minimum (required) Qualifications
- 15+ years professional software engineering.
- Deep experience designing platform APIs at scale: REST and gRPC; multi-tenant, versioned, backward-compatible.
- Experience architecting distributed systems used by multiple consuming teams.
- Track record of cross-team architectural leadership: ADRs, design reviews, technical standards.
- Experience with B2B SaaS, partner/SI API platforms or developer-facing products.
- Strong written communication: can produce an ADR that a squad understands and can implement from.
- Mentoring experience at Staff and Principal level.
Preferred Qualifications
- Experience with warehouse automation, robotics, industrial IoT or AMR fleet management platforms.
- Familiarity with Rust + Erlang interoperability - the Foundry simulation and control stacks.
- Experience designing event-driven integration architectures (event sourcing, CQRS, saga patterns).
- Background in building integration platforms consumed by enterprise SI / ISV partners.
- Experience with developer experience (DX) design: SDKs, API documentation, sandbox environments.
- Familiarity with multi-agent AI architectures interacting with backend platform APIs.
- Prior Principal Engineer or Distinguished Engineer scope at a technology company.
Technical Qualifications
- We expect you to be proficient in or quickly learn the following. Senior roles (Band E+) are expected to be experts; Band C/D roles are expected to have working knowledge.
- Platform API: REST (OpenAPI 3.x) and gRPC (Protobuf) at scale; API versioning strategies (URL, header, content-type); backward-compatibility guarantees and sunset policies.
- Integration patterns: event-driven architecture (Kafka / Pub/Sub); saga pattern for multi-squad transactions; outbox pattern for reliable event publishing; circuit breakers and bulkheads.
- Data architecture: schema evolution (Avro / Protobuf compatibility rules); distributed schema registry; the Layout Service data model (graph-based warehouse representation).
- Languages: Java or Go (primary for platform services); Rust reading ability; Python for tooling.
- Infrastructure: GCP (GKE, Cloud Spanner for global consistency, Pub/Sub, IAM); Terraform; Backstage as the service catalog and API portal.
- Security: OAuth 2.0 / OIDC for partner authentication; fine-grained RBAC for multi-tenant access; API key lifecycle management; secrets management via GCP Secret Manager.
- Observability: distributed tracing across squad boundaries (OpenTelemetry); SLO definition and error-budget tracking; Grafana dashboards for the integration layer; OneUptime for on-call.
- Developer experience: OpenAPI-generated SDKs; Postman / API sandbox; developer-portal integration via Backstage.
- Testing: contract tests (Pact or custom); chaos engineering (fault injection in the integration layer); load testing for SI partner API endpoints.
How We Work
- You report to the Senior Director and operate across all squads.
- You do not manage people - you lead through technical authority and the quality of your written and spoken reasoning. You are the primary decision-maker for decisions that cross squad boundaries (one-way-door calls in our decision framework) and you chair the architecture review process.
- You are expected to be available for cross-squad unblocking quickly and to produce written ADRs for every significant architectural decision.
