Engineering Manager

• Own Sprint Execution Across One To Two Teams: Run the planning cadence, prioritisation, and retros that make delivery predictable. Improve flow reliability, surface blockers early, and remove coordination drag. Sprint priorities are clear; the path to unblock is clear; the team always knows where things stand.
• Operate as Part of the Triad: Partner with the PM (discovery, prioritisation, transition) and Product Designer (UX, validation) so the three roles own delivery collectively. The triad shapes the product, builds it, ships it, and syncs the people — your lane is construction and production readiness, but the four jobs are shared.
• Own Team Output and Domain Health: Accountable for the output and health of the workstreams your teams own — not just velocity. Production readiness, monitoring, platform stability, technical debt posture, and on-call experience all sit with you.
• Develop the Engineers in Your Care: Own the performance, development, growth, and hiring of your direct reports. Hire well, manage performance clearly, give feedback that develops (not just corrects), and build a high-functioning team. This is the highest-leverage thing you'll do.
• Stay Hands-On Across the Stack: Contribute meaningful code across Elixir / Phoenix services and React / TypeScript surfaces — proof-of-concepts, performance work, hard bugs, architectural slices, AI-assisted experiments — to keep your technical judgement sharp and your credibility earned. Hands-on work is scoped inside a sprint as a deliberate capacity allocation, not a side project that competes with the team's mission. You won't out-code your senior engineers, and you shouldn't — but you should be able to pair on the hardest problem in either half of the stack.
• Lead Code Review and Technical Decisions: Give substantive code reviews on the work that matters — including AI-generated code. Understand the trade-offs, challenge decisions with reasoning, and earn engineering trust through the quality of your input, not the volume of it.
• Anticipate Risks and Define the Problem: Operate effectively in ambiguity — define the problem, not just the solution. Anticipate systemic risks (architecture, tooling, test coverage, technical debt, on-call load) and resolve them before they compound.
• Build Systems That Persist: Establish processes, review structures, and patterns that improve how the team works and outlast your direct involvement. Default to team-shaped review authority — explicit checkpoints, named reviewers, approval inside the team — not a hero-shaped model where you're the bottleneck.
• Communicate Up, Across, and Out: Translate technical strategy clearly to non-technical stakeholders. Manage up effectively — keep the CTO informed, flag risks early, bring problems with proposed resolutions. Politely correct external projections of a "delivery manager" role; redirect anything outside scope to CTO alignment.
• Use AI Deliberately Across the Team: Set norms for how the team uses coding agents, agentic prompting, and MCP-based tooling. Treat AI as a real capability multiplier, not a substitute for engineering judgement.

• 8+ Years in Engineering, with at Least 2–3 Years Leading Teams: You've managed engineers directly — running 1:1s, performance conversations, hiring, calibration — not just coordinated work.
• Hands-On Full-Stack Credibility: A track record of writing production code yourself in both a backend language (Elixir / Phoenix ideal — Ruby, Python, Node, or another typed functional / OO language acceptable if you can ramp on Elixir) and a modern frontend stack (React / TypeScript ideal). You don't need to be the deepest IC in the room, but you do need to be able to ship a non-trivial slice on either side of the stack and review the resulting code substantively.
• Production Systems Experience: Hands-on background in complex production systems (distributed, event-driven, real-time, or data-intensive). You've made the calls that matter on concurrency, consistency, observability, and failure modes — and you've been on-call for the consequences.
• Domain-Level Ownership Track Record: You've been accountable for the health and output of a workstream or team — including production reliability, on-call posture, and technical debt — not just sprint completion.
• The Triad Operating Model: Comfortable working alongside Product and Design as equal partners on delivery. Clear on where your lane starts and stops, and able to flex into adjacent ones without claiming them.
• Sprint and Delivery Discipline: Demonstrable experience improving planning cadence, flow, and predictability across multiple teams. You can articulate what good looks like and how you got a team there.
• People Development: A track record of hiring well, developing engineers (including into senior roles), and managing performance clearly when it matters. Comfortable having the hard conversation early rather than late.
• AI-Fluent Leadership: Practical, hands-on experience with coding agents and agentic tooling in your own work — enough to set credible norms for the team and challenge AI-generated work in review.
• Communication and Judgement: Clear, calibrated, and direct. Comfortable managing up and across; able to disagree well, update your view when the evidence does, and frame problems with proposed resolutions.

• Experience leading a domain that included on-call, incident response, or platform-stability accountability
• Exposure to multi-team or multi-domain leadership (especially where you've had to set priority bands rather than treat every domain as first-priority)
• Background in logistics, supply chain, or other operationally critical, integration-heavy domains
• Experience in scaling-stage environments where you set patterns rather than inherit them
• Direct commercial Elixir / Phoenix experience (the bulk of MOSAIC and TCMS sits here)
• Recent hands-on experience with AI-assisted coding workflows in your own delivery — beyond setting norms for the team

🏙️ A Great Place to Work (Literally): Enjoy in-person collaboration 4 days per week in our Sydney CBD office in the heart of the city — close to great food, coffee, and transport.

💡 Real Engineering, Real Impact: You'll work on meaningful product challenges with direct line of sight to operational users — concurrency, real-time events, data orchestration, and clear UI all matter here.

🧱 Shape What's Being Built: Our architecture is established but not rigid.

There's room to grow into bigger problems as you progress, and to influence patterns as you do.

🌏 Small Team, Big Autonomy: No bureaucracy.

Direct line to product, design, and leadership.

You get context, ownership, and visibility from day one.

🌱 Growth With Meaning: This is a place for builders who want to leave a mark on something real.

We use a published levels framework, so progression on craft, scope, and leadership is a real conversation — not a guessing game.