Beat the rush and join us early for complimentary barista-made coffee and breakfast.

AI isn't just changing how code gets written, it's rewriting team structures, delivery processes and what engineering leadership actually looks like. This keynote is a strategic conversation for leaders wrestling with the real question: How do you actually use AI to ship faster without breaking everything that makes your organisation work? 

‍

We’ll cover: 

• How team shapes, roles, and hiring are changing as AI absorbs junior and middle-tier work. 
• What's actually working in AI-Accelerated delivery, beyond demos and dashboards
• The leadership decisions that separates organisations using AI as a tool into a multiplier

‍

AI collapsed the cost of writing code, generating test cases, and grooming work. Delivery cycles didn't shorten to match.

This session examines why every step in the pipeline became generative except one. Getting realistic data to test against stayed extractive.

‍

Key Takeaways:

• Why AI-assisted development sped up your build but not your test cycle. The constraint on test data was never developer effort, so tooling that reduces effort doesn't touch it.
• How to tell fidelity apart from scenario coverage. Production data scores well on the first and, for a feature that doesn't exist yet, near zero on the second.
• Why the security-versus-realism tradeoff comes from where you source the data, not from the data itself. Once you stop copying production, the question changes rather than disappears, no longer "how much realism can I safely keep?" but "how do I build data that behaves like the real thing?"

AI agents are now writing code, deploying systems, and making real production decisions. But when things go wrong, model drift, data leaks, or outages, most organisations can’t answer three simple questions: Did we catch it? Who’s responsible? How do we prevent it next time?

This panel brings together engineering, platform, and security leaders tackling a new reality: AI is breaking both observability and accountability.

‍

We’ll cover:

• Why traditional monitoring misses AI failures  and what’s replacing it
• Where accountability sits when AI makes decisions
• How to design audit trails, guardrails, and escalation paths for AI systems
• Lessons from early AI incidents what was caught, what wasn’t, and who took responsibility
• What regulators, boards, and customers now expect

‍

‍

Vulnerabilities are now found faster than your team can patch them, and the software supply chain has become an active malware delivery channel. For engineering leaders this is showing up as an unbounded queue of security work you didn't plan for, against a release process designed in a different time.

You can't triage your way out, and you can't hire your way out either. The way out is delivery engineering - the ability to rebuild and ship safely, on demand, without drama.
This session covers what that takes, why the instinctive answers fail, and how teams that get it right end up shipping features faster too.

In this innovative session, attendees will be faced with a series of scenarios that they may face in their roles. Attendees will discuss the possible courses of action with their peers to consider the ramifications of each option before logging their own course of action.

Results will be tallied and analysed by our session facilitator and results will impact the way the group moves through the activity.

Will we collectively choose the right course of action?

The Cloud DevOps model promised scalability and flexibility. Many enterprises ended up with endless and too-frequent manual governance processes that led to Cloud Infrastructure sprawl, inconsistent setups, and rising operational overhead.

At the same time, modern applications and AI workloads are adding new pressure, pushing further the need for a scalable and production-ready Cloud-Native ecosystem developers can use, at their required velocity.

This session explores how value delivery at speed is achieved through platform engineering, abstracted standardisation, and pervasive automation, while keeping costs in check:

• Accelerate value while reducing cloud infrastructure sprawl and restoring consistency.
• How to balance flexibility, cost, and control as workloads scale.

BlueApp, Blue Pearl’s high-volume consultant-matching platform, faced growing challenges on Java 11, including deprecated APIs, dependency incompatibilities, and increasing maintenance overhead.

Upgrading to Java 25 (LTS) was critical for security, compliance, and performance but traditionally would have required weeks of engineering effort. In this session, we’ll walk through how we completed the full uplift in just 3 days with zero post-deployment defects using IBM Bob. You’ll gain practical insights in improving developer productivity and creating a repeatable framework for upgrading legacy applications at scale.

Attendees will learn:

• How to accelerate Java modernisation with AI-assisted upgrades, refactoring, and dependency management
• How to reduce modernisation risk using system insights, governance workflows, and integrated security scanning
• How to modernise CI/CD, testing, and deployment workflows while improving delivery speed, cost, and stability

Platform engineering has moved from a trend to a strategic bet. The organisations winning with AI, managing cloud spend, and scaling delivery all have one thing in common: they've treated their internal platform as a product. 

This panel brings together engineering leaders who've built platforms their teams actually use, and made the business case to fund them.

‍

What we’ll cover:

• Why platform-first is no longer optional for any engineering organisation above a certain size
• How to structure, staff, and fund platform teams as a strategic capability
• The hard parts: adoption, governance, and avoiding internal tooling sprawl
• Where data, environments, and developer experience intersect in a modern platform

‍

‍

‍

Select a topic of discussion and engage in an interactive roundtable discussion with a group of your like-minded peers.

Put your knowledge to the test in this fast-paced quiz covering real-world trivia, key concepts, and emerging trends. Compete for bragging rights - and a travel voucher - as the top scorer takes the crown.

‍

The industry is converging on a multi agent, multi model world. The best model changes every couple of months, it makes no economic sense to call a frontier model to classify a ticket, and unique workflows increasingly need custom models. So teams end up running many models across many harnesses (Claude Code, Copilot, Cursor, custom).

That makes trust the defining challenge. Harnesses ship their own guardrails, but each one only governs its own traffic. Agents can route around rails they can't see, and those rails can shift whenever a model vendor ships an update. Safety shouldn't depend on the agent making the right call, or on someone else's release schedule.

We'll cover:

• What's pushing engineering teams toward running many models across many harnesses, and why this convenience quietly turns into a trust problem
• The case for a meta runtime: one layer below every harness, governing execution, tool calls, credentials, scoped permissions and token spend, no matter the model or harness
• How a fine-grained, default-deny policy lets agents run at full speed inside the lines, with the audit trail written automatically

We format code to make it easier for people to read, but that formatting also uses LLM tokens. Research from Xiaoning Du found that removing spaces, indentation and line breaks reduced input tokens by an average of 24.5%, without affecting code completion accuracy.

The research also found that models could generate more compact code, reducing output length by up to 36.1% without losing accuracy. This session looks at what this could mean for teams running AI coding tools at scale, and how they can reduce token costs while keeping code readable for developers.

Key takeaways:

• Formatting has a cost. Spaces, indentation and line breaks can account for a significant amount of LLM token usage.
• Models don't need code formatted like humans do. Compact code can deliver the same results while using fewer tokens.
• You don't have to sacrifice readability. Formatting can be removed before sending code to the model and restored afterwards, keeping it readable for developers.

How we solved context switching: turning a chaotic 10-minute scramble for incident dashboards into a 10-second automated response using AI agents.

Large organisations are cutting roles. Graduate pipelines are shrinking. AI is absorbing work that used to take teams of engineers. This is the uncomfortable conversation the industry isn't having openly yet. 

This interactive think tank puts these issues to the room. Participants vote live on the scenarios shaping the next five years of Australian engineering, explore the results together, and vote again as perspectives shift.

• What roles disappear, what roles emerge, and what stays the same?
• How should we train, hire, and develop engineers in an AI-native world?
• Is the junior engineer dead? What's the entry pathway now?
• What's the Australian engineering profession's responsibility to its own people?
• Where does this leave engineering leadership in 2030?

‍

Unwind with your peers for a couple of drinks on us!