Modern browsers give us powerful tools for layout, animation, state, storage and more - the kinds of things we once had to reach for JavaScript libraries and frameworks to achieve. This session makes the case for treating the browser as an ally, rather than an enemy, and shows how leaning into its native capabilities can unlock simpler, faster and more resilient ways to build.

Frontend starts with a single “happy-path” mockup, but real apps must handle many dimensions—internationalization, accessibility, varying devices, performance constraints, and data complexity.

In this talk, we map the evolutionary path of frontend system design: from static pages, to components, shared state, caching, normalization, performance optimization, and beyond. Learn to locate your project on this journey and discover the next essential system concept to embrace.

An introduction to Backend for Frontend pattern and how we are trying to move to a better architecture using the same at Prezzee. The talk explains about the common problem that many organisations face when trying to move from monoliths to micro-services and how having BFFs could be helpful. I also talk about when not to use BFFs and can give a brief overview and demo of how we might implement it in Google Cloud.

Zero load time - even on spotty or no WiFi?

Zero API keys - LLMs in-browser, offline, private?

Zero app store - no cut to Apple or Google?

All are possible on the web today!

Powerful APIs such as Service Worker, Cache, IndexedDB, OPFS, webGPU and more are shrouded in misconception. We'll dig into their history, enabling exceptional UX along the way - and peer into the future.

To stay ahead, focus on providing an excellent customer experience. Remember, deploying code is just a technical task while releasing a new feature is a business process. Big releases can be risky, so use feature flags to limit any potential issues and ensure smoother releases.

In this talk, you’ll discover how we used feature flags in real-life situations, such as gradually releasing stock portfolios linked to brokers to thousands of users. You will learn how we applied feature flags to manage limits on those portfolios incrementally and safely. Hear about over a decade-long experience using feature flags spanning multiple companies and tools.

Adopting a feature flag mindset is key to improving customer experiences and boosting developer confidence. You’ll learn how to release features step-by-step: first to your team, then to the whole company, and after that, starting with just 1% of customers and gradually expanding to all customers. Join this session to understand how to safely test major features on production with almost no customer impact while keeping developers (yourself) happy.

Recursion often feels complex to engineers, but once it clicks, it opens up an entirely new way of solving problems.

This talk will start with a brief explanation of recursion including how it works under the hood in JavaScript and how to avoid stack overflow issues. From there, we will go through real-world examples by comparing iterative and recursive approaches and demonstrate how recursion can help cleaner and more readable code.

We will also see examples where recursion is the more suitable or even necessary approach.

Text inputs, checkboxes, radio buttons, sliders… Form controls have been part of the web since the beginning, but styling them can still feel like a battle.

If you’ve spent time struggling to figure out countless lines of CSS to make them look right, or rebuilt native elements from scratch because they weren’t customizable enough, you’re not alone.

In this session, we’ll explore why HTML form controls have been so hard to style — and introduce upcoming improvements that will make them easier to customize, using only the power of CSS.

You’ll also get a peek at how form controls have evolved, and how the new enhancements fit into the broader web ecosystem. If you’ve ever struggled with form controls, this talk will give you practical insight and a glimpse of what’s next.

Scrolling has come a long way since the concept originated in ancient Egypt. In this talk, we’ll blast through the evolution of scrollytelling — from JavaScript hacks to modern, declarative CSS magic. You’ll learn how scroll-timeline, view-timeline, and scroll-state queries unlock rich, interactive storytelling with minimal CSS and no scripting.

Geometry has always been the silent architect of art, design, and technology — from ancient Greek thinkers to the work of Newton.

In this talk, we’ll trace a surprising lineage of ideas, from proportions and perspective to spirals and symmetry, and see how they still shape the way we design and code for the web today.

You’ll leave with a new appreciation for the invisible mathematics behind creativity — and maybe even the urge to explore it yourself.

As engineers, it is hard (and arguably unwise) to trust "magic". What then should we do when our industry is flooded with "magical" new tools that promise to change the game?

The best way to see through a magic trick is to learn to do it yourself!

Based on the seminal blog post by Thorsten Ball from Amp, "How to Build an Agent, or: The Emperor Has No Clothes", this talk will dispel the illusion of magic surrounding agent-powered code editors like Amp, Claude Code, Copilot, Cursor, Windsurf, and Zed. Together, we will build our own coding agent in only ~400 lines of not-very-exciting JavaScript, and use it to complete some realistic coding tasks.

Armed with this clear understanding of how coding agents work under the hood, you will be better able to reason about how and when to use them in your own work.

AI agents are already connecting to frontend development workflows through Model Context Protocol, and the results are impressive. From React component generation to Figma-to-code pipelines, there's a growing ecosystem of MCP servers that frontend developers can plug into today. I've been exploring what's actually working in practice - which integrations deliver real value, what patterns are emerging across successful MCP servers, and where the biggest opportunities still lie.

I'll demo some of the most compelling examples, show you how to evaluate and integrate existing MCP tools into your workflow, and share what I've learned about building frontend-focused MCP integrations that developers actually want to use.

Generative AI is great at producing text — but what happens when it can actually do things? This talk explores the shift from AI as a conversational partner to AI as an active participant in real-world workflows.

We’ll look at how to connect AI systems to external tools and APIs using the Model Context Protocol (MCP). Instead of stopping at answers, AI can now execute file operations, manage digital assets, analyse images, and automate tasks that normally require human intervention. The result is a move from “chatting with AI” to “working with AI.”

Through practical examples, you’ll see how to:

• Extend AI beyond text into action-oriented workflows.
• Safely connect AI models to existing developer tools and services.
• Combine structured function calls with unstructured conversation.

Build AI-powered assistants that handle files, images, and APIs as part of a single seamless interaction.

This session isn’t about abstract futures — it’s about what you can build today. Whether you’re a developer, architect, or product builder, you’ll leave with a clear understanding of how to bridge the gap between natural language input and real-world execution.

AI that acts changes the role it plays: from passive responder to proactive teammate. Come see what happens when AI stops talking — and starts doing.

With power of the browser, identity and authentication landscape on the web is rapidly evolving.

Passkey introduces a simple and phishing resistant authentication.

FedCM introduces streamlined, browser mediated identity federation.

Digital Credential introduces trusted identity verification.

This session walks through the latest identity and authentication APIs you should care.

It’s commonly understood that automated accessibility testing tools can find around 20-30% of accessibility issues, but what does this actually mean in practice? What are the other 70-80% of issues they are missing, and why?

Beau takes a closer look at these tools using specific examples, demonstrating the types of accessibility issues automated testing tools won't find, and why that is the case.

If you or your organisation have considered using an automated accessibility testing tool, it is essential to understand how these tools work and identify issues - and even more importantly, the ways they don't work - to ensure they are not just providing a false sense of accessibility.

Note: This is a loose description, I'm working on the details and not sure if it's suitable while it covers some general concepts with documentation etc, a chunk of it does focus on specific tools (e.g. Figma, Figma Code Connect and the Figma MCP server)

The designer/engineer handoff is notoriously challenging. Communication gaps, mismatched terminology, and working in different environments often lead to friction and misinterpretation.

This talk explores how documentation, tools, and workflows can evolve into a common vocabulary designers and engineers can rely on. We’ll discuss tips for writing guidelines and examine tools like Figma Code Connect and the Figma MCP Server, which can ensure consistency from design files to production code.

What happens to design systems when automation becomes part of the workflow? As someone who's spent years contributing to open source systems, I've watched how new tools are changing how we think about design systems, components, patterns, and documentation. I have seen how AI has sped up the need for open source to be based on design systems.

In this talk I’ll explore why open design systems provide the strongest foundation for these new workflows, and how transparent, community-driven approaches give us the flexibility to adapt and evolve. You'll walk away with practical insights about building on open foundations, what implementation challenges to expect, and how to start experimenting within your own design system work.

What if your next customer isn’t human? In a world increasingly run by AI, machines are rapidly becoming independent economic actors, making buying decisions without human intervention.

In her provocative talk, "Machines Are Customers Too," Katja Forbes challenges businesses to radically rethink their approach to customer experience. She unveils how traditional customer journeys, trust-building, and engagement strategies must evolve to accommodate AI-driven agents and autonomous systems as genuine customers. Leveraging her award-winning expertise in CX innovation, Katja delivers a compelling vision of the near future: one where the customer is code, and loyalty is algorithmic.

This bold session isn’t just speculative. Katja provides actionable frameworks and a clear roadmap, empowering leaders to adapt, innovate, and harness this shift as a powerful engine for growth. Prepare to rethink everything you know about your customers. The future is here…machines are buying.