Engineering the Future of Software
Feb 25–26, 2018: Training
Feb 26–28, 2018: Tutorials & Conference
New York, NY

Speaker slides & video

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.)

Sarah LeBlanc (ThoughtWorks), Hany Elemary (ThoughtWorks)
Join Sarah LeBlanc and Hany Elemary for a unique talk where data science meets DevOps culture. Sarah and Hany explain how to put machine learning fraud detection models into production, using data science algorithms to drive effective models. Along the way, they explain how a global corporation is creating an extensible platform for more than just application fraud.
Data-intensive processes and AI workloads demand the performance and scalability of a cloud-native platform. Container-based methods accelerate software development, but to truly exploit CD workflows, enterprises must adopt a collaborative culture. Andrew Hately explains how a cloud-native mindset can accelerate your application delivery.
James Siddle (Skyhook Consulting Ltd)
Software architecture can be beautiful, but business and engineering reality is often inconvenient and messy. James Siddle explains how living product roadmaps help you deal with reality without compromising your architecture vision. You’ll learn Agile roadmapping techniques and how to engage with stakeholders to move toward your architecture goals while avoiding wasteful endeavors.
Rene Bostic (IBM Cloud)
René Bostic details how software architects of the digital economy are leveraging cloud technology to drive business transformation for success. Join in to learn how the cloud can make your business more resilient, enable new workloads, and ensure the balance between innovation and stability.
Kai Wähner (Confluent)
Kai Wähner shares a highly scalable, mission-critical infrastructure using Apache Kafka and Apache Mesos: Kafka brokers are used as the distributed messaging backbone; Kafka’s Streams API embeds stream processing into any external application without the need for a dedicated streaming cluster; and Mesos is used as a scalable infrastructure to leverage the benefits of a cloud-native platform.
Matthew McLarty (MuleSoft)
Microservices have taken the software architecture world by storm. Initially driven by a desire for increased delivery velocity and greater scalability, organizations are now recognizing the importance and complexity of securing their microservices. Matt McLarty shares techniques for securing microservice APIs and a practical model you can implement in your organization.
Georgios Gkekas (ING Bank)
Georgios Gkekas shares ING's advanced analytics journey to promote modern machine and deep learning techniques internally through a central, best-of-breed technical platform tailored for data science activities. The platform offers only the necessary automated tools to replace the tedious, repetitive, and error-prone steps in a typical data science pipeline.
Jeremy Deane (Foundation Medicine)
There are inherent trade-offs that must be made in any software architecture. Some architectural trade-offs are obvious, such as performance versus security or availability versus consistency, while others are quite subtle such as resiliency versus affordability. Jeremy Deane explores a number of architectural trade-offs and offers strategies for dealing with them.
James Thompson (Mavenlink)
Traditional management approaches tend to focus on narrow measures of performance. Within engineering organizations, this can lead to incentives around the wrong practices and priorities. Coaching models refocus the management of engineers around professional growth in a way that can create a virtuous cycle. James Thompson explains how to build a technical coaching program in your organization.
Steven Wu (Netflix)
Steven Wu explains how Netflix’s SPaaS platform empowers users to focus on extracting insights from data streams and build stream processing applications and shares lessons learned building and operating the largest SPaaS use case: Netflix’s Keystone data pipeline, a self-serve platform for creating near-real-time event pipelines that processes three trillion events and 12 PB of data every day.
Dean Wampler (Anyscale), Boris Lublinsky (Lightbend)
Dean Wampler and Boris Lublinsky walk you through building several streaming microservices applications based on Kafka using Akka Streams and Kafka Streams for data processing. You'll explore the strengths and weaknesses of each tool, helping you choose the best tools for your needs, and contrast them with Spark Streaming and Flink, so you can determine when to choose them instead.
Whether you’re modernizing an application monolith or developing a new cloud-native application, it's no longer a question of whether or not to use microservices. Instead, the challenge facing many architects is deciding what technologies to use in their applications. Andrew Hately details the best combination of cloud services and tools to use to get the right results.
Bernd Ruecker (Camunda)
In distributed systems, some business transactions and even more end-to-end processes stretch across boundaries of individual services. While event-driven choreography leads to nicely decoupled systems, complex event chains cause headaches. Bernd Rücker explains why transforming certain events into commands is beneficial and how to avoid losing sight of larger-scale flows.
Cassandra Shum (ThoughtWorks), Rosemary Wang (HashiCorp)
Cassandra Shum and Rosemary Wang detail what you need to know when moving from an on-premises platform to the public cloud, moving beyond the technical architecture and patterns to explore the pitfalls when migrating.
John Chapin (Symphonia)
With systems like Travis CI, Circle CI, and CodeBuild, we're never more than a few lines of YAML away from a complete continuous delivery pipeline. However, ephemeral build systems constantly recreate the world from scratch, increasing build time and lengthening the CD feedback loop. John Chapin addresses those challenges and shares a reference pipeline using AWS CodePipeline and CodeBuild.
Mario-Leander Reimer explores key JEE technologies that can be used to build JEE-powered data services and walks you through implementing the individual data processing tasks of a simplified showcase application. You'll then deploy and orchestrate the individual data services using OpenShift, illustrating the scalability of the overall processing pipeline.
Tom Hofte (Xebia), Marco van der Linden (Xebia)
A public API is a new type of service that extends the business model beyond traditional boundaries. Tom Hofte and Marco van der Linden walk you through designing a resource model for a public API. You'll then work in teams to design an API for a fictional case study.
Adrian Cockcroft (Amazon Web Services)
Chaos engineering leverages carefully designed failure injection tests and the distributed automation inherent in cloud deployments to prove that there is enough margin to absorb failures in production. Adrian Cockcroft outlines the overall architectural principles of chaos engineering and shares methods engineers can use to exercise failure modes in safety and business-critical systems.
Paul Bakker (Netflix)
How do feature teams (device teams, UI, etc.) connect efficiently to backend services in a microservices architecture? How do you create an edge API that satisfies teams with vastly different requirements? And how do you operate these mission-critical edge services? Paul Bakker discusses these challenges and offers an overview of Netflix's PaaS built specifically for edge services.
Joel Crabb (Target)
The catchphrase of the year is digital disruption. It's finally clear that digital complacency is a path to nonexistence even in industries that haven’t yet felt the direct impact of the digital era. Joel Crabb explains why retail has been completely disrupted and, in the process, is reinventing enterprise architecture for digital relevancy.
Chris Richardson (Eventuate)
Chris Richardson explains why events are a key application integration mechanism and how they are used by applications to communicate with the outside world. You'll learn how the microservices inside an application use events to maintain data consistency and discover how to go one step further and make events an integral part of your domain logic.
Jago Macleod (Google)
Jago Macleod shares recent work that allows users to extend the Kubernetes API with custom resources and controllers and leverage this pattern. Its growing popularity in Kubernetes and other projects in the space suggests you will see more of it in the future.
Philippe Guerin (CAST Software)
Philippe Guerin demonstrates how to transform a monolithic application into a microservices application while tracking the change of the transformation and balancing the loss of performance or stability of your application with the introduction of the new layers.
Kevin Stewart (Heptio)
Many organizations are racing to adopt cloud native to unlock all of the benefits that microservices, containers, and orchestration tools such as Kubernetes promise to deliver. Kevin Stewart explores the people, processes, and cultural aspects that complement the cloud-native computing technology stack.
Rouven Wessling (Contentful), Andrew Kumar (TELUS)
TELUS digital—the in-house agency for Canadian telecommunications company TELUS—recently created a new content platform that enables team members to easily add, update, and deliver content across all their digital properties. Rouven Wessling offers an overview of the platform and explains why TELUS digital chose a content infrastructure over traditional CMS options.
James Stewart (
Architects are often the ones making the decisions about how to build in the right security for systems while making systems usable and delivering them on time. James Stewart shares techniques for considering security of whole systems and explores ways of bringing together cross-disciplinary teams to collectively own secure designs.
Communicating (about) architecture to non-IT and business stakeholders is a valuable skill. After all, many architectural decisions are made by others, so they need to be informed with clear, honest, intelligible, and helpful information and advice. Jochem Schulenklopper dives into theory and shares practical tips on eight different facets of visually communicating your architecture.
Jochem Schulenklopper and Gero Vermaas offer an overview of TIME, a well-known model for application portfolio management by Gartner, and cover some improvements to the model, including a process for determining business value of applications, a innovative method of measuring IT quality (from an architect's perspective), and tactics for improving the applications in an organization's IT landscape.
Allen Holub (Holub Associates)
If you still use large up-front design phases, you'll likely encounter problems with your design as you implement. The solution is to build around a domain-focused metaphor that allows for incremental changes while maintaining coherence throughout. Allen Holub demonstrates how to develop an effective and coherent architecture incrementally as the code evolves.
Mike Amundsen (, Inc.)
A RESTful approach to microservices offers a number of benefits. Mike Amundsen walks you through building adaptable microservices that take advantage of the features of REST, including statelessness, self-description, and using hypermedia to discover and modify application state.
Sam Stokes (Honeycomb)
In the complex world of microservices and distributed systems, we need to understand what our software is doing. Traditional tools, such as logs, read by humans and filtered by crude rules, aren’t powerful enough. Sam Stokes explains that we need new, better tools and why this will also require us to design our systems to give the tools better data.
Yiannis Kanellopoulos (Code4Thought), Evelyn van Kelle (Software Improvement Group)
Good teams and good products go hand in hand. But how does product quality impact the effectiveness of a team? And how do good teams produce high-quality software architecture? Evelyn van Kelle and Yiannis Kanellopoulos explain how developer happiness and high-quality architecture are interrelated and why we cannot engineer the future without empowering developers.
Duncan DeVore (Lightbend)
Duncan DeVore discusses the ins and outs of dealing with modular JVM-based application consistency, distributed state, and identity coherence with techniques such as idempotency, eventual and casual consistency, the CAP theorem, single source of truth, and distributed domain design.
Karun Japhet (Sahaj Software), Vinicius Gomes (ThoughtWorks)
Serverless architecture is the latest implementation technique for the increasingly popular event-driven system architecture. Karun Japhet and Vinicius Gomes compare the the multiple cross-functional requirements of serverless and microservices implementations of an event-driven system.
John Chapin (Symphonia)
Even EC2 has serverless attributes, and you can leverage them to realize the benefits of serverless in your classic enterprise cloud architectures. John Chapin shares the true story of an enterprise IT organization for which a potent combination of “mostly serverless” technology and a DevOps mindset have laid the groundwork for a future serverless transformation.
Maria Gomez (BCG Digital Ventures)
Think of this talk as Microservices 201. You know microservices basics and their pros and cons and have maybe even started putting them in production but haven't spent much time thinking about how to maintain them. Maria Gomez explores the most important operational concerns for maintaining microservices and explains why observability helps you maintain a healthy production environment.
Allard Buijze (AxonIQ)
Most discussions about implementing microservices start by evaluating the technical options and their challenges. However, the real business value is in functionality. Allard Buijze demonstrates how to build evolutionary microservices, starting with a single application that can be scaled out and distributed once the sensible boundaries are known.
JP Robinson (New York Times)
Over the course of 2017, the API traffic of the New York Times crossword tripled. At the same time, a very small team of engineers managed to migrate its platform from a PHP monolith on Amazon Web Services to a suite of Go microservices on Google Cloud Platform. JP Robinson explains how his team was able to make the migration with zero downtime while cutting infrastructure costs in half.
Maria Gomez (BCG Digital Ventures)
Think of this talk as Microservices 201. You know microservices basics and their pros and cons and have maybe even started putting them in production but haven't spent much time thinking about how to maintain them. Maria Gomez explores the most important operational concerns for maintaining microservices and explains why observability helps you maintain a healthy production environment.
Seth Dobbs (Bounteous)
Communication is a critical skill for architects and tech leads, but it involves much more than simply documenting and diagramming. Seth Dobbs explores the illusion of communication and shares a process for effectively communicating your solutions to different stakeholders.
Ike Nassi (TidalScale)
Ike Nassi explores the implications that software-defined servers will have on application and computing infrastructure.
A big part of microservices architecture is decomposing monolithic applications with tightly coupled data models, but moving to decentralized data management is one of the most challenging aspects of a microservices architecture. JP Morgenthal shares strategies for your redesign efforts, the possible pitfalls, and the trade-offs these approaches force architects and engineers to make.
Robert Lefkowitz (Warby Parker)
Robert Lefkowitz offers a overview of technical debt, explaining how to prevent or reduce it, when to increase it, and how to use refactoring to refinance it.
Eben Hewitt (Sabre)
Eben Hewitt explains what the world’s top strategy firms can teach us about the intersection of strategic thinking and architecture and outlines a framework, process, and set of tools that will help you create a powerful technology strategy for your organization.
Cornelia Davis (Pivotal)
Cornelia Davis explains how to use an event-driven approach to address the fallacies of distributed computing in a very different way, offering significant benefits over request-response, and details event-oriented solutions to problems commonly addressed with well-known patterns.
Suudhan Rangarajan (Netflix)
As Netflix continues its journey beyond 100M members, the company is rearchitecting its critical Playback API service to better serve its business needs for the next three to five years. Suudhan Rangarajan discusses why and how Netflix rebuilt the Playback API service and outlines a rigorous framework that you can use to reason about your microservice architecture.