Microservices architecture has become a buzzword in the tech industry, promising unparalleled agility, scalability, and resilience. Yet, according to Gartner, more than 90% of organizations attempting to adopt microservices will fail. How can you ensure you're part of the successful 10%?

Success begins with looking beyond the superficial topology and understanding the unique demands this architectural style places on the teams, the organization, and the environment. These demands must be balanced against the current business needs and organizational realities while maintaining a clear and pragmatic path for incremental evolution.

In this session, Michael will share some real-world examples, practical insights, and proven techniques to balance both the power and complexities of microservices. Whether you're considering adopting microservices or already on the journey and facing challenges, this session will equip you with the knowledge and tools to succeed.

Architectural decisions are often influenced by blindspots, biases, and unchecked assumptions, which can lead to significant long-term challenges in system design. In this session, we’ll explore how these cognitive traps affect decision-making, leading to architectural blunders that could have been avoided with a more critical, holistic approach.

You’ll learn how common biases—such as confirmation bias and anchoring—can cloud judgment, and how to counteract them through problem-space thinking and reflective feedback loops. We’ll dive into real-world examples of architectural failures caused by biases or narrow thinking, and discuss strategies for expanding your perspective and applying critical thinking to system design.

Whether you’re an architect, developer, or technical lead, this session will provide you with tools to recognize and mitigate the impact of biases and blindspots, helping you make more informed, thoughtful architectural decisions that stand the test of time.

Modernizing legacy systems is often seen as a daunting task, with many teams falling into the trap of rigid rewrites or expensive overhauls that disrupt the business. The Tailor-Made Architecture Model (TMAM) offers a new approach—one that is centered on incremental evolution through design-by-constraint. By using TMAM, architects can guide legacy systems through a flexible, structured modernization process that minimizes risk and aligns with both technical and organizational needs.

In this session, we’ll explore how TMAM facilitates smooth modernization by identifying and addressing architectural constraints without resorting to drastic rewrites. We’ll dive into real-world examples of how legacy systems were evolved incrementally and discuss how TMAM provides a framework for future-proofing your systems. Through its focus on trade-offs, communication, and holistic fit, TMAM ensures that your modernization efforts not only solve today’s problems but also prepare your system for the challenges of tomorrow.

This session is ideal for architects, developers, and technical leads who are tasked with modernizing legacy systems and are looking for a structured, flexible approach that avoids the pitfalls of rigid rewrites. Learn how to evolve your legacy system while keeping it adaptable, scalable, and resilient.

The age of hypermedia-driven APIs is finally upon us, and it’s unlocking a radical new future for AI agents. By combining the power of the Hydra linked-data vocabulary with semantic payloads, APIs can become fully self-describing and consumable by intelligent agents, paving the way for a new class of autonomous systems. In this session, we’ll explore how mature REST APIs (level 3) open up groundbreaking possibilities for agentic systems, where AI agents can perform complex tasks without human intervention.

You’ll learn how language models can understand and interact with hypermedia-driven APIs, and how linked data can power autonomous decision-making. We’ll also examine real-world use cases where AI agents use these advanced APIs to transform industries—from e-commerce to enterprise software. If you’re ready to explore the future of AI-driven systems and how hypermedia APIs are the key to unlocking it, this session will give you the knowledge and tools to get started.

Just as CI/CD and other revolutions in DevOps have changed the landscape of the software development lifecycle (SDLC), so Generative AI is now changing it again. Gen AI has the potential to simplify, clarify, and lessen the cycles required across multiple phases of the SDLC.

In this session with author, trainer, and experienced DevOps director Brent Laster, we'll survey the ways that today's AI assistants and tools can be incorporated across your SDLC phases including planning, development, testing, documentation, maintaining, etc. There are multiple ways the existing tools can help us beyond just the standard day-to-day coding and, like other changes that have happened over the years, teams need to be aware of, and thinking about how to incorporate AI into their processes to stay relevant and up-to-date.

GitHub Copilot is a popular AI assistant that helps software developers more easily create content, get answers to coding-related questions, and handle many of the boilerplate tasks of software development. But it can also do much more in the areas where it can be used. Join Copilot expert (and author of the upcoming “Learning GitHub Copilot” book from O'Reilly) for a quick overview of some of the additional tips and tricks to allow you to make the most from this AI assistant.

Most users know GitHub Copilot can help with the basics of code generation, creating test cases, documentation, etc. But because the tool is AI based, there's a lot more that it can help you with in these areas simply by asking it and giving it the right prompts. In this session, we'll take a look at some ways to leverage beyond the basics of these tasks to creating results that are usable more deeply and widely. We'll also look at some ways to compensate when Copilot does not have the most recent information, or needs to be picking up more relevant context.

In this presentation, we'll cover the options, tips, and tricks for using GitHub Copilot to help us identify how to test code, generate tests for existing code, and generate tests before the code.

Join global trainer, speaker, and author of the upcoming book, Learning GitHub Copilot, Brent Laster as he presents material on multiple ways to leverage Copilot for testing your code on any platform and framework.

Have you wondered what options GitHub Copilot can provide for helping to not only write your code, but test your code? In this session, we'll examine some key ways that Copilot can support you in ensuring you have the basic testing needs covered. In particular, we'll cover:

• A quick overview of GitHub Copilot
• Letting Copilot tell you how to get started testing for a new language
• Creating tests for existing code through one-step commands
• Creating tests for existing code with comments
• Creating tests for existing code with explicit prompts
• Validating inputs to functions using Copilot
• Using Copilot to build out tests for edge cases
• Leveraging testing frameworks
• Building tests before the code - TDD with Copilot

Large language models (LLMs) are great and provide a lot of utility out of the box - as long as you accept that the data they have is only as recent as their training. And, as long as you understand that that they don't have context of any data they weren't trained on - which may be the local context you really care about. In this session, we'll see how to augment their training and knowledge to include other content that they weren't trained on, such as your files. And we'll see how to seamlessly combine that with the LLM's existing knowledge and query/prompt interfaces.

Retrieval Augmented Generation (RAG) is the prominent approach/technology for adding additional data to the set that can be referenced when you are working with LLMs. This approach allows you to add more up-to-date or more contextually relevant “local” information sources, such as documents. These are then converted and stored in a way that makes them “queryable” in the same way as the LLM.

Join expert Brent Laster to learn how to integrate your data with off-the-shelf LLMs to get a unified approach for querying your local content as well as the LLM's training.

IDEs have provided ways to refactor code for a long time now. In spite of their effectiveness, that journey is arduous and time consuming. Reluctance to refactor increases the cost of development. However, refactoring for the sake of doing so can lead to greater productivity loss as well.

In this presentation we will use data driven approach. We will take examples of code, measure code quality, and then use automated code transformation tools to refactor the code, and then, once again, measure the quality of code and see how much we have improved. This can help us to not only refactor faster but also see the benefits realized and motivate us to move faster with greater efficiency.

Dividing a large problem into subproblems that are scheduled to run on different threads is an often used solution. We've used executors and fork join pool for such problems in the past. These solutions, in spite of being very powerful, have significant limitations.

In this presentation we will start with those solutions, discuss the issues, and learn how structured concurrency, introduced in Java 21, can help solve such problems more effectively and elegantly.

Threads are lightweight, but do not scale well. That's one of the reasons we have been focused on the elastic capabilities on the cloud. Unfortunately that has an impact both on our environment and your companies wallet.

In this presentation we will learn how virtual threads reduce those impacts and help us to create scalable applications with minimum change to code.

In this example-driven session, we'll review several tips and tricks to make the most out of your Spring development experience. You'll see how to apply the best features of Spring and Spring Boot, including the latest and greatest features of Spring Framework 6.x and Spring Boot 3.x with an eye to what's coming in Spring 7 and Boot 4.

Spring has been the de facto standard framework for Java development for nearly two decades. Over the years, Spring has continued to evolve and adapt to meet the ever-changing requirements of software development. And for nearly half that time, Spring Boot has carried Spring forward, capturing some of the best Spring patterns as auto-configuration.

As with any framework or language that has this much history and power, there are just as many ways to get it right as there are to get it wrong. How do you know that you are applying Spring in the best way in your application?

Workshop Requirements

You'll need…

• A Java IDE of your choice. I'll be using IntelliJ, but you are welcome to use Spring Tools, Netbeans, or whatever you prefer for Java development. (Spring Tools–either the Eclipse or VSCode version–or IntelliJ is recommended, though).
• Java 17 or higher. I recommend using SDKMan (https://sdkman.io/) for managing multiple versions of Java on your machine. I'll be using Zulu 17.0.6 for most tasks, but may switch to a Liberica NIK version for purposes of native builds.
• Docker (optional, but may be necessary for some tasks)

By now, you've no doubt noticed that Generative AI is making waves across many industries. In between all of the hype and doubt, there are several use cases for Generative AI in many software projects. Whether it be as simple as building a live chat to help your users or using AI to analyze data and provide recommendations, Generative AI is becoming a key piece of software architecture.

So how can you implement Generative AI in your projects? Let me introduce you to Spring AI.

For over two decades, the Spring Framework and its immense portfolio of projects has been making complex problems easy for Java developers. And now with the new Spring AI project, adding Generative AI to your Spring Boot projects couldn't be easier! Spring AI brings an AI client and templated prompting that handles all of the ceremony necessary to communicate with common AI APIs (such as OpenAI and Azure OpenAI). And with Spring Boot auto-configuration, you'll be able to get straight to the point of asking questions and getting answers your application needs.

In this session, we'll consider a handful of use cases for Generative AI and see how to implement them with Spring AI. We'll start simple, then build up to some more advanced uses of Spring AI that employ your application's own data when generating answers.

In this session we'll take a tour of some features that you might or might not have heard of, but can significantly improve your workflow and day-to-day interaction with Git.

Git continues to see improvements daily. However, work (and life) can take over, and we often miss the changelog. This means we don't know what changed, and consequently fail to see how we can incorporate those in our usage of Git.

In this session we will look at some features you are probably aware of, but haven't used, alongside new features that Git has brought to the table. Examples include:

• Rebase and interactive rebase
• restore/switch and when to use them
• worktrees
• shallow-clones
• Git's filesystem monitor

By the end of this session, you will walk away with a slew of new tools in your arsenal, and a new perspective on how this can help you and your colleagues get the most out of Git.

Platform engineering is the latest buzzword, in a industry that already has it's fair share. But what is platform engineering? How does it fit in with DevOps and Developer Experience (DevEx)? And is this something your organization even needs?

In this session we will aim to to dive deep into the world of platform engineering. We will see what platform engineering entails, how it is the logical succession to a successful DevOps implementation, and how it aims to improve the developer experience. We will also uncover the keys to building robust, sustainable platforms for the future

Join us for an indepth exploration of cuttingedge messaging styles in your large domain.

Here, we will discuss the messaging styles you can use in your business.

• Event Sourcing
• EventDriven Architecture
• Claim Check
• Event Notification
• Event Carried State Transfer
• Domain Events

Java’s evolution is remarkable, and the leap from JDK 17 to the current version brings a wealth of powerful features to elevate your projects. Join us for an exciting session to explore select JEPs (Java Enhancement Proposals) introduced up to today, diving into their use cases and practical benefits for your work or open-source initiatives.

What You’ll Learn:
How to enable and utilize advanced Java features introduced in JDK 23.
Real-world demonstrations of cutting-edge updates, including:

• Stream Gatherers: Handle complex data streams with ease.
• Statements Before super(): Test invariants without constructing objects.
• Stable Values
• Unnamed Variables and Parameters: Enhance code readability and maintainability.
• Launch Multi-File Source-Code Programs: Rapidly prototype with multiple source files.
• Implicitly Declared Classes & Enhanced Main Methods: Streamline application development.
• Updates on switch Expressions: We will discuss where we are with pattern matching as well as dealing with primitives
• I may also sneak in something about my never-ending love for SimpleWebServer.

Why Attend?
Learn how to advocate for and implement your organization's latest Java tools and practices. Gain the knowledge you need to sell the value of next-generation Java and stay at the forefront of software development.

In today’s data-driven world, the ability to process and analyze data in real time is no longer a luxury—it’s a necessity. Apache Flink, a powerful stream processing framework, has emerged as a game-changer for handling high-throughput, low-latency data applications.

In this session, you’ll gain a clear understanding of what Apache Flink is, how it works, and why it’s become a cornerstone for modern data infrastructure. We’ll explore key features such as its robust stream and batch processing capabilities, event-time handling, stateful computations, and fault tolerance. You’ll also discover how Flink integrates seamlessly with popular systems like Kafka, Kubernetes, and major cloud platforms.

Whether you’re working with real-time analytics, event-driven applications, or machine learning pipelines, Apache Flink provides the scalability and flexibility needed to turn massive streams of data into actionable insights. Join us to see why Flink is critical to modern data ecosystems and learn how to start leveraging its power in your projects.

Since ChatGPT rocketed the potential of generative AI into the collective consciousness there has been a race to add AI to everything. Every product owner has been salivating at the possibility of new AIPowered features. Every marketing department is chomping at the bit to add a “powered by AI” sticker to the website. For the average layperson playing with ChatGPT's conversational interface, it seems easy however integrating these tools securely, reliably, and in a costeffective manner requires much more than simply adding a chat interface. Moreover, getting consistent results from a chat interface is more than an art than a science. Ultimately, the chat interface is a nice gimmick to show off capabilities, but serious integration of these tools into most applications requires a more thoughtful approach.

This is not another “AI is Magic” cheerleading session, nor an overly critical analysis of the field. Instead, this session looks at a number of valid usecases for the tools and introduces architecture patterns for implementing these usecases. Throughout we will explore the tradeoffs of the patterns as well as the application of AI in each scenario. We'll explore usecases from simple, direct integrations to the more complex involving RAG and agentic systems.

Although this is an emerging field, the content is not theoretical. These are patterns that are being used in production both in Michael's practice as a handson software architect and beyond.

Architects must maintain their breadth, and this session will build on that to prepare you for the inevitable AIpowered project in your future.

Since ChatGPT rocketed the potential of generative AI into the collective consciousness there has been a race to add AI to everything. Every product owner has been salivating at the possibility of new AIPowered features. Every marketing department is chomping at the bit to add a “powered by AI” sticker to the website. For the average layperson playing with ChatGPT's conversational interface, it seems easy however integrating these tools securely, reliably, and in a costeffective manner requires much more than simply adding a chat interface. Moreover, getting consistent results from a chat interface is more than an art than a science. Ultimately, the chat interface is a nice gimmick to show off capabilities, but serious integration of these tools into most applications requires a more thoughtful approach.

This is not another “AI is Magic” cheerleading session, nor an overly critical analysis of the field. Instead, this session looks at a number of valid usecases for the tools and introduces architecture patterns for implementing these usecases. Throughout we will explore the tradeoffs of the patterns as well as the application of AI in each scenario. We'll explore usecases from simple, direct integrations to the more complex involving RAG and agentic systems.

Although this is an emerging field, the content is not theoretical. These are patterns that are being used in production both in Michael's practice as a handson software architect and beyond.

Architects must maintain their breadth, and this session will build on that to prepare you for the inevitable AIpowered project in your future.

In this session we will discuss what modular monoliths are, what they bring to the table, and how they offer a great middle ground between monoliths and distributed architectures like microservices.

Monoliths get a bad rep. Experienced software developers have seen one too many monoliths devolve into a big ball of mud, leaving everyone frustrated, with an itch to do a “rewrite”. But monoliths have their pros! They are usually simpler, easier to understand, and faster to build and debug.

On the other side of the spectrum you have microservices—that offer scale, both technically and organizationally, as well as having the badge of honor of being “the new cool kid on the block”. But productionizing microservices is HARD.

Why can't we have our cake and eat it too? Turns out, we can. In this session we will explore the modular monolith—all the upsides of a monolith with none of the downsides of distributed architectures. We'll see what it means to build a modular monolith, and how that differs from a traditional layered architecture. We will discuss how we can build architectural governance to ensure our modules remain decoupled. Finally we'll see how our modules can communicate with one another without violating modularity.

By the end of this session you'll walk away with a greater appreciation for the monolith, and see how you can leverage this within your system architecture.

One of the coolest aspect of Java is the fact that the newer features simply do not live in isolation, but interplay quite nicely with each other. A place where this is clearly evident is the synergy between records, sealed classes, and pattern matching.

In this presentation we will focus on pattern matching and how its power is enhanced by records and also the sealed classes. The details presented will help you to make the best use of all the three features in your own applications.

Microservices have fundamentally changed the way we develop and deploy applications. Everything from team topologies, to DevOps to observability—everything changed, and for the better.

However, it's not all rainbows and unicorns. Operationalizing microservices is hard. Microservices encourage WET (write everything twice) to ensure that services are as decoupled from each other as possible. But how does that work when we have to deal with cross-cutting concerns that we need for every service?

Enter the service mesh. Service meshes like Istio allow us to “slot” in cross-cutting architectural concerns within a kubernetes cluster, letting our services focus on solving actual business concerns.

In this fast-paced session, we will blitz through what Istio is, how it works, and what facilities it offers to DRY out your microservices. Come see how Istio can make your cluster programmable and application-aware.

Introducing Spring Modulith

Although microservices are still a useful architectural choice, the balance of additional complexity and the advantages of microservice architecture do not necessarily work out in the benefit of all applications. While most application will benefit from improved modularity, the challenges that come with distributed computing may be too much for some applications to take on. A well-structured and modular monolithic application might be a better fit.

In this session, we'll explore Spring Modulith, a relatively new Spring library that enables developers to build well-structured Spring Boot applications, guiding them in discovering domain-driven modules, and verifying that the modular arrangement is correct. We'll also see how Spring Modulith assists with modular integration testing and documentation.

In this session, we'll cover several useful prompt engineering techniques as well as some emerging patterns that are categorized within the “Agentic AI” space and see how to go beyond simple Q&A to turn your LLM of choice into a powerful ally in achieving your goals.

At it's core, Generative AI is about submitting a prompt to an LLM-backed API and getting some response back. But within that interaction there is a lot of nuance, particularly with regard to the prompt itself.

It's important to know how to write effective prompts, choosing the right wording and being clear about your expectations, to get the best responses from an LLM. This is often called “prompt engineering” and includes several patterns and techniques that have emerged in the Gen AI space.

Spring Security has long been a powerful guard to place around your Spring applications, providing authentication, authorization, and many more concerns around keeping your application secure.

As time has progressed, Spring Security has evolved to provide even more capabilities, but has applied some self-improvement to make working with Spring Security even easier. That is to say, the way you configure and apply Spring Security today has changed dramatically from it's early XML-oriented approach and is even different now than some of the more recent Java-based configuration strategies.

In this example-driven session, we'll explore the latest and greatest that Spring Security has to offer, with an emphasis on how to apply security aspects to your applications with the latest configuration styles supported by Spring Security. You'll see how security is enabled in modern Spring applications using the Lambda DSL configuration approach, the preferred way to configure Spring Security and the ONLY way to configure Spring Security 7.

In this session, we will discuss architectural concerns regarding security. How do microservices communicate with one another securely? What are some of the checklist items that you need?

• Valet Key
• mTLS and Sidecars
• Public Key Infrastructure (PKI)
• SASL
• Hashicorp Vault Keys
• SBOMs
• JSON Web Tokens

2025 has been declared the “year of the agents”. There's a lot of potential, but there's also a lot to understand and make sense of. AI Agents are combinations of LLMs, tools, and custom roles that can autonomously perform tasks and make decisions based on context and user input. There are multiple types of agents and multiple agents can be managed together to cooperatively handle individual tasks that are part of a larger project to accomplish an overall goal.

By combining capabilities like tool access, multi-step reasoning, and real-time adjustments, agents can construct and complete complex workflows and intelligent solutions. In this presentation, we'll look at what AI agents are, how they really work, different types of agents and design patterns and touch on frameworks, challenges and more.

There is a new way of Threading, which means it is time to prepare. Project Loom has introduced Java Virtual Threads, which is now available in Java 21. Virtual Threads are small Threads meant to perform quick operations with the need to procure long-running OS threads, which can prove expensive. In this presentation, we will learn how to use these threads, what does it mean in relationship with the rest of the Java API, and what does it mean for third-party libraries.

• What is a Virtual Thread
• Creating and Using a Virtual Thread
• What will Loom's Virtual Threads do to Future and Reactive
• What is a Continuation?
• What is Structured Concurrency?
• What are Scoped Values

Join me as we embark on a journey to dissect the anatomy of innovation, uncover strategies to unlock the full potential of ideas, and transform them into impactful realities. Let's build a strong culture of innovation, and make sure that it is not just a buzzword but a tangible outcome.

Innovation is one of the key cornerstones of a successful company. So why do so many new inventions get stuck in backlog graveyards never to see the light of day? How can we go from idea to innovation faster?

To me, innovation is the process of creating novel meaningful impact through intentional learning. In this talk, I will share this model of the innovation pipeline and strategies I developed to classify and efficiently scale up innovations.

I’ll start by introducing three types of innovations: disruptovations, sustainovations, and maintainovations. Each has its playbook for how to get it off the ground and prioritize it. I’ll also share examples from my own experiences, both the wins and the losses, and the takeaways you can grab from them. Finally, I’ll dive into a few projects that started as a passion project and grew into major patented initiatives stretching across multiple teams and domains.

Join me as we embark on a journey to dissect the anatomy of innovation, uncover strategies to unlock the full potential of ideas, and transform them into impactful realities. Let’s build a strong culture of innovation, and make sure that it is not just a buzzword but a tangible outcome.

The Tech Radar is a powerful tool. It can be used to build a company-wide tech strategy, experiment with new technologies, document technical decisions, or even onboard new devs. In this talk, we will share our variation of the tech radar and strategies we developed to author, maintain, and open-source them.

The Tech Radar is a powerful tool. It can be used to build a company-wide tech strategy, experiment with new technologies, document technical decisions, or even onboard new devs. In this talk, we will share our variation of the tech radar and strategies we developed to author, maintain, and open-source them.

We’ll start with an overview of the technology lifecycle phases: assess, trial, adopt, hold, or retire. These are the foundations of the tech radar. We will also share our own experiences building and maintaining tech radars, and the tips and tricks you can take away. Finally, we’ll share a project that we have been working on to enable companies to open-source and share their tech radars.

Join us for the launch of the Open Tech Radar, where we'll guide you through the processes of authoring, documenting, sustaining, and open-sourcing your tech radar. Let's foster a culture of collaboration and knowledge-sharing across the industry!

Designing robust and scalable software systems is a challenge that grows with complexity. At MIT, I learned how tools like Design Structure Matrices (DSMs) and system engineering principles can transform software architecture. Join me to discover how system engineering methodologies can elevate software architecture!

Designing robust and scalable software systems is a challenge that grows with complexity. At MIT, I learned how tools like Design Structure Matrices (DSMs) and system engineering principles can transform software architecture.

In this talk, I’ll show how DSMs help visualize dependencies, uncover bottlenecks, and guide modular design. We’ll explore tradespace frameworks for managing complexity and balancing scalability, performance, and maintainability. I’ll share real-world examples of applying these techniques to microservices, monoliths, and hybrid systems.

Join me to discover how system engineering methodologies can elevate software architecture!