AI has permanently transformed the role of Enterprise Architects. Traditional architectures built around data, applications, and integration are no longer enough. Modern intelligent systems rely on retrieval-augmented reasoning (RAG), relationship-driven graph reasoning (GraphRAG), and autonomous AI agents that must operate safely, predictably, and in alignment with business goals.
This full-day immersive workshop introduces the ARCHAI Blueprint, the first EA 4.0 framework that unifies:
– ARCHAI Fabric — enterprise knowledge & reasoning layer powered by RAG and GraphRAG
– ARCHAI Agents — assistive, autonomous, and cooperative agents with guardrails
– ARCHAI View — C4++ modeling for intelligent architectures
– ARCHAI Maturity Model — a 5-level roadmap toward the autonomous enterprise
Through storytelling, live architecture labs, and hands-on modeling, participants will learn how to design safe, scalable, AI-augmented enterprise architectures. You will build an end-to-end architecture for a realistic case study—ArchiMetal, a global manufacturing enterprise modernizing with AI.
By the end, you will not just understand RAG and GraphRAG—you will know how to embed them into production-grade enterprise architecture that is governable, observable, and future-proof.
⸻
KEY TAKEAWAYS
Participants will leave with the ability to:
Architect AI-Driven Knowledge Systems
•Design enterprise-scale RAG and GraphRAG pipelines
•Build knowledge fabrics that unify documents, graphs, embeddings & metadata
•Govern retrieval consistency, drift, safety, lineage & real-time updates
Model Intelligent Systems Using ARCHAI View
•Produce C0 → C3 diagrams (C4++ enhanced for AI)
•Model knowledge flows, agent interactions, guardrails & reasoning boundaries
Design and Govern Enterprise AI Agents
•Define agent roles, decisions, constraints, and safety boundaries
•Create multi-agent workflows across business domains
•Establish guardrail & observability architecture
Build AI-Augmented Business, Data, Application & Technology Architectures
•Extend TOGAF with AI reasoning-layer constructs
•Integrate RAG/GraphRAG into EA artifacts and capability maps
•Architect runtime platforms for inference, retrieval, safety & cost control
Create an EA 4.0 Roadmap Using the ARCHAI Maturity Model
•Assess enterprise readiness
•Identify transformation milestones across 5 maturity levels
•Build a 12–36 month strategic roadmap for intelligent systems adoption
Welcome & Foundations of EA 4.0
•Why enterprise architecture must evolve for AI
•Overview of the 5 ARCHAI components
•ARCHAI Blueprint
•ARCHAI View
•ARCHAI Fabric
•ARCHAI Agents
•ARCHAI Maturity Model
⸻
Session 1 — Architecture Vision
•The new Enterprise Knowledge & Reasoning Layer
•Why RAG/GraphRAG require architectural foundations
•Intelligent system context modeling (C0/C1)
•Introducing the ArchiMetal case study
⸻
Session 2 — Business Architecture for AI
•Mapping AI-driven capabilities and value streams
•Decision hotspots and agent opportunities
•Business capability redesign
•ARCHAI Maturity Model assessment
⸻
Session 3 — Data Architecture: ARCHAI Fabric
•Designing the knowledge layer (RAG + GraphRAG)
•Vector, graph, ontology, and metadata models
•Governance for retrieval, drift, lineage, and safety
•C2 modeling for the Fabric
⸻
Session 4 — Application Architecture: ARCHAI Agents
•Assistive, autonomous & cooperative agent patterns
•Agent decision boundaries and governance
•Multi-agent workflows & human-in-loop logic
•C2/C3 diagrams for agent flows
⸻
Session 5 — Technology Architecture
•AI & retrieval runtimes
•Guardrail and policy engines
•Observability for reasoning, retrieval, and agent behavior
•Technical standards for EA 4.0 systems
⸻
Session 6 — Integrated Architecture Lab
•Build the full ARCHAI Blueprint for ArchiMetal
•Create C0 → C3 diagrams (ARCHAI View)
•Design Fabric + agent ecosystem
•Map guardrails & governance
•Define the EA 4.0 transformation roadmap
⸻
Session 7 — Governance & Operating Model
•Knowledge governance (Fabric)
•Agent governance (charters, permissions, kill switches)
•Model & retrieval lifecycle governance
•Risk, compliance, auditability
•EA 4.0 operating model for intelligent systems
⸻
Session 8 — Future Trends & Roadmap
•Multi-modal RAG & graph fusion
•Enterprise agent meshes
•Intelligent twins & edge reasoning
•Autonomous governance
•3–5 year ARCHAI roadmap
⸻
Closing & Next Steps
•Recap of frameworks & deliverables
•EA transformation priorities for the next 90 days
•Certification and final Q&A
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
AI, agentic workflows, digital twins, edge intelligence, spatial computing, and blockchain trust are converging to reshape how enterprises operate.
This session introduces Enterprise Architecture 4.0—a practical, future-ready approach where architectures become intelligent, adaptive, and continuously learning.
You’ll explore the EA 4.0 Tech Radar, understand the six major waves of disruption, and learn the ARCHAI Blueprint—a structured framework for designing AI-native, agent-ready, and trust-centered systems.
Leave with a clear set of patterns and a 12-month roadmap for preparing your enterprise for the next era of intelligent operations.
⸻
KEY TAKEAWAYS
•Understand the EA 4.0 shift toward intelligent, agent-driven architecture
•Learn the top technology trends: AI, agents, edge, twins, spatial, blockchain, and machine customers
•See how the ARCHAI Blueprint structures AI-first design and governance
•Get practical patterns for agent safety, digital twins, trust, and ecosystem readiness
•Leave with a concise 12-month roadmap for implementing EA 4.0
⸻
AGENDA
– The Speed of Change
Why traditional enterprise architecture cannot support AI-native, agent-driven systems.
– The EA 4.0 Tech Radar
A 3–5 year outlook across:
•Agentic AI
•Edge intelligence
•Digital twins
•Spatial computing
•Trusted automation (blockchain)
•Machine customers
– The Six Waves of Transformation
Short deep dives into each wave with real enterprise use cases.
– The ARCHAI Blueprint
A clear architectural framework for AI-first enterprises:
•Attention & Intent Modeling
•Retrieval & Knowledge Fabric
•Capability & Context Models
•Human + Agent Co-working Patterns
•Action Guardrails & Safety
•Integration & Intelligence Architecture
This gives architects a single, unified design methodology across all emerging technologies.
– The Architect’s Playbook
Practical patterns for:
•Intelligence fabrics
•Agent-safe APIs
•Digital twin integration
•Trust & decentralized identity
•Ecosystem-ready design
– Operationalizing EA 4.0
How architecture teams evolve:
•New EA roles
•Continuous planning
•Agent governance
•EA dashboards
•The 12-month adoption roadmap
AI systems behave fundamentally differently from traditional software — they reason, retrieve, learn, and act with autonomy.
These behaviors introduce new failure modes: retry storms, inference cost surges, misaligned agent actions, semantic drift, and retrieval errors.
Most system design approaches were never built to handle these risks.
This talk presents the A.R.C.H.A.I. Blueprint
(AI-Ready Contextual Human-Aligned Initiative),
a modern, AI-first architecture methodology that helps organizations design systems that are safe, scalable, resilient, and aligned with human intent.
Through vivid scenarios drawn from Dreamazon—a fictional global retailer—we show how classical architecture breaks when AI agents interact with APIs, data, and user flows.
Attendees learn how to extend the traditional C4 model into C4+, incorporating AI reasoning layers, retrieval paths, guardrails, drift surfaces, and human oversight points.
Participants also engage in an Architecture Lab, applying ARCHAI to design an AI-powered system using real templates, patterns, and safety practices.
This session equips architects, developers, and technical leaders with the frameworks and confidence needed to build AI-first systems responsibly.
⸻
Key Skills You Will Learn
•How to design systems that incorporate AI reasoning and autonomous behavior
•How to extend C4 into C4+, modeling intelligence, retrieval, guardrails, and safety layers
•How to build AI-safe flows with idempotency, retry constraints, and ambiguity handling
•How to architect Retrieval-Augmented Generation (RAG) and agent orchestration
•How to map business capabilities and value chains for AI transformation
•How to identify AI-specific failure patterns and design to prevent them
•How to define drift detection, cost ceilings, and guardrail policies
•How to create an AI-first governance and ownership model
⸻
What You Will Take Away
•A complete understanding of the A.R.C.H.A.I. Blueprint
•A reusable C4+ architecture template for designing AI systems
•Practical patterns to prevent runaway AI behavior, duplication, and cost explosions
•A framework for aligning AI systems with business intent and human oversight
•Tools for modeling retrieval boundaries and agent interaction flows
•A clear professional roadmap for becoming an AI-first architect
⸻
Agenda
•Why traditional system design breaks when AI agents enter the system
•Realistic case studies from Dreamazon’s Black Friday failures
•Introduction to the A.R.C.H.A.I. Blueprint
•How to apply the six pillars to real-world AI use cases
•Extending the C4 model into C4+ for AI architecture
•Modeling reasoning paths, retrieval pipelines, and safety constraints
•Architecture Lab: Building an AI-ready system using ARCHAI
•Design templates, scorecards, and guardrail patterns
•Roadmap for evolving into an AI-first architect
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.
AI is moving from pilots to production faster than most enterprises are prepared for. Over the next 3–5 years, architectures must evolve to support agentic workflows, governed AI, secure inference, and cost-efficient operations.
This session gives you a practical blueprint for building an AI-native enterprise architecture—powered by MCP/LangGraph orchestration, GraphRAG retrieval, ISO/IEC 42001 governance, NIST AI RMF safety controls, confidential computing, and post-quantum cryptography.
You’ll leave with a 90-day activation plan and a 3-year roadmap for designing safe, trusted, and scalable AI systems.
KEY TAKEAWAYS
•Clear blueprint for agentic AI architecture
•How to implement governance-as-code (ISO 42001 + NIST AI RMF)
•Patterns for secure & confidential AI (PQC + enclaves)
•FinOps + GreenOps practices for cost & carbon visibility
•AgentOps methods for observability and reliability
•A 90-day plan to start safely
•A 3-year roadmap to modernize EA
⸻
AGENDA
1.The Shift: From AI pilots to agentic platforms
2.Failure Modes: What breaks in real enterprises
3.Blueprint: MCP, LangGraph, GraphRAG, tool safety
4.Governance & Security: ISO 42001, NIST, PQC, confidential compute
5.FinOps & GreenOps: Cost + carbon per inference
6.AgentOps: Observability & drift detection
7.90-Day Activation Plan
8.3-Year EA Roadmap
9.Closing: Architecting the Trusted AI Enterprise
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.
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.
Attendees will learn how to:
Integrate AI assistants into cloud readiness, migration, and optimization phases.
Use AI to analyze legacy code, auto-generate documentation, and map dependencies.
Employ the AWS CAF 3.0, Microsoft CAF, and Google CAF to guide large-scale migration while balancing security, compliance, and cost.
Design cloud-native architectures powered by continuous learning, resilience, and automation.
Packed with case studies, modernization blueprints, and AI-assisted workflows, this session equips architects and technical leaders to bridge the gap between heritage systems and future-ready enterprises.
Agenda (60–90 minutes)
1 Introduction: Why Legacy Modernization Now (10 min)
The Gartner 2030 prediction and what it means for enterprises.
The rise of AI-augmented modernization.
2 Understanding Cloud Adoption Frameworks (15 min)
Overview of AWS CAF 3.0, Microsoft CAF for Azure, Google CAF.
Common pillars: strategy, governance, people, platform, security, and operations.
Strengths and trade-offs across frameworks.
3 Strategic Role of AI in Legacy Modernization (15 min)
How LLMs augment discovery, documentation, and refactoring.
ChatGPT as a legacy analysis assistant: reading COBOL, PL/SQL, Java monoliths.
AI-driven dependency mapping, test case generation, and modernization playbooks.
4 Steps for Moving Legacy Systems to the Cloud (20 min)
Assessment → Migration Planning → Modernization Execution → Optimization.
Incremental vs. Full Rewrite: decision matrix and hybrid models.
Ensuring compliance, resilience, and audit readiness throughout migration.
5 Designing AI-Ready Cloud-Native Architectures (15 min)
Embedding RAG, microservices, and event-driven architecture.
Leveraging container orchestration (EKS, AKS, GKE) and serverless compute.
Implementing AI observability, MLOps, and data pipelines on cloud.
6 Case Studies & Real-World Transformations (10 min)
BFSI: Mainframe-to-Microservices using AWS CAF + GenAI refactoring.
Manufacturing: SAP modernization using Azure CAF + AI code summarization.
Retail: Omnichannel API modernization with GCP CAF + Copilot GPTs.
7 Best Practices & Roadmap (5 min)
Align modernization with business capability models.
Embed AI governance into CAF workflows.
Build continuous improvement loops through feedback and metrics.
8 Q&A / Wrap-Up (5 min)
Recap core insights.
The future of AI-enhanced cloud adoption and autonomous modernization.
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.
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.
“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/2026 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.
This presentation delves into the potential of integrating LLMs with Apache Spark and Apache Iceberg as part of a Big Data to AI foundational architecture. In this session we’ll explore the potential of combining Iceberg, Spark and LLMs to give you a real world AI architecture that uses your data.
We'll build an AI application that allows users to perform data queries and extract insights from massive datasets using natural language. We'll start with understanding the structure and architecture of a large dataset. Then we'll look at options for querying the dataset using Apache Spark and Trino. Finally, we'll use an LLM to query the dataset using natural language. We'll also look at other uses of LLMs as part of an overall solution, and explore the differences between different LLMs.
We’ll also discuss where event streaming (Kafka and Flink) fit into this architecture. The design of this architecture is meant to be flexible and give your dev team the ability to choose different technologies for the processing and querying. I’ll leave you with a CONCRETE example that you can run on your laptop and explore the possibilities. Again, this will be an example of a real-world application; the dataset used will be for home sales data for the last 15 years.
We will use these technologies:
Apache Iceberg
Apache Spark
Trino
LM Studio for running your own LLM
AI inference is no longer a simple model call—it is a multi-hop DAG of planners, retrievers, vector searches, large models, tools, and agent loops. With this complexity comes new failure modes: tail-latency blowups, silent retry storms, vector store cold partitions, GPU queue saturation, exponential cost curves, and unmeasured carbon impact.
In this talk, we unveil ROCS-Loop, a practical architecture designed to close the four critical loops of enterprise AI:
•Reliability (Predictable latency, controlled queues, resilient routing)
•Observability (Full DAG tracing, prompt spans, vector metrics, GPU queue depth)
•Cost-Awareness (Token budgets, model tiering, cost attribution, spot/preemptible strategies)
•Sustainability (SCI metrics, carbon-aware routing, efficient hardware, eliminating unnecessary work)
KEY TAKEAWAYS
•Understand the four forces behind AI outages (latency, visibility, cost, carbon).
•Learn the ROCS-Loop framework for enterprise-grade AI reliability.
•Apply 19 practical patterns to reduce P99, prevent retry storms, and control GPU spend.
•Gain a clear view of vector store + agent observability and GPU queue metrics.
•Learn how ROCS-Loop maps to GCP, Azure, Databricks, FinOps & SCI.
•Leave with a 30-day action plan to stabilize your AI workloads.
⸻
AGENDA
1.The Quiet Outage: Why AI inference fails
2.X-Ray of the inference pipeline (RAG, agents, vector, GPUs)
3.Introducing the ROCS-Loop framework
4.19 patterns for Reliability, Observability, FinOps & GreenOps
5.Cross-cloud mapping (GCP, Azure, Databricks)
6.Hands-on: Diagnose an outage with ROCS
7.Your 30-day ROCS stabilization plan
8.Closing: Becoming a ROCS AI Architect
Large Language Models unlock new capabilities—and expose brand-new attack surfaces.
From prompt injection and data exfiltration to model denial-of-service and insecure plugin calls, adversaries are exploiting weaknesses traditional AppSec never anticipated.
The new OWASP LLM Top-10 provides a shared vocabulary for AI risks; this session turns that list into actionable engineering practice.
You’ll learn how to threat-model LLM endpoints, design guardrails that actually block malicious behavior, sandbox tools and plug-ins with least privilege, and align your mitigations to the NIST AI Risk Management Framework for audit-ready governance.
Problems Solved
Why Now
What You’ll Learn
Agenda
Opening: The New AI Attack Surface
How LLMs change the threat model. Examples of real-world attacks: prompt injections, indirect injections, model DoS, and exfiltration via vector stores.
Pattern 1: Threat Modeling LLM Endpoints Identify assets, trust boundaries, and high-risk flows. Apply STRIDE-inspired analysis to prompts, context windows, retrieval layers, and plugin calls.
Pattern 2: Designing Input/Output Guardrails Policy filtering, schema validation, and content moderation. Runtime vs compile-time guardrails—what actually works in production. Enforcing determinism and fail-safe defaults.
Pattern 3: Sandboxing and Least Privilege Plugins Secure function calling: scoped IAM, network egress rules, per-plugin secrets, and API key vaulting. Container isolation and ephemeral agent sandboxes.
Pattern 4: Data Protection and Tenancy in RAG Redacting sensitive data before embedding. Segregating tenant vectors and access policies. Auditing data lineage and evidence paths.
Pattern 5: Red Team & Evaluation Frameworks Running adversarial simulations aligned with OWASP LLM Top-10. Common exploits and how to detect them. Integrating automated red-team tests into CI/CD pipelines.
Pattern 6: Governance & Framework Mapping Mapping mitigations to NIST AI RMF (categories RA, MA, ME). Building dashboards and executive summaries for risk reporting.
Wrap-Up & Action Plan Summarize practical controls that can be implemented within 30 days. Introduce the Guardrail Policy Starter Kit + Red-Team Runbook templates. Live checklist review for readiness maturity.
Key Framework References
Takeaways
Enterprises are moving from single AI agents to networks of agents that trigger thousands of API calls, retries, and tool-chains per prompt. Without orchestration discipline and APIs built for AI-scale, systems buckle under bursty load, retry storms, cache-miss spikes, inconsistent decisions, and runaway costs.
This talk shows how to combine MCP (Model Context Protocol) with proven inter-agent orchestration patterns — Supervisor, Pub/Sub, Blackboard, Capability Router — and how to harden APIs for autonomous traffic using rate limits, dedupe, backpressure, async workflows, resilient caching, and autoscaling without bill shock.
You’ll also learn the AIRLOCK Framework for governing multi-agent behavior with access boundaries, identity checks, rate controls, least-privilege routing, observability, compliance filters, and kill-switches.
You will walk away with a practical blueprint for building multi-agent systems that are fast, safe, reliable, and cost-predictable.
KEY TAKEAWAYS
Pattern Literacy: When to use Orchestrator, Pub/Sub, Blackboard, Router
MCP Fluency: Standardize agent↔tool integration
API Scaling: Rate limits, dedupe, backpressure, async, caching
Resilience: Bulkheads, jitter, circuit breakers, autoscaling guardrails
Observability: Trace chain-ID/tool-ID across agents & tools
AIRLOCK Governance: Access boundaries, identity, rate controls, least-privilege routing, compliance, kill-switches
AGENDA
Why AI Changes Load Patterns
Bursty workloads · fan-out · retry amplification · cost spikes
MCP 101
Standardized agent→tool access · hot-swappable tools
Orchestration Patterns
Supervisor · Pub/Sub · Blackboard · Capability Router
Architecting APIs for AI Traffic
Multi-dimensional rate limits · dedupe · backpressure · SWR caching · async
Resilience & Autoscaling
Circuit breakers · bulkheads · kill-switches · budget caps
Observability & Governance
Chain-ID tracing · anomaly detection · AIRLOCK boundaries
Architecture is often described as “the stuff that's hard to change” or “the important stuff (whatever that is).” At its core, architecture defines the very essence of software, transcending mere features and functions to encompass vital capabilities such as scalability, evolvability, elasticity, and reliability. But here's the real question: where do these critical capabilities truly originate?
In this keynote, we'll embark on a journey to uncover the secrets behind successful architectures. While popular architecture patterns may offer a starting point, it's time to unveil the startling truth – both monolith and microservicesbased projects continue to stumble and falter at alarming rates. The key to unparalleled success lies in the art of finetuning and tailormaking architectures to precisely fit the unique needs of your organization, environment, and the teams delivering the software.
Step into the future as we introduce a groundbreaking, problemcentric approach to defining and evolving system architectures. Our practical techniques will empower you to transform constraints, both architectural and environmental, into powerful enablers of robust, valuable, and longlived software systems.
Join us and elevate your architecture game to new heights!
A client once asked me to take a team that was new to REST, Agile, etc. and put together a high profile, high value commerce-oriented API in the period of six months. In the process of training the team and designing this API, I hit upon the idea of providing rich testing
coverage by mixing the Behavior-Driven Design testing approach with REST.
In this talk, I will walk you through the idea, the process, and the remarkable outcomes we achieved. I will show you how you can benefit as well from this increasingly useful testing strategy. The approach makes it easy to produce tests that are accessible to business analysts and other stakeholders who wouldn't understand the first
thing about more conventional unit tests.
Behavior is expressed using natural language. The consistent API style minimizes the upfront work in defining step definitions. In the end, \you can produce sophisticated coverage, smoke tests, and more that exercise the full functionality of the API. It also produces another organizational artifact that can be used in the future to migrate to
other implementation technologies.
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!
Strategic Domain-Driven Design (DDD) is an architecture approach that aligns systems, data, and teams around the true structure of the business. Getting started with identifying bounded contexts—the core building blocks of Strategic DDD—has long been a challenging mix of art and science.
In this hands-on session, you’ll learn a practical, repeatable method for introducing Strategic DDD starting with a single business process. Using collaborative event storming, you’ll visualize the flow of the conference registration journey, identify natural bounded contexts, and map the messages that flow between them.
You’ll see how starting with this approach is a natural input to event-driven architectures and CQRS patterns while also creating a common language between Business and IT to inform strategic decisions.