This interactive, hands-on workshop is designed for software developers and architects eager to explore cutting-edge AI technologies. We’ll delve deep into Retrieval-Augmented Generation (RAG) and GraphRAG, equipping participants with the knowledge and skills to build autonomous agents capable of intelligent reasoning, dynamic data retrieval, and real-time decision-making.
Through practical exercises, real-world use cases, and collaborative discussions, you’ll learn how to create applications that leverage external knowledge sources and relational data structures. By the end of the day, you’ll have a solid understanding of RAG and GraphRAG and the ability to integrate these methodologies into production-ready autonomous agents.
In this interactive workshop, participants will delve into the foundational concepts of RAG and GraphRAG, exploring how these technologies can be utilized to develop autonomous agents capable of intelligent reasoning and dynamic data retrieval. The workshop will cover essential topics such as data ingestion, embedding techniques, and the integration of graph databases with generative AI models.
Attendees will engage in practical exercises that involve setting up RAG pipelines, utilizing vector databases for efficient information retrieval, and implementing GraphRAG workflows to enhance the capabilities of their applications. By the end of the workshop, participants will have a comprehensive understanding of how to harness these advanced methodologies to build robust autonomous agents tailored to their specific use cases.
You are ready to level up your skills. Or, you've already been playing accidental architect, and need to have a structured plan to be designated as one. Well, your wait is over.
From the author of O'Reilly's best-selling “Head First Software Architecture” comes a full-day workshop that covers all that you need to start thinking architecturally. Everything from the difference between design and architecture, and modern description of architecture, to the skills you'll need to develop to become a successful architect, this workshop will be your one stop shop.
We'll cover several topics:
This is an exercise heavy workshop—so be prepared to put on your architect hat!
Microservices has emerged as both a popular and powerful architecture, yet the promised benefits overwhelmingly fail to materialize. Industry analyst, Gartner, estimates that “More than 90% of organizations who try to adopt microservices will fail…” If you hope to be part of that successful 10%, read on…
Succeeding with microservices requires optimizing for organization-level goals with all teams “rowing in the same direction” which is easier said than done. While the microservices architecture may have been well-defined at some point in history, today the word “microservices” is used as an umbrella to refer to a vast and diverse set of coarse-to-fine grained distributed systems. In short, thanks to the phenomenon of semantic diffusion, the term “microservices” means many different things to many different people.
The promised benefits of microservices (e.g. extremely high agility, scalability, elasticity, deployability, testability, evolvability, etc.) are achieved through a highly contextual hyper-optimization of both the logical architecture of the system as well as optimization of technical practices, tooling, and the organization itself. Operating based on someone else's reference architecture (optimized for their problem space, not yours) or attempting to apply the architectural topology without the necessary team and process maturity is often just laying the foundation for yet another microservice mega disaster.
There simply is no one-sized-fits-all approach to component granularity, optimal inter-service communication, data granularity, data replication and aggregation, minimizing or managing distributed transactions, asynchronous event orchestration or choreography, technology and platform selection/management, along with so many more decisions that are highly contextual. In short, adopting this architecture requires correctly making hundreds of decisions on a path that is fraught with traps and landmines. This is one of the hardest architectures to execute well. In markets with ever-increasing competitiveness, slow and costly trial-and-error is untenable.
Mastering microservices requires that architects and developers understand the numerous tradeoffs (and their consequences) to arrive at an architecture that is both in-reach of the development teams and organization as well as capable of delivering the promised (and often necessary) -illities. This requires deep understanding of the terrain the architect will be exploring, extensive hands-on practice, and the latest tools, patterns, and practices; all of which this workshop is designed to deliver.
If you or your organization hopes to venture down this path, or if you already have but the organization and system is struggling to deliver necessary -illities, or if you just want to have a better understanding of the complex yet powerful architecture category; this workshop is for you.
How do we go from requirements to architecture? When the requirements change, when and what do we change in the architecture? A good architecture has to be relevant to the application it serves, but how can we accomplish that.
In this workshop, we will take an example driven approach to take a few sample requirements, identify key considerations, map them over to architectural capabilities, and arrive at architectures that suite the requirements. Along the way we will cover some prominent architectures and when and where to use them.
Event-driven architecture (EDA) is a design principle in which the flow of a system’s operations is driven by the occurrence of events instead of direct communication between services or components. There are many reasons why EDA is a standard architecture for many moderate to large companies. It offers a history of events with the ability to rewind the ability to perform real-time data processing in a scalable and fault-tolerant way. It provides real-time extract-transform-load (ETL) capabilities to have near-instantaneous processing. EDA can be used with microservice architectures as the communication channel or any other architecture.
In this workshop, we will discuss the prevalent principles regarding EDA, and you will gain hands-on experience performing and running standard techniques.
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.
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.
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.
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.
Statistically speaking, you are most probably an innovator. Innovators actively seek out new ideas, technologies, and mental models by reading books, interacting with a broader social circle, and attending conferences. While you may leave this conference with the seed of an idea that has the potential to transform your teams, products, and organization; the battle has only begun. While, as a potential changeagent, you are ideally positioned to conceive of the powerful new ideas, you may be powerless to drive the change that leads to adoption. Your success requires the innovation to diffuse outward and become adopted. This is the art of Innovation.
Fortunately there has been over a century of study on the topic of how innovations go from novel idea to mainstream adoption. The art of innovation is difficult, but tractable and this session illuminates the path. You will get to the heart of why some innovations succeed while others fail as well as how to tip the scales in your favor. You'll leave armed with the tools to become a powerful change agent in your career and life and, ultimately, become a more powerful and influential person.
Agile has become an overused and overloaded buzzword, let's go back to first principles. Agile is the 12 principles. Agile is founded on fast feedback and embraces change. Agile is about making the right decisions at the right time while constantly learning and growing.
Architecture, on the other hand, seems to be the opposite. Once famously described by Grady Booch as “the stuff that's hard to change” there is overwhelming pressure to get architecture “right” early on as the ultimate necessary rework will be costly at best, and fatal at worst. But too much complexity, too early, can be just as costly or fatal. A truly practical approach to agile architecture is long overdue.
This session introduces a new approach to architecture that enables true agility and unprecedented evolvability in the architectures we design and build. Whether you are a already a seasoned architect, or are simply beginning that path, this session will fundamentally change the way you think about and approach software architecture.
REST APIs often fall into a cycle of constant refactoring and rewrites, leading to wasted time, technical debt, and endless rework. This is especially difficult when you don't control the API clients.
But what if this could be your last major API refactor? In this session, we’ll dive into strategies for designing and refactoring REST APIs with long-term sustainability in mind—ensuring that your next refactor sets you up for the future.
You’ll learn how to design APIs that can adapt to changing business requirements and scale effectively without requiring constant rewrites. We’ll explore principles like extensibility, versioning, and decoupling, all aimed at future-proofing your API while keeping backward compatibility intact. Along the way, we’ll examine real-world examples of incremental API refactoring, where breaking the cycle of endless rewrites is possible.
This session is perfect for API developers, architects, and tech leads who are ready to stop chasing their tails and want to invest in designing APIs that will stand the test of time—so they can focus on building great features instead of constantly rewriting code.
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.
It's not just architecture—it's evolutionary architecture. But to evolve your architecture, you need to measure it. And how does that work exactly? How does one measure something as abstract as architecture?
In this session we'll discuss various strategies for measuring your architecture. We'll see how you know if your software architecture is working for you, and how to know which metrics to keep an eye on. We'll also see the benefits of measuring your architecture.
We'll cover a range of topics in this session, including
Different kinds of metrics to measure your architecture
The benefits of measurements
Improving visibility into architecture metrics
In this session we will discuss the need to document architecture, and see what mechanisms are available to us to document architecture—both present and future.
We've all learned that documenting your code is a good idea. But what about your architecture? What should we be thinking about when we document architecture? What tools and techniques can we reach for as we pursue this endeavor? Can we even make this a sustainable activity, or are we forever doomed to architectural documentation getting outdated before the ink is even dry?
In this session we will discuss a range of techniques that will not only help document your architecture, but even provide a mechanism to think about architecture upfront, and make it more predictable. You'll walk away armed with everything you need to know about documenting your current, and future architectures.
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?
This presentation will discuss the patterns required when things go wrong in architecture and how to stay resilient under pressure. These are battle-tested patterns that every architect should know.
We take a look at another facet of architectural design, and that is how we develop and maintain transactions in architecture. Here we will discuss some common patterns for transactions
This workshop will explore the principles of the Ports and Adapters pattern (also called the Hexagonal Architecture) and demonstrate how to refactor legacy code or design new systems using this approach. You’ll learn how to organize your domain logic and move UI and infrastructure code into appropriate places within the architecture. The session will also cover practical refactoring techniques using IntelliJ and how to apply Domain Driven Design (DDD) principles to ensure your system is scalable, maintainable, and well-structured.
What is Hexagonal Architecture?
Understand the fundamental principles of Hexagonal Architecture, which helps isolate the core business logic (the domain) from external systems like databases, message queues, or user interfaces. This architecture is designed to easily modify the external components without affecting the domain.
What are Ports and Adapters?
Learn the key concepts of Ports and Adapters, the core elements of Hexagonal Architecture. Ports define the interface through which the domain interacts with the outside world, while Adapters implement these interfaces and communicate with external systems.
Moving Domain Code to Its Appropriate Location:
Refactor your domain code to ensure it is correctly placed in the core domain layer. You will learn how to separate domain logic from external dependencies, ensuring that business rules are isolated and unaffected by user interface or infrastructure changes.
Moving UI Code to Its Appropriate Location:
Discover how to refactor UI code by decoupling it from the domain logic and placing it in the appropriate layers. You’ll learn how to use the Ports and Adapters pattern to allow the user interface to communicate with the domain without violating architectural boundaries.
Using Refactoring Tools in IntelliJ:
Learn how to use IntelliJ’s powerful refactoring tools to streamline code movement. Techniques such as Extract Method, Move Method, Extract Delegate, and Extract Interface will be applied to refactor your codebase.
Applying DDD Software Principles:
We’ll cover essential Domain-Driven Design principles, such as Value Objects, Entities, Aggregates, and Domain Events.
Refactoring Techniques:
Learn various refactoring strategies to improve code structure, Extract Method, Move Method, Extract Delegate, Extract Interface, and Sprout Method and Class
Verifying Code with Arch Unit:
Ensure consistency and package rules using Arch Unit, a tool for verifying the architecture of your codebase. You will learn how to write tests confirming your project adheres to the desired architectural guidelines, including separating layers and boundaries.
This workshop is perfect for developers who want to improve their understanding of Ports and Adapters Architecture, apply effective refactoring techniques, and leverage DDD principles for designing scalable and maintainable systems.
If you wish to do the interactive labs:
This workshop will explore the principles of the Ports and Adapters pattern (also called the Hexagonal Architecture) and demonstrate how to refactor legacy code or design new systems using this approach. You’ll learn how to organize your domain logic and move UI and infrastructure code into appropriate places within the architecture. The session will also cover practical refactoring techniques using IntelliJ and how to apply Domain Driven Design (DDD) principles to ensure your system is scalable, maintainable, and well-structured.
What is Hexagonal Architecture?
Understand the fundamental principles of Hexagonal Architecture, which helps isolate the core business logic (the domain) from external systems like databases, message queues, or user interfaces. This architecture is designed to easily modify the external components without affecting the domain.
What are Ports and Adapters?
Learn the key concepts of Ports and Adapters, the core elements of Hexagonal Architecture. Ports define the interface through which the domain interacts with the outside world, while Adapters implement these interfaces and communicate with external systems.
Moving Domain Code to Its Appropriate Location:
Refactor your domain code to ensure it is correctly placed in the core domain layer. You will learn how to separate domain logic from external dependencies, ensuring that business rules are isolated and unaffected by user interface or infrastructure changes.
Moving UI Code to Its Appropriate Location:
Discover how to refactor UI code by decoupling it from the domain logic and placing it in the appropriate layers. You’ll learn how to use the Ports and Adapters pattern to allow the user interface to communicate with the domain without violating architectural boundaries.
Using Refactoring Tools in IntelliJ:
Learn how to use IntelliJ’s powerful refactoring tools to streamline code movement. Techniques such as Extract Method, Move Method, Extract Delegate, and Extract Interface will be applied to refactor your codebase.
Applying DDD Software Principles:
We’ll cover essential Domain-Driven Design principles, such as Value Objects, Entities, Aggregates, and Domain Events.
Refactoring Techniques:
Learn various refactoring strategies to improve code structure, Extract Method, Move Method, Extract Delegate, Extract Interface, and Sprout Method and Class
Verifying Code with Arch Unit:
Ensure consistency and package rules using Arch Unit, a tool for verifying the architecture of your codebase. You will learn how to write tests confirming your project adheres to the desired architectural guidelines, including separating layers and boundaries.
This workshop is perfect for developers who want to improve their understanding of Ports and Adapters Architecture, apply effective refactoring techniques, and leverage DDD principles for designing scalable and maintainable systems.
If you wish to do the interactive labs:
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.
This session will focus on data governance and making data available within your enterprise. Who owns the data, how do we obtain the data, and what does governance look like?
Domain Driven Design has been guiding large development projects since 2003, when the seminal book by Eric Evans came out. Domain Driven Design is split up into two parts: Strategic and Tactical. One of the issues is that the Strategic part becomes so involved and intense that we lose focus on implementing these sorts of things. This presentation swaps this focus as topic pairs. For example, when we create a bounded context, is that a microservice or part of the subdomain? When we create a domain event, what does that eventually become? How do other tactical patterns fit into what we decide in the strategic phase?
In this workshop, we will break it down into pairs of topics.
In this workshop, we will perform the following activities
Domain Driven Design has been guiding large development projects since 2003, when the seminal book by Eric Evans came out. Domain Driven Design is split up into two parts: Strategic and Tactical. One of the issues is that the Strategic part becomes so involved and intense that we lose focus on implementing these sorts of things. This presentation swaps this focus as topic pairs. For example, when we create a bounded context, is that a microservice or part of the subdomain? When we create a domain event, what does that eventually become? How do other tactical patterns fit into what we decide in the strategic phase?
In this workshop, we will break it down into pairs of topics.
In this workshop, we will perform the following activities
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.
As digital ecosystems evolve at breakneck speed, enterprises must reimagine their architectural blueprints—not as static diagrams, but as adaptive, intelligence-driven systems. This talk offers a compelling preview of Enterprise Architecture 4.0, weaving together cutting-edge technologies, strategic foresight, and practical frameworks to prepare architects and technology leaders for the next wave of transformation.
We begin by exploring how Generative AI, Assistive Agents, Predictive Analytics, and Copilot GPTs can be embedded into modern architectures—turning traditional systems into living, learning ecosystems. Attendees will gain foundational knowledge of RAG (Retrieval-Augmented Generation), vector databases, and graph databases—critical for context-aware reasoning, personalization, and intelligent data processing.
Then, using the Gartner Emerging Tech Impact Radar as our compass, we explore the innovations reshaping enterprise software over the next 3–5 years:
Emerging Technologies Shaping the Future
Generative AI & GPT Agents: Beyond code generation—autonomous reasoning, AI coaching, and domain-specific copilots.
Vector & Graph Databases: Powering search, personalization, and relationship-aware AI.
Augmented & Virtual Reality (AR/VR): Enhancing training, field ops, and immersive collaboration.
Edge Computing: Enabling low-latency intelligence and decentralized decision-making at the enterprise edge.
AI/ML at Scale: Mitigating bias, enforcing AI ethics, and integrating ML into business operations.
Blockchain: Ensuring data integrity, supply chain transparency, and smart contract automation.
Autonomous Agents & Advanced Automation: Automating complex workflows through intelligent, multi-modal agents.
We highlight how Enterprise Architecture becomes the navigation system for these innovations—ensuring alignment with business strategy, reducing technical debt, and unlocking agility and resilience.
Key Takeaways & Outcomes
By the end of this session, attendees will:
Understand the strategic shift toward Enterprise Architecture 4.0 and why it’s essential—not optional.
Gain a preview of patterns, principles, and tools to be explored in the 2-day workshop, including AI-first frameworks and modular architectures.
Learn how to integrate emerging technologies like GPT agents, vector search, blockchain, and AR/VR into a unified roadmap.
Discover how to elevate the EA function—from compliance-oriented governance to future-shaping innovation leadership.
Whether you’re preparing for next-gen AI systems, scaling automation, or future-proofing your enterprise strategy, this talk provides the preview and perspective you need to lead with confidence into the AI-driven future.
Mastering the AI-First System Design Methodology is a must-attend talk for developers and architects seeking to elevate their system design capabilities in the era of intelligent systems. In this dynamic 90-minute session, attendees will embark on a comprehensive journey through the foundational principles of modern system design—now reimagined for AI integration—with a practical focus on the C4 model and its application to AI-enabled architectures.
This session is designed to equip professionals with the frameworks and tools necessary to build scalable, efficient, AI-aware systems that deliver lasting impact in a rapidly evolving digital ecosystem.
We'll begin by exploring the critical importance of understanding business requirements and stakeholder intent—an essential step in designing systems that align human values with machine intelligence. From there, we’ll guide attendees through a structured, AI-augmented design methodology: from stakeholder engagement and context modeling to system decomposition and refinement using LLMs and generative AI assistants.
Each stage will be brought to life with real-world examples, hands-on exercises, and interactive discussions—demonstrating how AI can accelerate ideation, automate documentation, optimize decisions, and identify design flaws early in the process.
Special focus will be given to incorporating empathy maps, value chain analysis, and customer journey mapping, enhanced with AI-driven pattern recognition and predictive insights. These tools enable deeper understanding of user behavior and business dynamics, resulting in more responsive and adaptive system architectures.
Whether you're a seasoned architect embracing AI-driven transformation or a developer ready to future-proof your design thinking, this talk will deliver actionable insights into building robust, intelligent, and human-centric systems. Join us to reimagine system design through the lens of AI—and become a key innovator in your organization’s AI-first journey.
The Importance of System Design
Overview of System Design Methodology
Deep Dive into the Methodology Stages
* Engage with Business Stakeholders
* Techniques for engagement and prioritization
* Case Study: A startup's journey to understand market needs
* Identify Vital Business Capabilities
* Mapping business capabilities
* Case Study: Streamlining operations for a logistics company
* Understand the Internal and External Personas
* Using empathy maps and customer journey mapping
* Case Study: Designing a healthcare app with patient and provider personas
* Develop a New Value Proposition
* Crafting value propositions
* Case Study: Innovating retail experience with a new e-commerce platform
* Define Solution Architecture
* Detailing architecture and capability modules
* Case Study: Architectural overhaul for a financial services firm
* Define Component Process Flows
* Visualizing interactions and process flows
* Case Study: Enhancing the order fulfillment process for an online retailer
* Review, Refine, and Finalize
* Consolidating insights and preparing for implementation
* Case Study: Finalizing and launching a new feature for a social media platform
As an architect you rely on your knowledge and the skills of your team to create an appropriate architecture to meet the needs of your applications. However, in spite of our creativity, it is hard for us as humans to think through various scenarios that could potentially lead to issues down the lane. This is where prudent use of AI tools can help us in proactively identifying problems and incorporating solutions into our architectures.
This presentation will taken an example driven approach to humanAI collaboration to create architectures.
Not every application needs high performance and not in every single part. However, where performance is critical, taking bruteforce approach to bring in speed often does not help.
In this presentation we will discuss the lessons learned from working with high performance systems, things that caused slowdown on scale and measures we can take to provide speed where it is essential.
If your team is tasked with transitioning from Monoliths to either Modular Monoliths or Microservices, splitting the application code, as tiring as it could be, is relatively easy when compared to dealing with data.
In this presentation we will discuss the various aspects of data modeling and the consequences of choosing the right models to fit the architectures for the application.
Plan for failures is a well known fact, but the question is how? Use circuit breakers, build timeouts, sure we know those concepts, but those are easily said than done.
In this presentation we will get down to the nittygritty details on how to build for resilience, things we should evaluate, consider, measure, monitor, adjust, and evolve in order to make sure the mission critical systems we build are truly resilient.
The ability to test a system is not accidental, it is a deliberate action that we have to bake into a system. The benefits of rapid feedback we gain from tests is significant, whereas the consequences for the inability to test is huge.
In this presentation we will discuss the reasons to build for testability, the approaches we can take, the tools we can use to support our efforts, and how to guide a team along to realize good feedback loops.
Have you ever created a single blob of an application where there were no parts to communicate between? Not in the past 50 years. So, then what does it mean to create a monolith vs. a distributed application? When should we choose one over the other. What are the consequences of choosing one over the other.
In this presentation, rather than thinking about these as good or bad, we will evaluate the reasons, benefits, and consequences of choosing different architectures and why you should evaluate these when creating architectures for your own applications.
Graph technology has emerged as the fastest-growing sector in database systems over the past decade—and now, it's at the heart of AI transformation. This talk explores the strategic imperative of mastering graph technologies for professionals designing intelligent systems, optimizing codebases, and architecting future-ready enterprises.
Mastering graph databases, knowledge graphs, and advanced algorithms is no longer a niche skill—it's foundational to enabling AI use cases, powering semantic search, driving recommendation engines, and orchestrating Retrieval-Augmented Generation (RAG) with high precision.
In this comprehensive session, we'll explore high-level graph algorithms that form the backbone of modern, complex systems and discuss how these algorithms are integral to the architecture of efficient graph databases. We will delve into the advanced functionalities and strategic implementations of knowledge graphs, illustrating their essential role in integrating disparate data sources, empowering AI applications including generative AI, and enhancing business intelligence.
Join us to navigate the complexities and opportunities this dynamic field presents, ensuring you remain at the cutting edge of technology and continue to drive significant advancements in your projects and enterprises.
What You’ll Learn:
Advanced Graph Algorithms
Concise review of key graph theory concepts tailored for AI and data engineers.
Application of algorithms like Greedy, Dijkstra's, Bellman-Ford, and PageRank for real-world graph optimization, pathfinding, and influence modeling.
Graph Database Architecture
Comparison of graph vs. relational models for large-scale, interconnected data.
Best practices in data modeling, indexing, and query performance tuning in platforms like Neo4j, TigerGraph, and Amazon Neptune.
Mastery of Knowledge Graphs
How to build and scale enterprise-grade knowledge graphs for semantic search, personalization, and intelligent recommendations.
Role of ontologies, entities, and relationships in structuring organizational knowledge.
Graph-RAG and AI-Enhanced Use Cases
Deep dive into Graph-RAG (Graph-enhanced Retrieval-Augmented Generation): combining structured knowledge graphs with unstructured retrieval to power trustworthy, explainable generative AI.
Use cases:
Domain-specific copilots with traceable knowledge lineage.
AI assistants that reason over connected knowledge.
Compliance-aware search and recommendations.
Customer 360 + Agent 360 views for enterprise workflows.
Case Studies and Future Technologies
Real-world case studies of graph adoption in healthcare, finance, e-commerce, and public sector AI.
Preview of emerging trends:
Graph Neural Networks (GNNs)
Hybrid vector–graph databases
Multimodal reasoning over structured + unstructured data
Outcomes & Takeaways:
By the end of this session, you will:
Understand why graph mastery is foundational for AI and system innovation.
Learn to architect performant, scalable graph systems for enterprise use.
See how Graph-RAG bridges structured knowledge and LLMs to deliver smarter AI assistants.
Be equipped to apply graph technologies to drive innovation, efficiency, and AI trustworthiness in your own organization.
Over the next three years, the enterprise stack is being reshaped by Agentic AI, AI governance platforms, disinformation security, hybrid/spatial computing, and post-quantum cryptography. This talk gives architects a concrete operating model to turn those trends into roadmaps, controls, and shipped value. You’ll learn how to design an agentic platform (MCP + LangGraph), evolve from RAG to GraphRAG with evaluation harnesses, stand up an ISO/IEC 42001-aligned AI management system using the NIST AI RMF Generative AI Profile, prepare for EU AI Act phasing, harden LLM/agent security with OWASP controls, adopt confidential computing for private inference, measure cost & carbon with the Software Carbon Intensity (SCI) standard, and roll out a PQC-ready crypto plan (FIPS 203/204/205). We close with a 90-day activation plan and a 3-year EA roadmap template.
Why join
Who it’s for
Enterprise/Software Architects, Platform/AI Leads, Software Engineers, Security & Compliance partners.
What you’ll take away (outcomes)
Join us for an immersive journey into the heart of modern cybersecurity challenges. In this groundbreaking talk, we delve into the intricacies of securing your digital assets with a focus on three critical domains: applications, APIs, and Large Language Models (LLMs).
As developers and architects, you understand the paramount importance of safeguarding your systems against evolving threats. Our session offers an exclusive opportunity to explore the industry-standard OWASP Top 10 vulnerabilities tailored specifically to your domain.
Uncover the vulnerabilities lurking within your applications, APIs, and LLMs, and gain invaluable insights into mitigating risks and fortifying your defenses. Through live demonstrations and real-world examples, you'll witness firsthand the impact of security breaches and learn proactive strategies to combat them.
Whether you're a seasoned architect seeking to fortify your organization's security posture or a developer striving to build resilient systems, this talk equips you with the knowledge and tools essential for navigating the complex landscape of cybersecurity.
Agenda
OWASP Top 10 Overview
OWASP Top 10 for Application Security
OWASP Top 10 for API Security
OWASP Top 10 for LLM Applications (Large Language Models)
Q&A and Discussion
Conclusion
In the age of digital transformation, Cloud Architects emerge as architects of the virtual realm, bridging innovation with infrastructure. This presentation offers a comprehensive exploration of the Cloud Architect's pivotal role.
Delving into cloud computing models, architecture design, and best practices, attendees will gain insights into harnessing the power of cloud technologies. From optimizing scalability and ensuring security to enhancing efficiency and reducing costs, this session unravels the strategic decisions and technical expertise that define a Cloud Architect's journey. Join us as we decode the nuances of cloud architecture, illustrating its transformative impact on businesses in the modern era.
In the realm of architecture, principles form the bedrock upon which innovative and enduring designs are crafted. This presentation delves into the core architectural principles that guide the creation of structures both functional and aesthetic. Exploring concepts such as balance, proportion, harmony, and sustainability, attendees will gain profound insights into the art and science of architectural design. Through real-world examples and practical applications, this session illuminates the transformative power of adhering to these principles, shaping not only buildings but entire environments. Join us as we unravel the secrets behind architectural mastery and the principles that define architectural brilliance.
Good architectural principles are fundamental guidelines or rules that inform the design and development of software systems, ensuring they are scalable, maintainable, and adaptable. Here are some key architectural principles that are generally considered valuable in software development:
Adhering to these architectural principles can lead to the development of robust, maintainable, and adaptable software systems that meet the needs of users and stakeholders effectively.
TBD
TBD
In the ever-changing landscape of technology, Solution Architects stand as the linchpin between complex business challenges and innovative technological solutions. This presentation dives deep into the world of Solution Architects, exploring their pivotal role in crafting tailored, efficient, and scalable solutions. From deciphering intricate business requirements to orchestrating seamless integrations, Solution Architects navigate a maze of technologies to deliver outcomes that align perfectly with organizational goals. Join us as we unravel the key responsibilities, skills, and methodologies that empower Solution Architects to transform abstract ideas into tangible, impactful solutions, shaping the future of businesses in a digital age.
In this session we will walk thru the following:
Whether you are an existing Solution Architect looking to hone or validate your skills or you are looking to get into the role of Solution Architect, this session is for you!
Awareness is the knowledge or perception of a situation or fact, which based on myriad of factors is an elusive attribute. Likely the most significant unasked for skill… perhaps because it's challenging to “measure” or verify. It is challenging to be aware of aware, or is evidence of it's adherence. This session will cover different levels of architectural awareness. How to surface awareness and how you might respond to different technical situations once you are aware.
Within this session we look holistically an engineering, architecture and the software development process. Discussing:
* Awareness of when process needs to change (original purpose of Agile)
* Awareness of architectural complexity
* Awareness of a shift in architectural needs
* Awareness of application portfolio and application categorization
* Awareness of metrics surfacing system challenges
* Awareness of system scale (and what scale means for your application)
* Awareness when architectural rules are changing
* Awareness of motivation for feature requests
* Awareness of solving the right problem
The focus of the session will be mindful (defined as focusing on one's awareness), commentating in sharing strategies for heightening awareness as an architect and engineer.
The organization has grown and one line of business has become 2 and then 10. Each line of business is driving technology choices based on their own needs. Who and how do you manage alignment of technology across the entire Enterprise… Enter Enterprise Architecture! We need to stand up a new part of the organization.
This session will define the role of architects and architectures. We will walk through a framework of starting an Enterprise Architecture practice. Discussions will include:
Modern architecture consists of complex, interconnected systems that exhibit both positive and negative emergent behaviors. As a result, traditional reductionist approaches to analysis and design are insufficient for defining precise requirements, designing distributed systems, or identifying root causes in production. In today’s landscape, it is crucial for architects to understand and apply Systems Thinking.
This session offers an introduction to Systems Thinking, covering key definitions, techniques, models, and patterns. It also demonstrates how Systems Thinking is applied to architecture through practical examples. Prezi Presentation
Software architecture involves inherent trade-offs. Some of these trade-offs are clear, such as performance versus security or availability versus consistency, while others are more subtle, like resiliency versus affordability. This presentation will discuss various architectural trade-offs and strategies for managing them.
The role of a technical lead or software architect is to design software that fulfills the stakeholders' vision. However, as the design progresses, conflicting requirements often arise, affecting the candidate architecture. Resolving these conflicts typically involves making architectural trade-offs (e.g. service granularity vs maintainability). Additionally, with time-to-market pressures and the need to do more with less, adopting comprehensive frameworks like TOGAF or lengthy processes like ATAM may not be feasible. Therefore, it is crucial to deeply understand these architectural trade-offs and employ lightweight resolution techniques. Prezi Presentation
No matter the techniques used to make enterprise solutions Highly Available (HA), failure is inevitable at some point. Resiliency refers to how quickly a system reacts to and recovers from such failures. This presentation discusses various architectural resiliency techniques and patterns that help increase Mean Time to Failure (MTTF), also known as Fault Tolerance, and decrease Mean Time to Recovery (MTTR).
Failure of Highly Available (HA) enterprise solutions is inevitable. However, in today's highly interconnected global economy, uptime is crucial. The impact of downtime is amplified when considering Service Level Agreement (SLA) penalties and lost revenue. Even more damaging is the harm to an organization's reputation as frustrated customers express their grievances on social media. Resiliency, often overlooked in favor of availability, is essential. Prezi Presentation
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!
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!
Integration, once a luxury, is now a necessity. Doing this well, however, continues to be elusive. Early attempts to build better distributed systems such as DCOM, CORBA, and SOAP were widely regarded as failures. Today the focus is on REST, RPC, and graphql style APIs.
Which is best? The goto answer for architects is, of course, “it depends.”
In this session, we look at the various API approaches, how they attempt to deal with the challenge of decoupling client from server, evolvability, extensibility, adaptability, composability.
The biggest challenge is that needs change over time, and APIs must necessarily evolve. Versioning is challenging, and breaking changes are inevitable. You'll leave this session with a highlevel understanding of these approach, their respective tradeoffs and ultimately how to align your API approach with your architectural and organizational goals.
The difference between a junior and a senior dev isn't coding skills. A developer's coding skills are just their ante; necessary to get into the game but, like an ante, they only get you into the game.
Everything that happens from that point on depends on what else you bring to the table.
In this session, we explore the key skills necessary to make an impact, be effective, and will ultimately pave the way to grow into senior/principal level developers and architects.
If you are getting tired of the appearance of new types of databases… too bad. We are increasingly relying on a variety of data storage and retrieval systems for specific purposes. Data does not have a single shape and indexing strategies that work for one are not necessarily good fits for others. So after hierarchical, relational, object, graph, columnoriented, document, temporal, appendonly, and everything else, get ready for Vector Databases to assist in the systematization of machine learning systems.
This will be an overview of the benefits of vectors databases as well as an introduction to the major players.
We will focus on open source versus commercial players, hosted versus local deployments, and the attempts to add vector search capabilities to existing storage systems.
We will cover:
If you are getting tired of the appearance of new types of databases… too bad. We are increasingly relying on a variety of data storage and retrieval systems for specific purposes. Data does not have a single shape and indexing strategies that work for one are not necessarily good fits for others. So after hierarchical, relational, object, graph, columnoriented, document, temporal, appendonly, and everything else, get ready for Vector Databases to assist in the systematization of machine learning systems.
This will be an overview of the benefits of vectors databases as well as an introduction to the major players.
We will focus on open source versus commercial players, hosted versus local deployments, and the attempts to add vector search capabilities to existing storage systems.
We will cover:
We have seen how Retrieval Augmented Generation (RAG) systems can help prop up Large Language Models (LLMs) to avoid some of their worst tendencies. But that is just the beginning. The cutting edge stateoftheart systems are Multimodal and Agentic, involving additional models, tools, and reusable agents to break problems down in separate pieces, transform and aggregate the results, and validate the results before returning them to the user.
Come get introduced to some of the latest and greatest techniques for maximizing the value of your LLMbased systems while minimizing the risk.
We will cover:
We have seen how Retrieval Augmented Generation (RAG) systems can help prop up Large Language Models (LLMs) to avoid some of their worst tendencies. But that is just the beginning. The cutting edge stateoftheart systems are Multimodal and Agentic, involving additional models, tools, and reusable agents to break problems down in separate pieces, transform and aggregate the results, and validate the results before returning them to the user.
Come get introduced to some of the latest and greatest techniques for maximizing the value of your LLMbased systems while minimizing the risk.
We will cover:
Large Language Models (LLMs) such as ChatGPT and Llama have impressed us with what they can do. They have also horrified us with what they actually do when they are employed with no protection: hallucinations, stale knowledge bases, no conceptual basis for reasoning, and a capacity for toxic and inappropriate content generation. Rather than avoid them altogether or risk legal liability or brand damage, we can put some guardrails around them to benefit from their best traits without fearing their worst.
Retrieval Augmented Generation (RAG) systems augment the process to make it behave more to our liking. Come hear what you can do to benefit from AI systems without fearing them.
We will cover examples using LangChain and LlamaIndex, two open source frameworks for working with LLMs and creating RAG infrastructure.
We will cover:
Introduction to LLMs
Risks and Limitations
Basic RAG Systems
Embeddings
Vector Databases
Prompt Engineering
Testing and Validating LLMs and RAG Systems
Advanced Techniques
AI as Judge
Large Language Models (LLMs) such as ChatGPT and Llama have impressed us with what they can do. They have also horrified us with what they actually do when they are employed with no protection: hallucinations, stale knowledge bases, no conceptual basis for reasoning, and a capacity for toxic and inappropriate content generation. Rather than avoid them altogether or risk legal liability or brand damage, we can put some guardrails around them to benefit from their best traits without fearing their worst.
Retrieval Augmented Generation (RAG) systems augment the process to make it behave more to our liking. Come hear what you can do to benefit from AI systems without fearing them.
We will cover examples using LangChain and LlamaIndex, two open source frameworks for working with LLMs and creating RAG infrastructure.
We will cover:
Introduction to LLMs
Risks and Limitations
Basic RAG Systems
Embeddings
Vector Databases
Prompt Engineering
Testing and Validating LLMs and RAG Systems
Advanced Techniques
AI as Judge
“By 2030, 80 percent of heritage financial services firms will go out of business, become commoditized, or exist only formally but not competing effectively”, predicts Gartner.
This session explores the integration of AI, specifically ChatGPT, into cloud adoption frameworks to modernize legacy systems. Learn how to leverage AWS Cloud Adoption Framework (CAF) 3.0, Microsoft Cloud Adoption Framework for Azure, and Google Cloud Adoption Framework to build cloud-native architectures that maximize scalability, flexibility, and security. Designed for architects, technical leads, and senior IT professionals, this talk provides actionable insights and strategies for successful digital transformation.
Cloud adoption frameworks are essential for accelerating digital business transformation by leveraging the power of cloud technologies. This talk will guide you through the AWS Cloud Adoption Framework (CAF) 3.0, Microsoft Cloud Adoption Framework for Azure, and Google Cloud Adoption Framework, focusing on building cloud-native architectures that ensure scalability, flexibility, and security.
The session will delve into the strategic role of AI, particularly ChatGPT, in modernizing legacy systems. By understanding and implementing these frameworks, you will learn to navigate the complexities of transitioning from legacy systems to modern cloud-based architectures. This talk will provide practical steps and real-world case studies to help you effectively plan and execute your cloud adoption strategy.
Legacy systems can be assets and obstacles, providing reliable functionality but often becoming burdensome to maintain and evolve. In this talk, we will confront the challenges of working with legacy architectures and discover the strategic approaches for modernization. By examining the benefits and risks of incremental migration versus full system rewrites, attendees will learn the most suitable path for their unique situations.
Through practical examples and case studies, we will explore how successful organizations have revitalized their aging architectures, preserving the value of legacy investments while embracing innovation and adaptability. From small-scale legacy components to large-scale monolithic systems, we'll cover diverse modernization scenarios, allowing participants to glean insights applicable to their projects.
Whether your organization is facing budget constraints, a need for rapid modernization, or concerns about maintaining critical functionality, this talk offers a comprehensive guide to navigating the legacy landscape and crafting a roadmap to rejuvenate aging architectures.
Participants will leave this session equipped with a robust understanding of how to leverage AI, particularly ChatGPT, in the context of legacy system modernization. You will gain strategic insights, practical tools, and actionable knowledge to lead your teams and projects towards successful, AI-enhanced modernization efforts, ensuring your organization remains competitive and agile in a rapidly evolving digital landscape.
On the one hand, Machine Learning (ML) and AI Systems are just more software and can be treated as such from our development efforts. On the other hand, they behave very differently and our capacity to test, verify, validate, and scale them requires a different set of perspectives and skills.
This presentation will walk you through some of these unexpected differences and how to plan for them. No specific background in ML/AI is required, but you are encouraged to be generally aware of these fields. The AI Crash Course would be a good start.
We will cover:
Matching Capabilities to Needs
Performance Tuning
Vector Databases
Testing Strategies
MLOPs/AIOps Techniques
Evolving these Systems Over Time
On the one hand, Machine Learning (ML) and AI Systems are just more software and can be treated as such from our development efforts. On the other hand, they behave very differently and our capacity to test, verify, validate, and scale them requires a different set of perspectives and skills.
This presentation will walk you through some of these unexpected differences and how to plan for them. No specific background in ML/AI is required, but you are encouraged to be generally aware of these fields. The AI Crash Course would be a good start.
We will cover:
Matching Capabilities to Needs
Performance Tuning
Vector Databases
Testing Strategies
MLOPs/AIOps Techniques
Evolving these Systems Over Time
In an era where digital transformation and AI adoption are accelerating across every industry, the need for consistent, scalable, and robust APIs has never been more critical. AI-powered tools—whether generating code, creating documentation, or integrating services—rely heavily on clean, well-structured API specifications to function effectively. As teams grow and the number of APIs multiplies, maintaining design consistency becomes a foundational requirement not just for human developers, but also for enabling reliable, intelligent automation. This session explores how linting and reusable models can help teams meet that challenge at scale.
We will explore API linting using the open-source Spectral project to enable teams to identify and rectify inconsistencies during design. In tandem, we will navigate the need for reusable models—recognizing that the best specification is the one you don’t have to write or lint at all! These two approaches not only facilitate the smooth integration of services but also foster collaboration across teams by providing a shared, consistent foundation.
Modern HTTP APIs power today’s connected world, acting as the core interface not only for developers, but also for the ever-growing ecosystem of machines, services, and now AI agents. As every organization is increasingly expected to produce and consume APIs at scale, the ability to design, build, deploy, and operate consistent, high-quality APIs has become a key competitive differentiator. With AI accelerating the need for composable, well-structured, and discoverable interfaces, API maturity is no longer optional—it’s essential. However, building and scaling effective API Design First practices across an enterprise is still fraught with manual processes, inconsistent standards, and slow governance models. To succeed, organizations must reimagine API Governance as a strategic enabler—one that prioritizes collaboration, stewardship, and automation.
In this session, we’ll explore the core stages of the API design lifecycle and share how to implement practical, modern governance models that increase productivity without sacrificing control. Drawing on real-world examples from SPS Commerce, as well as off-the-shelf tooling and custom solutions, we’ll show how to align your teams, accelerate delivery, and produce APIs that are robust, reusable, and ready for both human and AI consumers.
Embarking on the journey to become an architect requires more than technical expertise; it demands a diverse skill set that combines creativity, leadership, communication, and adaptability. You may be awesome as a developer or engineer, but the skills needed to be an architect are often different and require more than technical awareness to succeed.
This presentation delves into the crucial skills aspiring architects need to cultivate. From mastering design principles and embracing cutting-edge technologies to honing collaboration and project management abilities, attendees will gain valuable insights into the multifaceted world of architectural skills. Join us as we explore practical strategies, real-world examples, and actionable tips that pave the way for aspiring architects to thrive in a dynamic and competitive industry.
Security problems empirically fall into two categories: bugs and flaws. Roughly half of the problems we encounter in the wild are bugs and about half are design flaws. A significant number of the bugs can be found through automated testing tools which frees you up to focus on the more pernicious design issues.
In addition to detecting the presence of common bugs, however, we can also imagine automating the application of corrective refactoring. In this talk, I will discuss using OpenRewrite to fix common security issues and keep them from coming back.
In this talk we will focus on:
Using OpenRewrite to automatically identify and fix known security vulnerabilities.
Integrating security scans with OpenRewrite for continuous improvement.
*Free up your time to address larger concerns by addressing the pedestrian but time-consuming security bugs.
Not every application needs high performance and not in every single part. However, where performance is critical, taking bruteforce approach to bring in speed often does not help.
In this presentation we will discuss the lessons learned from working with high performance systems, things that caused slowdown on scale and measures we can take to provide speed where it is essential.
Internal Developer Portals are revolutionizing how teams streamline workflows, enhance developer experience, and boost productivity. As AI begins to weave deeper into engineering workflows, having structured, reliable SDLC data becomes essential to unlock its full potential. But for medium-sized organizations with limited resources, the path to success is unclear and fraught with challenges. Simply mimicking or using industry frameworks like Spotify Backstage might seem like a shortcut, but without a clear vision and strategy, it can lead to frustration and failure.
This talk dives into how to build a successful Internal Developer Portal tailored to your unique needs. We'll explore critical steps: making a compelling business case, navigating the buy-versus-build dilemma, designing scalable architectures, driving adoption, and measuring impact in meaningful ways. Packed with actionable insights from SPS Commerce’s journey—the force behind the world’s largest retail network—you'll gain a roadmap to reduce cognitive load, empower your teams, and align your engineering practices with business goals. Whether you're starting fresh or refining an existing portal, this session will equip you to achieve big wins, even on a lean budget.
Organizations increasingly see their aging technology and data architecture as a liability, at odds with their desired outcomes of engaging customer experiences, fast delivery speed and operational efficiency. So, how are organizations modernizing their legacy architecture and transforming it into a competitive advantage? What role is strategic Domain-Driven Design (DDD) playing in this transformation and how can it help organizations like yours?
In this talk, Ryan shares why architecture modernization is critical for today’s organizations and then shows real-life before / after designs from organizations using Strategic DDD to modernize their applications, data platforms and cloud infrastructure. Using real-world examples, Ryan highlights the key DDD concepts used in modernization and explains how to get started with a Domain-Driven Discovery approach. This talk is for anyone interested in seeing real-life examples of how to modernize architecture using DDD and turn a liability into a competitive advantage.
When modernizing architecture, quickly discovering the current users, systems and their dependencies is a critical starting point. Unfortunately, accurate documentation rarely exists. When it does, it’s confusing and at the wrong level. More often than not, accurate architecture details are locked in people’s heads and not written down anywhere. So, how might we create an accurate view of the current software architecture quickly while also having fun with our team?
This session teaches you how to facilitate a pair of workshops to uncover and visually document any collection of software systems in fun and engaging ways. Based on the Miro Discover Systems with the C4 Model template, you will learn how to help your teams translate isolated tribal knowledge into a collective view of the architecture that anyone can understand. Learn the tips and tricks for taking something boring - like creating system documentation - and turning it into a fun activity where everyone can participate and learn!
“Humans became behaviourally modern the moment they committed to storing abstract information outside their brains.” —Lyn Wadley
As architects, we often bridge the gaps that exist between all of the teams and stakeholders involved in the success or failure of a system. Because of this, information is hitting us from every direction. How we capture, organize, distill, and express this information is critical to our own success or failure.
Unfortunately, while excellent at abstract thinking, our brains are equally terrible at random recall. What we need is a second brain that excels at providing us with the right information at the right time. In this session, we're going to learn Digital Knowledge Management workflows and tools that will help us build and use that second brain.
In this architectural kata, you will step into the shoes of a software architect tasked with designing a modern healthcare management system for a rapidly growing provider, MedBest.
The challenge is to create a system that integrates patient records, appointment scheduling, billing, and telemedicine while ensuring robust security, compliance with regulations, scalability, and cost efficiency.
2025 shattered the old cadence of software architecture. AI agents now co‑author code and refactors, compliance expectations tightened, and cost/latency signals moved inside everyday design loops. Static diagrams, quarterly review boards, and slide-driven governance can’t keep up.
This curated set of 3 sessions will help equip senior technologists to evolve from document stewardship to adaptive integrity management—blending human judgment, executable principles, and guided agent assistance.Architecture is shifting from static designs to adaptive, agent-driven execution.
Come to the Agentic Architect session if you want to see:
how the role of architecture is evolving in the agentic era
practical tips and trick for how to embrace the new agentic toolset
how to lean into architecture as code
cut decision time from weeks and days to hours
stop redrawing diagrams forever
“The Agentic Architect isn't about AI writing your code – it's about transforming how you make, communicate, and enforce architecture in an AI-accelerated world.”
2025 shattered the old cadence of software architecture. AI agents now co‑author code and refactors, compliance expectations tightened, and cost/latency signals moved inside everyday design loops. Static diagrams, quarterly review boards, and slide-driven governance can’t keep up.
This live demo session takes the patterns from “The Agentic Architect” and runs them end-to-end starting with a blank slate.
Watch ideas turn into working architecture
See diagrams-as-code that update themselves based on a more holistic context
Learn how to use AI agents on a daily basis to transform your work
2025 shattered the old cadence of software architecture. AI agents now co‑author code and refactors, compliance expectations tightened, and cost/latency signals moved inside everyday design loops. Static diagrams, quarterly review boards, and slide-driven governance can’t keep up.
2025 delivered unprecedented architectural disruption.
This interactive session will explore key events throughout 2025 that have impacted the architect's role in the context of AI ubiquity, platform acceleration, and cost pressures.
In the fast-paced world of software development, maintaining architectural integrity is a
continuous challenge. Over time, well-intended architectural decisions can erode, leading to unexpected drift and misalignment with original design principles.
This hands-on workshop will equip participants with practical techniques to enforce architecture decisions using tests. By leveraging architecturally-relevant testing, attendees will learn how to proactively guard their system's design, ensuring consistency, scalability, and security as the codebase evolves. Through interactive exercises and real-world examples, we will explore how testing can serve as a powerful tool for preserving architectural integrity throughout a project's lifecycle.
Key Takeaways
Participants will learn to:
Write architecture-driven tests that validate and enforce design constraints.
Identify architectural drift early and prevent unintended changes.
Maintain consistent, scalable, and secure architectures over time.
Collaborate effectively within teams to sustain architectural excellence.
Prerequisites
Basic Understanding of Software Architecture: Familiarity with architectural patterns and
principles
Experience with Automated Testing: Understanding of unit, integration, or system testing
concepts
Collaboration and Communication Skills: Willingness to engage in discussions and
teamwork
Experience working with Java
Optional
Familiarity with Static Analysis and Code Quality Tools: Knowledge of tools like ArchUnit,
SonarQube, or custom linters is beneficial but not required
Experience with Large-Scale Systems: Prior work on complex systems can enhance the
Key Takeaways:
Participants will learn to:
Write architecture-driven tests that validate and enforce design constraints.
Identify architectural drift early and prevent unintended changes.
Maintain consistent, scalable, and secure architectures over time.
Collaborate effectively within teams to sustain architectural excellence.
Prerequisites:
Basic Understanding of Software Architecture: Familiarity with architectural patterns and principles
Experience with Automated Testing: Understanding of unit, integration, or system testing concepts
Collaboration and Communication Skills: Willingness to engage in discussions and
teamwork
Experience working with Java
Optional
Familiarity with Static Analysis and Code Quality Tools: Knowledge of tools like ArchUnit,
SonarQube, or custom linters is beneficial but not required
Experience with Large-Scale Systems: Prior work on complex systems can enhance the
AI enablement isn’t buying Copilot and calling it done–it’s a system upgrade for the entire SDLC. Code completion helps, but the real bottlenecks live in reviews, testing, releases, documentation, governance, and knowledge flow. Achieving meaningful impact requires an operating model: guardrails, workflows, metrics, and change management; not a single tool.
This session shares SPS Commerce’s field notes: stories, failures, and working theories from enabling AI across teams. You’ll get a sampler of adaptable patterns and anti-patterns spanning productivity, systems integration, guardrails, golden repositories, capturing tribal knowledge, API design, platform engineering, and internal developer portals. Come for practical menus you can pilot next week—and stay to compare strategies with peers.
In today's rapidly evolving technological world, architects play pivotal roles in shaping the success of organizations. This presentation explores the diverse spectrum of architects, ranging from Enterprise Architects and Solution Architects to UX Architects and Security Architects. Delving into their unique responsibilities and expertise, this session sheds light on how these professionals align business objectives with technology, design innovative solutions, and ensure seamless integration. By understanding the multifaceted roles of architects, attendees will gain valuable insights into how these experts drive efficiency, foster innovation, and architect the future of modern enterprises.
This session will outline the importance of Architectural Roles by diving into different roles and responsibilities including the value that each role brings to larger enterprises. The roles that will be covered include:
In addition, We will take time to discuss common challenges faced by Architects.