Burnout in engineering teams is rarely caused by a single event. Instead, it’s the result of persistent, often overlooked management habits that quietly erode motivation, well-being, and performance. Here are 9 habits, why they matter, what happens if you ignore them, and actionable tips to build a healthier, more sustainable engineering culture.

Andrew Murphy

9 Management Habits Quietly Burning Out Your Best Engineers

AI is sexist, racist, and dangerous. And it's on us, the developers building it today, to fix that. This might be the most important work of your career, because the AI we create now will shape humanity for generations. And if this generation of developers doesn't step up?
This session focuses on building systems that don't harm people. We'll explore practical frameworks for ethical AI development, from compassionate design that protects the most vulnerable, to training out bias, implementing guardrails that actually work, and using AI agents to keep each other in check. No corporate BS, just real talk about the responsibility we carry and how to handle it.

You'll leave with:
-Actionable strategies to build responsible AI and more ethical AI systems
-Practical frameworks you can implement immediately
-A renewed sense of urgency about why this work matters so damn much


Sreyna Rath

AI: it's our responsibility

When building integrations between systems, we are tempted, sometimes, to jump straight into writing automation to pull data from one system and push it to another. However, this approach often overlooks potential pitfalls that can lead to inefficiency, business errors, and maintenance headaches.

In this session, we'll explore some of the common integration challenges and pitfalls, so that we are in a better position to build successful integrations that solve the right business needs.

Emad Alashi

Beyond the Code: Building Robust Integrations That Work

Pull request reviews are often the biggest bottleneck in software delivery, especially for distributed teams. What takes minutes to write can sit for days waiting for review, killing development velocity.

The open source world has solved this at scale. Major projects like Kubernetes, Rust, and React coordinate thousands of contributors with sophisticated review strategies that go far beyond traditional approaches.

This session explores proven techniques from leading OSS projects and how to adapt them for your teams: early design alignment, automated reviewer assignment, merge automation, cultural process shifts, velocity metrics, and modern workflow patterns.

You'll leave with practical strategies to eliminate review bottlenecks and measurably improve your team's delivery speed.

Pavel Oborin

Breaking the PR Review Bottleneck

We often treat code as a set of instructions for machines... but in reality, code is a conversation between developers across time. Every variable name, comment, function, and structure sends a message to whoever comes next: maybe that’s your teammate, a future hire, or even you six months later.

In this talk, we’ll explore how to write code that communicates clearly, empathetically, and effectively. We’ll dive into real-world examples of confusing vs. clean code, and examine how small improvements in naming, structure, and intent can drastically reduce bugs and onboarding pain.

You’ll walk away with a new lens for reading and writing code - not just as a tool for functionality, but as an act of collaboration.

Joel Gallagher

Code is a Conversation: What Are You Really Saying to the Next Developer?

Agile was supposed to fix everything. Faster delivery. Better collaboration. Happier customers. That’s what the consultants promised. That’s what the slide decks still say.

And yet… your product is still late. Still not what the customer asked for. Still somehow worse than last quarter.

Companies are still burning millions on "Agile transformations" that never end. Teams are drowning in meetings, sprint boards, and Jira tickets. Leadership still doesn’t know what’s going on, but now they have new words for it.

Scrum, Kanban, SAFe: They were meant to be tools, not religions. But somewhere along the way, companies stopped solving problems and started worshiping the process itself.

I’ve seen teams spend more time debating backlog grooming than improving the product. I’ve watched companies mistake motion for progress, convinced that sprinting fast and often enough will somehow fix their broken foundation.

If your organization is chaotic, misaligned or hiding behind process, Agile won’t save you. Customers don’t care what framework you use. They care if you solve their problems and too many teams forgot how to do that.

What You’ll Walk Away With...
... how to stop Agile from getting in the way of actual work.
... how to fix your product development process without another Agile coach.
... the questions leadership should ask before jumping on agile.
... how to tell if your Agile setup is making things better or just making things busier.

Marin Niehues

Congratulations, you are agile. Your product is still late.

An unarguable truth in software is that, at some point, failure is inevitable. Code breaks, servers crash, the power goes out – but building software that is designed to fail gracefully isn't always front-of-mind.

In this talk, we’ll walk through the process of designing of a resilient, real-world system; exploring how to handle failure at every layer. From redundancy and circuit breakers, to handling automated full or partial failover, we’ll cover practical techniques for building robust systems that keep working when things go wrong. As complexity grows, we’ll examine how architectural choices affect failure modes, and how to mitigate common tradeoffs like latency, data consistency, and degraded functionality.

We'll also explore what it takes to build reliability into team processes & mindset; identifying critical requirements and dependencies, to designing with user expectations in mind. Finally we’ll highlight the role of observability via health checks and OpenTelemetry, and automated tools for stress testing our systems, in helping teams make fast, informed decisions under pressure.

You will leave armed with practical tips, tools, and techniques to make sure your systems are designed to fail (gracefully)... and crucially recover!

Callum Whyte

Designed To Fail: Building Resilient Applications

We've all seen a tiny bug wreak havoc on our applications and when it comes to Infrastructure as Code (IaC), those consequences can be disastrous. We're talking about a git push that wipes out a production database, a misconfigured module that kills a service, or a state file that just takes a walk. We'll peel back the layers to understand not just what went wrong, but why, and how those moments can teach us to build more resilient systems.

Join me for a deep dive into the dark side of IaC. We'll skip the basics and go straight to the real-world horror stories. We'll uncover the anti-patterns that lead to these meltdowns and explore practical solutions—technical and process-driven—to save you from that dreaded late-night call serious regret, and if you’re me…some tears. If you love a good incident report and a safe space to share your own infrastructure horror stories, this talk is for you.

Kirsty McDonald

Dude where's my state file? Adventures with Infrastructure as Code


Forget chatbots - welcome to the world of AI agents, your new digital co-workers! In this hands-on workshop, we will dive into how to build smart, action-taking AI agents that don’t just generate text but get stuff done. Powered by large language models, these agents can plan trips, write code, respond to users, and even work together like a dream team of bots.

You will see how modern agents combine tools, memory, and goal-oriented thinking to handle real tasks just like a human assistant would (only faster and without coffee breaks).
We will explore practical design patterns and show their evolution through plenty of real-world examples—starting with simple use cases and building up to fun, advanced, and collaborative scenarios.

By the end, you will walk away with:

✅ A clear sense of how agents go beyond just prompts
✅ Practical design patterns to kickstart your own agentic builds
✅ Awareness of the "gotchas" to avoid in real-world deployments
✅ The confidence (and code) to start building your own autonomous AI sidekicks

Whether you are building the next-gen assistant or just want to supercharge your apps—this workshop will put you on the fast track to building intelligent, agent-driven solutions.

Rakesh Lakshminarayana

From Bots to Brains: Patterns for Building Intelligent AI Agents

Heard 'move fast and break things?' But what if what you're breaking is your team's trust, your community's momentum, or your own sanity?
This talk is a manifesto for slowing the hell down and actually building something that lasts. Whether it’s a developer community, an engineering guild, or just a group chat that actually doesn’t fizzle after 3 weeks, the same principles apply.
We’ll explore:
Why “shipping community” too fast burns everyone out

The difference between having followers and having a real community (hint: likes ≠ loyalty)

How to create a space where people feel safe enough to show up — and keep coming back

The art of designing rituals, not just events

How going slow actually accelerates outcomes like engagement, retention, and influence


If you want to build something meaningful, you need patience, curiosity, and a tiny bit of rebellion against the cult of urgency.

This isn’t just about community building — it’s about culture hacking, trust building, and doing it all without burning out. Go slow, build something, and watch it last longer than the latest hype cycle.

This talk is for anyone who believes that real value isn't measured in velocity, but in longevity.


Gretchen Scott

Go Slow and Build Something: Why Speed Kills (Your Community)

Can't afford a humanoid robot to grab a Coke while you chill on the couch? Yeah… same here.

But like every techy parent who refuses to let go of the dream, I rolled up my sleeves and built one myself, out of LEGO. Why? Because there are way too many bricks lying around the house thanks to my kids, and I just couldn't resist.

This isn't just a talk - it's a real-life, hands-on adventure through the worlds of robotics, AI, and pure parent-level determination. Join me as I go from random plastic chaos to a fully operational LEGO robot agent, powered by GPT, and held together by hope, determination, and coffee.

🤖 Agentic Brains
How we turned OpenAI models into robotic minds that can think, plan, and act - like tiny agents with LEGO diplomas.

🧠🛠 Teaching GPT to LEGO
We customized a large language model to speak LEGO - understanding motors, sensors, ports, and commands like a seasoned Spike Prime coach.

🧩 Goal-Based Multi-Agent Orchestration
Why stop at one brain? We built a whole team. Each agent has a role - like a robotic pit crew working together to get that Coke mission complete.

🔁 Closing the Feedback Loop
Never trust a robot (especially one made of plastic). We built a real-time monitoring loop so the robot always knows what it's doing, and we do too.

📱 Zero-to-Hero App Dev
We created a GenAI app that lets you talk to the robot in plain English - and actually watch it move. No command lines. No code. Just say the word.

Just to keep it real, I’ll be throwing in some fun behind-the-scenes moments too:
- Sprinting between my desktop and the robot table like a caffeinated relay race
- My son getting suspicious every time a random AI voice echoes from my study (the agent)
- That magical moment when everything finally worked

Whether you're a parent, maker, teacher, robotics fan, or just someone who loves the idea of talking to a LEGO robot, this session is for you. No hardcoding. No PhD. Just a love for tinkering - and maybe a cold Coke waiting at the end.

Come for the LEGO. Stay for the AI. Leave with the inspiration to build your own agentic robot (or at least get excited about it)!




Daniel Fang

Hey LEGO robot, Grab me a Coke!

Lots of the basic principals of writing code that your team will understand in the not-so-distant future, and that enable your team to 'play well with others' aren't so basic or universal after all.

In order to learn the basics of the right thing to do - I'm going to show a bunch of anti-examples (gleaned from things I've witnessed - or committed) to show how you can maximize the WTFs per line of code. We'll cover topics like enigmatic versioning, ineffective naming, version lack-of-control and using AI to do what it does best: add lots of lines of code!

By intentionally looking at real world ways that teams have made their code awful and unmaintainable, we're going to learn the basics of writing code that you're going to be able to maintain in the future.

Lachlan Kingsford

How To Write Awful Unmaintainable Code

Platform work is often invisible until it breaks. We don’t ship features to end users. We don’t own the pretty UI. But we build the foundations that make everything else possible. 

Platform product management is one of the most niche — and most misunderstood — roles in tech. In this talk, I’ll dive into what Platform PMs actually do, who they build for, and how they drive impact when their metrics are two layers removed.

Whether you're a product leader scaling infrastructure, an engineer partnering with platform teams, or a PM curious about internal tools, this session will offer a clearer view of the invisible scaffolding behind great products — and the people who manage it.

Baani Ahluwalia

Laura Schaufelberger

It takes a village: how internal platforms let companies build great products

Oh no! Your team is doing a fabulous job. You never have to have difficult conversations, everyone is getting their work done to a high standard and on time. The higher ups are super happy with you. No one on your team has failed in longer than you can remember! How could you let this happen and what can you do to fix it?

Failure is an important part of growing your team - both the individuals on it and the cohesiveness of the whole. Without it creative problem solving can stagnate, learning slows to a crawl, and the work you get done is less than it could have been. 

We’ll dive in to strategies for helping your team (including you!) feel comfortable with failure, as well as strategies for keeping YOUR boss happy when it happens. We’ll also explore low-stakes ways to introduce failure into your team, so you’re not taking down prod to prove a point. 

Amy Norris

Managing for Failure

Establishing a platform that serves the needs of your developers is a challenge for teams of all sizes. But with Generative AI tools like GitHub Copilot, surely this is now all easy, and all we need is a few prompts, right?

Well, no, not really. Your onboarding processes are probably poorly documented, the tools your developers use on a day-to-day basis vary wildly between teams, and the way your teams deploy to production vary from dated bash scripts to crossed fingers over beers on Friday. Hardly the solid context needed for generative AI to actually be helpful.

In this talk, we’ll explore how platform engineering and generative AI can work together to improve developer experience, if you get the foundations right. We’ll look at common organisational and cultural challenges that limit productivity, and how to start addressing them with simple, practical steps. From there, we’ll show how “everything-as-code” patterns and AI-assisted tooling can accelerate platform maturity and reduce friction across teams.

Whether you’re a platform engineer, developer, or tech leader, you’ll leave with a clearer view of how to build a platform that AI can actually help with, and how to make your developers happier in the process.

Will Velida

Platform Engineering in the age of Generative AI

Building real-time web applications often feels like trying to juggle flaming torches while riding a unicycle! But it doesn't have to be that way! Join me for a down-to-earth session where we'll unravel the process of creating a real-time Shopping List application using Blazor WebAssembly, SignalR, and Fluxor.

We'll start by setting up a .NET 10 ASP.NET WebAPI backend with Minimal APIs, ensuring our foundation is solid yet straightforward. Then, we'll sprinkle in SignalR to handle seamless, bidirectional communication, allowing our app to broadcast updates faster than you can say "Hello, World!" Finally, we'll integrate Fluxor for state management, keeping our application's state predictable and our sanity intact.

Through live coding and practical examples, we'll navigate common pitfalls and share tips that make managing real-time updates across multiple devices (and users) a breeze. Whether you're a seasoned pro or just dipping your toes into Blazor, there's something here for everyone.

By the end of this workshop, you'll have the knowledge to build responsive, scalable web applications that impress both users and fellow developers alike.

William Liebenberg

Real-Time Magic: Crafting Blazor WebAssembly Apps with SignalR and Fluxor (Workshop Edition)

Just like the code we write, our careers need refactoring. Technology never stands still. Frameworks rise and fall, cloud evolving at this very minute. AI is transforming how we build software, and something else will be next.

The skills that helped you get one job might not be enough for your next one. The challenge (and the opportunity) is learning how to adapt without burning out or feeling left behind.

In this talk, we’ll explore what it means to “refactor your career” so you can thrive no matter what the next tech wave is. Whether you’re looking for your first dev role or have been coding for decades, the principles are the same: embrace change, invest in timeless skills, and leverage emerging tools to your advantage.

The term refactoring was popularised in the 1990s to describe improving code without changing its behaviour. Small, thoughtful improvements keep the system healthy, and the same applies to our careers.

With so many technologies emerging constantly, the key isn’t to learn everything, but to stay open, curious, and adaptable. You’ll learn how newcomers can stand out by building solid problem-solving foundations, how mid-career developers can avoid stagnation by diversifying their skills, and how experienced developers can remain in demand by focusing on leadership, mentoring, and system-level thinking that no tech wave can replace you ever.

Treat your career as a codebase. Review, identify what to keep, what to improve, and what to rewrite. By treating your career like evolving software, you’ll be ready for today’s wave and whatever comes next.

Let’s explore, share, and learn together how to keep our developer careers adaptable, resilient, and in demand from first commit to the last pull request.

Randi Ratnayake

Refactoring Your Career: From First Commit to Last Pull Request

Two Boeing 737 MAX crashes killed 346 people, and cost Boeing over $20 billion (US). The root cause of both crashes wasn't just faulty software, it was a cultural blindspot. Boeing's aerospace engineering teams, dominated by a similar mindset that prioritised efficiency over safety concerns, dismissed documented warnings from pilots and regulators who saw the system differently. 

This isn't an isolated incident, billion-dollar failures can often be traced back to teams trapped in echo chambers, missing critical perspectives that could have prevented catastrophe.

This session reveals the hidden diversity crisis across organisations and teams. You'll discover why your most challenging colleague or team member might actually be your secret weapon, how to identify groupthink patterns, and practical strategies for building cognitively diverse teams that catch blindspots others miss.

Amanda Pitcher

The Billion Dollar Blindspot: What happens when everyone thinks alike

Most apps are designed for the sunny day. Users mistype, networks wobble, services time out, and people click the wrong button under pressure. This session gives you a field guide of twelve battle tested patterns that keep customers safe and calm when things go wrong. We cover undo everywhere, autosave with draft states, guarded destructive actions, resilient forms that never lose input, explainable errors that tell users what happened and what to do next, and recovery links that take people back to a safe point with one click.

We then move deeper into system aware product design. You will learn how to expose partial degradation instead of a blank spinner, how to design idempotent actions from the UI down so retries never double charge, how to surface long running work with receipts and progress that survive refresh, how to ship a rescue mode that disables risky integrations quickly, and how to write customer facing runbooks that support can use during incidents. Every pattern comes with trade offs, simple code sketches, and a checklist you can apply to a feature in a single sprint.

You will leave with a shared language for safety across product, design, and engineering, plus a printable worksheet to audit your app. The goal is simple. Fewer tickets, fewer late night pages, and users who feel looked after even when the internet misbehaves.

Renaldi Gondosubroto

The Safety First App: 12 product patterns that turn failures into recoveries

We've all been there: GitHub Copilot promises to be your coding companion, but instead feels more like that overeager intern who confidently writes brilliant code for the wrong problem. As AI-assisted development tools become ubiquitous, the industry narrative promises revolutionary productivity gains. Yet many practitioners find themselves playing an exhausting game of context whack-a-mole—constantly explaining, re-explaining, and fixing what their AI "partner" confidently got wrong.

Having spent considerable time wrestling with this gap between AI promises and reality, I've discovered that the real challenge isn't prompt engineering—it's context engineering. This talk explores why "vibe coding" is fundamentally broken and introduces the systematic discipline that separates magical AI experiences from expensive disappointments. Through the constraint-context matrix and real examples like the Breadcrumb Protocol, I'll demonstrate why human expertise in scaffolding, steering, and domain understanding isn't just relevant—it's the secret ingredient that makes AI actually work. You'll leave with practical strategies for engineering context systematically and a framework for building sustainable human-AI collaboration that leverages both your skills and the machine's capabilities.

Dasith Wijesiriwardena

Throw Away The Vibes: Context Engineering Is All You Need

You likely have a good pipeline that either runs tests, lints, or deployments for your project.

But when it comes to changing that pipeline, how sure are you that it works before taking those changes live?

In this talk, we'll explore why it doesn't have to be the case that "there's no devops for devops".

We'll give a quick run down of what pipelines are, and why they should be used, before we give an example where it can be hard to know whether making changes to a gitlab pipeline will fail, and why that can be the case.

Then, we'll showcase tools that can be used for testing, creating, and simulating pipelines, so you too can setup a system to always be sure that your pipeline changes won't cause any water damage.

Evan Kohilas

Who tests the testers? Making and testing pipelines

Disagreements are an inevitable part of working in teams, and knowing how to resolve them quickly and easily will let you spend less time arguing about code, and spend more time writing it instead.

In this talk, I'll share the lessons I've learned from working in open-source, on teams with flat management structures, no management structures, and teams that could be best described as a ragtag band of misfits.

I'll discuss how to bridge gaps in rank, age, language (programming and spoken), experience and mindset to let you isolate and solve the real issues.

Agenda

All Agendas

Sponsors