Talks

While constant change characterises software development, timeless engineering principles enable systems to evolve gracefully. Modern teams often focus on delivery while inconsistently applying fundamental design principles from the 1960s-70s that remain essential today.

This session makes foundational principles explicit, relevant, and practically applicable at every architectural layer. Rather than inventing new approaches, the real challenge involves consistently applying proven fundamentals across all system levels — from functions and classes to services and infrastructure.

Key Principles Covered:

• Abstraction
• Encapsulation
• Cohesion
• Loose Coupling

Design behind interfaces. Keep responsibilities narrow. Make dependencies replaceable.

As software engineers, it's easy to get lost in the excitement of implementing clever business logic: the algorithms, the workflows, the elegant domain models. But the success (or failure) of a service rarely hinges on its core logic alone. What really separates a fragile prototype from a resilient, scalable system is everything that happens around that logic: the invisible scaffolding that shapes how a service behaves, communicates, and recovers when things go wrong.

In this session I'll explore the often-overlooked aspects of building robust services. The decisions that make the difference between smooth operations and painful refactors months down the line. I'll unpack how thoughtful design choices early on can pay dividends in maintainability, observability, and security later. Whether you're building your first microservice or managing an ecosystem of services, you'll leave with practical ideas for designing services.

Key Takeaways:

• Why the non-domain aspects of a service are often what determine its long-term success
• How to think holistically about design, structure, and reliability
• Strategies for evolving your services without introducing chaos

Software engineering is hard, and leading a team as an engineer can be even harder. Many of us feel more comfortable writing code than working with people, and we often believe our value lies solely in our technical output. But when you step into team leading, the balance shifts: there are more people than code, and your value changes and, often, grows.

Over the last 25 years I was dropped into team leading several times without warning, but three and a half years ago I chose to do it deliberately. It still took more than a year before I realised I was only just beginning to understand what leading a software team really involves.

This revised and updated version of my talk - now expanded to better reflect the ideas in my book So You Think You Can Lead a Team? - shares the highs, lows, surprises, and lessons learned along the way. I can't promise a magic formula (I'm still learning every day), but I hope to help you avoid some of the mistakes I made and find your own path to becoming a better team lead.

Ever wanted to build a serverless function, but felt there was too much boilerplate to write before it gets interesting? In this talk, we'll walk through creating an AWS Lambda from scratch, using TypeScript, and show just how clean, fast, and repeatable deployment can be when using Terraform for infrastructure and GitHub Actions for deployment.

This practical demonstration will cover:

• Writing and packaging a simple TypeScript Lambda
• Defining and provisioning AWS infrastructure with Terraform
• Automating deployment with GitHub Actions
• Things I've learnt using Lambdas

And all in the space of an hour.

Whether you're new to AWS or just looking to try serverless, this talk will leave you knowing how to ship robust, serverless functions quickly and reliably, with everything under version control.

A session on using Amplitude for product management, covering analytics-driven decision making and practical approaches to understanding user behaviour.