7–9 November 2016: Conference & Tutorials
9–10 November 2016: Training
Amsterdam, The Netherlands

Speaker slides & videos

Presentation slides will be made available after the session has concluded and the speaker has given us the files. Check back if you don't see the file you're looking for—it might be available later! (However, please note some speakers choose not to share their presentations.)

Accelerated mobile pages (AMP) deliver a fast user experience for mobile devices by placing restrictions on the AMP markup and its ability to run code. Without code, how can we gather analytics or validate that our AMP pages are fast? Nic Jansma and Nigel Heron demonstrate how to gather RUM for AMP.
For too long, the Web has been seen as a poor relation to native apps, but no longer! We’ve been able to add websites to our home screens for a while, but with better offline support and notifications and richer metadata, we can finally build web experiences that rival or exceed native apps. Andy Davies explains how these technologies can be combined to deliver great web experiences.
When we're looking for improved velocity and speeding up the process of delivering value to customers, incorporating security and compliance requirements is important. Mandi Walls offers an overview of InSpec, a tool that can help bridge the gap between security needs and operational realities in continuous delivery workflows.
Schuberg Philis is an innovative business technology company focused on the mission-critical applications that its customers and society rely on 24/7. As Schuberg Philis was growing, the company had to figure out how to keep its coaching model sustainable. Lotta Croiset van Uchelen explores the solution it landed on: every colleague can choose their own boss.
Michael Hausenblas demonstrates how to build and roll out containerized applications in an automated fashion and outlines best practices around Docker image builds, taking footprint and security aspects into consideration.
Not all web applications are deployed to Linux or the cloud. Building and deploying for clients with traditional IT departments is challenging, and ensuring we can deploy with confidence within unusual infrastructures and IT constraints requires flexibility. Rob Allen explores these complexities and shares some solutions.
To ship software at the rate that we do (or strive to), we need the right tools and the right setup. Lorna Mitchell discusses how the layout of your Git repository can really help or hinder how your teams work together.
Sky Betting & Gaming bought into the DevOps philosophy years ago. During that time, the business has changed radically, going from 250 to 1,000 employees with >30% growth year on year. Michael Maibaum describes how the DevOps function has changed repeatedly over the last few years to help the company continue to move fast and keep systems operating through organizational and technical challenges.
Drawing on examples from Adidas, Kristian Skoeld explains how to create a data-driven third-party governance strategy that delivers greater insights into frontend performance and continuous delivery.
In the world of microservices, when things are moving fast and constantly breaking, the accepted wisdom is that teams must own the whole stack and operate their services themselves. But how do we ensure that operational standards are consistent across the organization? And how much stack is the whole stack? George Sudarkoff explains how to distribute operations in a consistent and efficient way.
Michael Gooding and Javier Garza share their experiences with HTTP/2 over the last year, discussing case studies that demonstrate how performance can be improved over HTTP/2 while addressing backward compatibility, exploring using RUM data to review performance-related observations of customers after switching to HTTP/2, and offering hands-on demos of HTTP/2 with server push and HTTP/2 + QUIC.
It's daunting knowing the WebPerf community is going to scrutinize the website you’re building—especially when the website is for one of your favorite meetups. Adam Onishi walks you through the project from design to deployment, covering design considerations, font choices, frontend optimization, and performance testing before exploring how service workers can improve performance.
Kubernetes and Prometheus are still pretty young, but somehow they immediately fell in love when they first met early last year. And now Prometheus has moved into the shiny new CNCF building that Kubernetes has called home for a while. Björn Rabenstein explores how the first two projects hosted by the Cloud Native Computing Foundation work together.
Everything changes at scale. Launching products at a scale of 1+ billion users requires a massive cross-team, cross-functional, coordinated effort, and business, engineering, and cultural challenges must be overcome. Kishore Jalleda and Gopal Mor explain how they have applied DevOps best practices at scale to successfully launch several high-profile products at Yahoo.
The elephant in the room that every developer ignores is that all automated tests (except unit) are too slow for today’s fast-paced, first-to-market environment. With slow automated tests, you’re just shipping problems faster to production. Emanuil Slavov explains how the team at Komfo made automated tests run 60x faster using containers, hermetic servers, and improved architecture.
New Direction - Velocity & Fluent
Successful DevOps means empowering teams. But you still have things you want all teams to do, and you need to balance the benefits of the right technologies against the costs of running multiple data stores, deployment platforms, languages, etc. Sarah Wells offers a brief overview of nudge theory and explores its possibilities for influencing disparate teams to do things for the common good.
Loading all the resources a web page needs is a complex process. Some resources can cause the browser's parser to block, preventing other resources' discovery. In other cases, resources can be hidden from the parser altogether. Yoav Weiss discusses how browsers discover and load resources and explores preload, a new link relation enabling early resource discovery.
There's more to microservices than just being small. Modern service-oriented architectures typically reside in more volatile environments, and the lifespan of a single service instance is much shorter than it used to be. Rick Fast explores how to design services and their infrastructure to allow for dynamic placement, resiliency, monitoring, and discovery.
Who do you trust? What do you control? What are your dependencies? Reliability on the Internet is an adrenaline-fueled adventure, but we all want a good night sleep and working service sometimes. Adam Surák takes a closer look at some reliability nightmares and explains how they could be dealt with.
Several APIs are available on modern browsers to help performance, including Service Worker, Push Notifications, NetInfo API, the Cache Storage API, and the older Application Cache. Through hands-on labs, Maximiliano Firtman walks you through using these APIs to create a progressive web app and improve performance and perception on a website.
New performance bottlenecks become apparent as web browsers and servers start using HTTP/2. Kazuho Oku explains the issues, their mitigation, and how the developers of the HTTP protocol are trying to make the Web even faster, covering the reality of HTTP/2 prioritization, cache-aware server push, the impact of load balancers for HTTP/2, mobile optimization, and HTTP caching.
The Grand National always breaks records by every metric at Sky Betting & Gaming, one of the UK's largest online betting websites. Kevin Bowman offers a from-the-trenches perspective of how Sky Betting & Gaming planned for and ran the busiest day of the sports betting year and the lessons learned that will make next year even better.
LeaseWeb has started a transition toward a more Agile and empowered engineering culture. Arnoud Vermeer offers a summary of things LeaseWeb did to foster the change, the impact they had, and lessons learned along the way.
We often hear talks on scale and reliability, mostly based on personal experience and lessons learned. Avishai Ish-Shalom asks what mathematics tells us about reliability and scale. Can math help us scale our systems and companies? It turns out that failure models, probability, statistics, and other domains can help our analysis and provide useful insights
HTTP/2 Push is the next frontier of web performance. Colin Bendell explores Push's possibilities and pitfalls as well as new metrics to measure the Push opportunity. Colin discusses when and how to use Push, testing, and several advanced techniques, reviews real-world experimentation, and shares recommendations on how to prepare for the future with Push support.
Yoav Weiss explores where web standards come from, the role of the Web Performance Working Group, new and forthcoming performance-related APIs, and how to push that cool idea you have for a new web API.
There's been a lot of discussion about how to build a progressive web app but not a lot of discussion about why businesses should invest in them. Better user experience, faster performance, more engagement—Jason Grigsby explains why progressive web apps are no-brainers for most websites.
When we think about human work, we often fail to realize that the same activity is actually two very different sorts of work. Steven Shorrock explores some of the differences between work as imagined and work as done in a variety of settings and outlines some implications for the inevitable gaps.