This full-day, hands-on workshop equips developers, architects, and technical leaders with the knowledge and skills to secure AI systems end-to-end — from model interaction to production deployment. Participants learn how to recognize and mitigate AI-specific threats such as prompt injection, data leakage, model exfiltration, and unsafe tool execution.
Through a series of focused labs, attendees build, test, and harden AI agents and Model Context Protocol (MCP) services using modern defensive strategies, including guardrails, policy enforcement, authentication, auditing, and adversarial testing.
The training emphasizes real-world implementation over theory, using preconfigured environments in GitHub Codespaces for instant, reproducible results. By the end of the day, participants will have created a working secure AI pipeline that demonstrates best practices for trustworthy AI operations and resilient agent architectures.
The course blends short conceptual discussions with deep, hands-on practice across eight structured labs, each focusing on a key area of AI security. Labs can be completed in sequence within GitHub Codespaces, requiring no local setup.
1.Lab 1 – Mapping AI Security Risks
Identify the unique attack surfaces of AI systems, including LLMs, RAG pipelines, and agents. Learn how to perform a structured threat model and pinpoint where vulnerabilities typically occur.
2.Lab 2 – Securing Prompts and Contexts
Implement defensive prompting, context isolation, and sanitization to mitigate prompt injection, hidden instructions, and data leakage risks.
3.Lab 3 – Implementing Guardrails
Use open-source frameworks (e.g., Guardrails.ai, LlamaGuard) to validate LLM outputs, enforce content policies, and intercept unsafe completions before delivery.
4.Lab 4 – Hardening MCP Servers and Tools
Configure FastMCP servers with authentication, scoped tokens, and restricted tool manifests. Examine how to isolate and monitor server–client interactions to prevent privilege escalation.
5.Lab 5 – Auditing and Observability for Agents
Integrate structured logging, trace identifiers, and telemetry into AI pipelines. Learn how to monitor for suspicious tool calls and enforce explainability through audit trails.
6.Lab 6 – Adversarial Testing and Red-Teaming
Simulate common AI attacks—prompt injection, model hijacking, and context poisoning—and apply mitigation patterns using controlled experiments.
7.Lab 7 – Policy-Driven Governance
Introduce a “security-as-code” approach using policy files that define allowed tools, query types, and data scopes. Enforce runtime governance directly within your agent’s workflow.
8.Lab 8 – Secure Deployment and Lifecycle Management
Apply DevSecOps practices to containerize, sign, and deploy AI systems safely. Incorporate secrets management, vulnerability scanning, and compliance checks before release.
Outcome:
Participants finish the day with a secure, auditable, and policy-controlled AI system built from the ground up. They leave with practical experience defending agents, MCP servers, and model workflows—plus learning for integrating security-by-design principles into future projects.
Hi, Spring fans! Developers today are being asked to deliver more with less time and build ever more efficient services, and Spring is ready to help you meet the demands. In this workshop, we'll take a roving tour of all things Spring, looking at fundamentals of the Spring component model, look at Spring Boot, and then see how to apply Spring in the context of batch processing, security, data processing, modular architecture, miroservices, messaging, AI, and so much more.
Basics
which IDE? IntelliJ, VSCode, and Eclipse
your choice of Java: GraalVM
start.spring.io, an API, website, and an IDE wizard
Devtools
Docker Compose
Testcontainers
banner.txt
Development Desk Check
the Spring JavaFormat Plugin
Python, gofmt, your favorite IDE, and
the power of environment variables
SDKMAN
.sdkman
direnv
.envrc
a good password manager for secrets
Data Oriented Programming in Java 21+
an example
Beans
dependency injection from first principles
bean configuration
XML
stereotype annotations
lifecycle
BeanPostProcessor
BeanFactoryPostProcessor
auto configuration
AOP
Spring's event publisher
configuration and the Environment
configuration processor
AOT & GraalVM
installing GraalVM
GraalVM native images
basics
AOT lifecycles
Scalability
non-blocking IO
virtual threads
José Paumard's demo
Cora Iberkleid's demo
Cloud Native Java (with Kubernetes)
graceful shutdown
ConfigMap and you
Buildpacks and Docker support
Actuator readiness and liveness probes
Data
JdbcClient
SQL Initialization
Flyway
Spring Data JDBC
Web Programming
clients: RestTemplate, RestClient, declarative interface clients
REST
controllers
functional style
GraphQL
batches
Architecting for Modularity
Privacy
Spring Modulith
Externalized messages
Testing
Batch Processing
Spring Batch
load some data from a CSV file to a SQL database
Microservices
centralized configuration
API gateways
reactive or not reactive
event bus and refreshable configuration
service registration and discovery
Messaging and Integration
“What do you mean by Event Driven?”
Messaging Technologies like RabbitMQ or Apache Kafka
Spring Integration
files to events
Kafka
a look at Spring for Apache Kafka
Spring Integration
Spring Cloud Stream
Spring Cloud Stream Kafka Streams
Security
adding form login to an application
authentication
authorization
passkeys
one time tokens
OAuth
the Spring Authorizatinm Server
OAuth clients
OAuth resource servers
protecting messaging code
Modern system design has entered a new era. It’s no longer enough to optimize for uptime and latency — today’s systems must also be AI-ready, token-efficient, trustworthy, and resilient. Whether building global-scale apps, powering recommendation engines, or integrating GenAI agents, architects need new skills and playbooks to design for scale, speed, and reliability.
This full-day workshop blends classic distributed systems knowledge with AI-native thinking. Through case studies, frameworks, and hands-on design sessions, you’ll learn to design systems that balance performance, cost, resilience, and truthfulness — and walk away with reusable templates you can apply to interviews and real-world architectures.
Target Audience
Enterprise & Cloud Architects → building large-scale, AI-ready systems.
Backend Engineers & Tech Leads → leveling up to system design mastery.
AI/ML & Data Engineers → extending beyond pipelines to full-stack AI systems.
FAANG & Big Tech Interview Candidates → preparing for system design interviews with an AI twist.
Engineering Managers & CTO-track Leaders → guiding teams through AI adoption.
Startup Founders & Builders → scaling AI products without burning money.
Learning Outcomes
By the end of the workshop, participants will be able to:
Apply a 7-step system design framework extended for AI workloads.
Design systems that scale for both requests and tokens.
Architect multi-provider failover and graceful degradation ladders.
Engineer RAG 2.0 pipelines with hybrid search, GraphRAG, and semantic caching.
Implement AI trust & security with guardrails, sandboxing, and red-teaming.
Build observability dashboards for hallucination %, drift, token costs.
Reimagine real-world platforms (Uber, Netflix, Twitter, Instagram) with AI integration.
Practice mock interviews & chaos drills to defend trade-offs under pressure.
Take home reusable templates (AI System Design Canvas, RAG Checklist, Chaos Runbook).
Gain the confidence to lead AI-era system design in interviews, enterprises, or startups.
Workshop Agenda (Full-Day, 8 Hours)
Session 1 – Foundations of Modern System Design (60 min)
The new era: Why classic design is no longer enough.
Architecture KPIs in the AI age: latency, tokens, hallucination %, cost.
Group activity: brainstorm new KPIs.
Session 2 – Frameworks & Mindset (75 min)
The 7-Step System Design Framework (AI-extended).
Scaling humans vs tokens.
Token capacity planning exercise.
Session 3 – Retrieval & Resilience (75 min)
RAG 2.0 patterns: chunking, hybrid retrieval, GraphRAG, semantic cache.
Multi-provider resilience + graceful degradation ladders.
Whiteboard lab: design a resilient RAG pipeline.
Session 4 – Security & Observability (60 min)
Threats: prompt injection, data exfiltration, abuse.
Guardrails, sandboxing, red-teaming.
Observability for LLMs: traces, cost dashboards, drift monitoring.
Activity: STRIDE threat-modeling for an LLM endpoint.
Session 5 – Real-World System Patterns (90 min)
Uber, Netflix, Instagram, Twitter, Search, Fraud detection, Chatbot.
AI-enhanced vs classic system designs.
Breakout lab: redesign a system with AI augmentation.
Session 6 – Interviews & Chaos Drills (75 min)
Mock interview challenges: travel assistant, vector store sharding.
Peer review of trade-offs, diagrams, storytelling.
Chaos drills: provider outage, token overruns, fallback runbooks.
Closing (15 min)
Recap: 3 secrets (Scaling tokens, RAG as index, Resilient degradation).
Templates & takeaways: AI System Design Canvas, RAG Checklist, Chaos Runbook.
Q&A + networking.
Takeaways for Participants
AI System Design Canvas (framework for interviews & real-world reviews).
RAG 2.0 Checklist (end-to-end retrieval playbook).
Chaos Runbook Template (resilience drill starter kit).
AI SLO Dashboard template for observability + FinOps.
Confidence to design and defend AI-ready architectures in both career and enterprise contexts.
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!
As code generation becomes increasingly automated, our role as developers and architects is evolving. The challenge ahead isn’t how to get AI to write more code, it’s how to guide it toward coherent, maintainable, and purposeful systems.
In this session, Michael Carducci reframes software architecture for the era of intelligent agents. You’ll learn how architectural constraints, composition, and trade-offs provide the compass for orchestrating AI tools effectively. Using principles from the Tailor-Made Architecture Model, Carducci introduces practical mental models to help you think architecturally, communicate intent clearly to your agents, and prevent automation from accelerating entropy. This talk reveals how the enduring discipline of architecture becomes the key to harnessing AI—not by replacing human creativity, but by amplifying it.
When Eliyahu Goldratt wrote The Goal, he showed how local optimizations (like adding robots to a factory line) can actually decrease overall performance. Today, AI threatens to repeat that mistake in software. We’re accelerating coding without improving flow. In this talk, Michael Carducci explores what it means to architect for the goal: continuous delivery of value through systems designed for flow.
Drawing insights from Architecture for Flow, Domain-Driven Design, Team Topologies, and his own Tailor-Made Architecture Model, Carducci shows how to align business strategy, architecture, and teams around shared constraints and feedback loops. You’ll discover how to turn automation into advantage, orchestrate AI within the system of work, and build socio-technical architectures that evolve—not just accelerate.
The hardest part of software architecture isn’t the technology, it’s the people. Every architecture lives or dies by its ability to influence behavior, build consensus, and turn vision into change. In this session, Michael Carducci explores the real work of being an architect: communicating clearly, guiding decisions, and driving meaningful change in complex organizations. Drawing from decades of experience and the principles behind the Tailor-Made Architecture Model, Carducci shows how to identify where change is needed, package ideas for adoption, and lead with both clarity and empathy.
And while AI may soon help us design systems, it still can’t align humans around them. The enduring art of architecture lies in shaping not just the code, but the culture that makes progress possible. You’ll leave with practical tools to navigate the human side of architecture and a renewed appreciation for why that art still matters.
Everyone’s talking about AI models, but almost no one is talking about the data architecture that makes them intelligent. Today’s AI systems are brittle because they lack context, semantics, and shared understanding. In this session, Michael Carducci explores how linked data, RDF, ontologies, and knowledge graphs solve the very problems that leave the industry floundering: hallucination, inconsistency, and lack of interoperability.
Drawing from real-world examples, Carducci connects decades of overlooked research in semantic web technologies to the challenges of modern AI and agentic systems. You’ll see how meaning itself can be modeled, linked, and reasoned over; and why the future of AI depends not on bigger models, but on smarter data.
In our rush toward the future, the software industry keeps forgetting its past—and with it, the hard-won lessons that could save us from repeating the same mistakes. In this live storytelling session, Michael Carducci revives the forgotten wisdom of the pioneers who shaped our craft.
Through entertaining, thought-provoking tales drawn from computing’s early days, he reveals how timeless principles still illuminate today’s challenges in architecture, AI, and innovation. Blending inspiration, history, and humor, Carducci connects these tales to our modern struggles with AI, architecture, and innovation itself. This isn’t nostalgia—it’s a rediscovery of the foundations that still shape great software and better technologists.
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.
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.
This session will focus on the essential technical skills that are needed by software architects on a daily basis from ideation to product delivery. For many architects, maintaining your technical skills can be a challenge.
Come to this session if you want to learn some tricks and tips for how to raise your technical game as an architect.
Java has quietly grown into a more expressive, flexible, and modern language — but many developers haven’t kept up with the latest features. This two-part workshop explores the most useful additions to Java from recent releases, with hands-on examples and real-world scenarios.
Whether you’re still catching up from Java 8 or already using Java 21+, this series will give you a practical edge in writing cleaner, more modern Java code.
sealed classesrecordswitch expressionsJava has quietly grown into a more expressive, flexible, and modern language — but many developers haven’t kept up with the latest features. This two-part workshop explores the most useful additions to Java from recent releases, with hands-on examples and real-world scenarios.
Whether you’re still catching up from Java 8 or already using Java 21+, this series will give you a practical edge in writing cleaner, more modern Java code.
sealed classesrecordswitch expressionsJava has quietly grown into a more expressive, flexible, and modern language — but many developers haven’t kept up with the latest features. This two-part workshop explores the most useful additions to Java from recent releases, with hands-on examples and real-world scenarios.
Whether you’re still catching up from Java 8 or already using Java 21+, this series will give you a practical edge in writing cleaner, more modern Java code.
Java has quietly grown into a more expressive, flexible, and modern language — but many developers haven’t kept up with the latest features. This two-part workshop explores the most useful additions to Java from recent releases, with hands-on examples and real-world scenarios.
Whether you’re still catching up from Java 8 or already using Java 21+, this series will give you a practical edge in writing cleaner, more modern Java code.
Let us peer into the future of Java with the Foreign Function and Memory Interface, the new way to interact with native code. This session will discuss the essential ingredients of creating a Java-based application that issues commands and reads from the underlying native code and libraries. We will discuss establishing memory arenas, establishing pointers, making download calls, and using upcall stubs. This presentation will be rich with actual code examples. We will conclude by discussing the eventual removal of JNI, the old Java Native Interface
In this session, we will describe each of the following features of the Foreign Function and Memory API, along with Kata demos that you can run.
ArenaLinkerjextractGit continues to see improvements daily. However, work (and life) can take over, and we often miss the latest changelog. This means we don't know what changed, and consequently fail to see how we can incorporate those in our usage of Git.
In this session we'll take a tour of some features that you might or might not have heard of, but can significantly improve your workflow and day-to-day interaction with Git.
Git continues to see improvements daily. However, work (and life) can take over, and we often miss the changelog. This means we don't know what changed, and consequently fail to see how we can incorporate those in our usage of Git.
In this session we will look at some features you are probably aware of, but haven't used, alongside new features that Git has brought to the table.
You will need the following installed
Git continues to see improvements daily. However, work (and life) can take over, and we often miss the latest changelog. This means we don't know what changed, and consequently fail to see how we can incorporate those in our usage of Git.
In this session we'll take a tour of some features that you might or might not have heard of, but can significantly improve your workflow and day-to-day interaction with Git.
Git continues to see improvements daily. However, work (and life) can take over, and we often miss the changelog. This means we don't know what changed, and consequently fail to see how we can incorporate those in our usage of Git.
In this session we will look at some features you are probably aware of, but haven't used, alongside new features that Git has brought to the table.
You will need the following installed
Spring Boot 3.x and Java 21 have arrived, making it an exciting time to be a Java developer! Join me, Josh Long (@starbuxman), as we dive into the future of Spring Boot with Java 21. Discover how to scale your applications and codebases effortlessly. We'll explore the robust Spring Boot ecosystem, featuring AI, modularity, seamless data access, and cutting-edge production optimizations like Project Loom's virtual threads, GraalVM, AppCDS, and more.
Let's explore the latest-and-greatest in Spring Boot to build faster, more scalable, more efficient, more modular, more secure, and more intelligent systems and services.
The age of artificial intelligence (because the search for regular intelligence hasn't gone well..) is nearly at hand, and it's everywhere! But is it in your application? It should be. AI is about integration, and here the Java and Spring communities come second to nobody.
In this talk, we'll demystify the concepts of modern day Artificial Intelligence and look at its integration with the white hot new Spring AI project, a framework that builds on the richness of Spring Boot to extend them to the wide world of AI engineering.
There's a clear need for security in the software systems that we build. The problem for most organizations is that they don't want to spend any money on it. Even if they did, they often have no idea how much to spend. No particular initiative is likely to imbue your system with “security”, but a strong, deep defensive approach is likely to give you a fighting chance of getting it right.
Web Security as applied to APIs in particular are an important part of the plan. In this workshop, we'll show you how approaches to defining “enough” as well as concrete techniques to employ incrementally in your designs.
In this workshop, we will pick a hands on framework for implementation, but the ideas will generally be standards-based and transcend technology choice so you should have a strategy for mapping the ideas into your own systems.
We will cover a broad range of topics including:
There's a clear need for security in the software systems that we build. The problem for most organizations is that they don't want to spend any money on it. Even if they did, they often have no idea how much to spend. No particular initiative is likely to imbue your system with “security”, but a strong, deep defensive approach is likely to give you a fighting chance of getting it right.
Web Security as applied to APIs in particular are an important part of the plan. In this workshop, we'll show you how approaches to defining “enough” as well as concrete techniques to employ incrementally in your designs.
In this workshop, we will pick a hands on framework for implementation, but the ideas will generally be standards-based and transcend technology choice so you should have a strategy for mapping the ideas into your own systems.
We will cover a broad range of topics including:
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.
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
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
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.
I've witnessed firsthand the challenges and opportunities faced by companies navigating the complex world of legacy systems.
In this session, I'll draw on my years of experience to:
Define the “legacy landscape”: We'll explore the different types of legacy systems, their impact on businesses, and the unique challenges they present for technology teams. We will also distinguish between legacy and technical debt. We will show practical and actionable tools to extract legacy ‘reasoning’ and ‘design’ and transform them into moder landscapes.
Understand the business context: We'll shift perspectives, examining how legacy systems support core business functions and value propositions. Extracting out of a legacy system is essential. And the core capabilities it supports even more so.
Bridge the gap: Technology delivery strategies: We'll delve into practical strategies for delivering technology value within a legacy environment, including:
Modernization techniques: Refactoring, microservices, and API integration.
Legacy coexistence strategies: Leveraging existing investments while adopting new technologies.
Change management considerations: Aligning stakeholders, navigating risk,and ensuring adoption.
Real-world case studies: Learn from real-world examples of companies successfully delivering technology value in legacy environments.
Open discussion: Share your own challenges and experiences, and engage in a collaborative discussion about navigating the legacy landscape.
Technologists tend to think of end-to-end as meaning the UI to the database from client to server. But a true architect realizes end to end means from idea to retirement. The architect has to traverse a lot of territory in that journey, from business to technology. They have to work through change management, complex stakeholder dynamics, systems of systems and of course technical decisions.
This introduction to the end-to-end architect will prepare you with the 5 pillars of architecture as well as help you understand how to navigate the complexity of end-to-end architecture work!
As CEO of Iasa, the world's largest professional association for architects, and champion of the BTABoK (Business Technology Architecture Body of Knowledge), I've witnessed firsthand the dynamic interplay between engineering and architecture in today's complex projects. In this session, we'll dance on the edge of these disciplines, using the BTABoK as our guiding framework, exploring how agile practices, decisive engineering, efficient delivery, and the delicate balance of hands-on/hands-off leadership intertwine.
Defining the modern dance: We'll explore the shifting ground where agile methodologies meet traditional engineering rigor, and how architects leverage the BTABoK's 5 Pillars of Architecture Skill (Business Strategy, Technology Strategy,Solution Design, Delivery & Operations, and Value Management) to navigate the tension inherent in the roles. We will also dive into the healthy and natural balance between engineereing and architecture and why it is so essential to modern systems success.
Understanding the business waltz: We'll shift perspectives, examining how business objectives and user needs inform the interaction between agility and precision in complex projects, aligning with the BTABoK's emphasis on strategic value delivery.
Change Management and Architecture: We'll look into practical strategies for managing the roadmap and delivery of a project including:
Harmonizing delivery: Finding the sweet spot between iterative sprints and long-term vision, as outlined in the Delivery & Operations pillar.
Hands-on leadership: Empowering teams while providing strategic guidance,aligning with the Leadership and People skills.
Technical Excellence: Ensuring high-quality engineering practices within an agile framework, leveraging the BTABoK's Technology pillar.
Human Systems: Addressing unforeseen challenges and navigating changing requirements, a key competency in the BTABoK's Solution Design pillar.
Case studies from the architectural stage: Learn from real-world examples of successful projects where architects mastered the interaction between agility and engineering excellence, demonstrating the practical application of the BTABoK principles.
Open discussion: Share your own experiences and challenges, and engage in a collaborative conversation about navigating the complexities of modern architecture, applying the BTABoK's collaborative and knowledge-sharing principles.
This session is for you if you are:
A senior developer or technology leader working with legacy systems.
A senior architect looking at a portfolio of change and large structural systems delivery.
Responsible for delivering new technology solutions in a complex, existing environment.
Keen to gain practical strategies and actionable insights from a business and technical perspective.
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.
AI models are evolving fast, but the systems around them aren’t. Every backend change still breaks your carefully tuned AI client, while on the web, every change to a server doesn’t require you to download a new browser. What if AI worked the same way?
In this talk, Michael Carducci explores the architecture of 3rd Generation Agentic AI, building on the ideas and technologies introduced in Data Architecture for AI. You’ll discover how JSON-LD, Hydra, and semantic integration enable truly evolvable, interoperable AI ecosystems at web scale. Through live demos and real-world examples, Carducci shows how these web-native standards create APIs that describe themselves, adapt to change, and empower agents to discover and interact safely without brittle coupling. The real frontier isn’t smarter models—it’s shared meaning—and that’s an architectural problem worth solving.
If you ask the typical technologist how to build a secure system, they will include encryption in the solution space. While this is a crucial security feature, in and of itself, it is an insufficient part of the plan. Additionally, there are a hundred ways it could go wrong. How do you know if you're doing it right? How do you know if you're getting the protections you expect?
Encryption isn't a single thing. It is a collection of tools combined together to solve problems of secrecy, authentication, integrity, and more. Sometimes those tools are deprecated because they no longer provide the protections that they once did.Technology changes. Attacks change. Who in your organization is tracking and validating your encryption strategy? How are quantum computing advancements going to change the game?No background will be assumed and not much math will be shown.
If you ask the typical technologist how to build a secure system, they will include encryption in the solution space. While this is a crucial security feature, in and of itself, it is an insufficient part of the plan. Additionally, there are a hundred ways it could go wrong. How do you know if you're doing it right? How do you know if you're getting the protections you expect?
Encryption isn't a single thing. It is a collection of tools combined together to solve problems of secrecy, authentication, integrity, and more. Sometimes those tools are deprecated because they no longer provide the protections that they once did.Technology changes. Attacks change. Who in your organization is tracking and validating your encryption strategy? How are quantum computing advancements going to change the game?No background will be assumed and not much math will be shown.
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.
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:
The typical technologist has a fairly straightforward perspective about the use of resources in modern software systems. They understand the concept of stable identifiers and what some of the HTTP verbs are intended for based upon experiences with the Web.
There is a rich ecosystem of use cases that build upon these basic ideas, however, and in this talk I will demonstrate several of my favorite examples. Drawing upon my pattern-oriented book, I will highlight patterns that surface information, transform it, direct
traffic, and more. These patterns will be presented with intention, consequences, and the usual context we expect in pattern-oriented literature to help us communicate sophisticated design decisions.
Come develop a more sophisticated palette of resource-oriented patterns to help you solve a variety of issues in distributed information systems development.
One of the nice operational features of the REST architectural style as an approach to API Design is that is allows for separate evolution of the client and server. Depending on the design choices a team makes, however, you may be putting a higher burden on your clients than you intend when you introduce breaking changes.
By taking advantage of the capabilities of OpenRewrite, we can start to manage the process of independent evolution while minimizing the impact. Code migration and refactoring can be used to transition existing clients away from older or deprecated APIs and toward new versions with less effort than trying to do it by hand.
In this talk we will focus on:
Managing API lifecycle changes by automating the migration from deprecated to supported APIs.
Discussing API evolution strategies and when they require assisted refactoring and when they don’t.
*Integrating OpenRewrite into API-first development to ensure client code is always up-to-date with ease.
Learning and understanding AI concepts is satisfying and rewarding, but the fun part is learning how to work with AI yourself. In this 1/2 day workshop, author, trainer, and experienced technologist Brent Laster will help you do both! We’ll explain why and how to run AI models locally, the basic ideas of agents and RAG, and show how to assemble a simple AI agent in Python that leverages RAG and uses a local model through Ollama. And you'll get to follow through with hands-on labs and produce your own instance running on your system in a GitHub Codespace
In this workshop, we'll walk you through what it means to run models locally, how to interact with them, and how to use them as the brain for an agent. Then, we'll enable them to access and use data from a PDF via retrieval-augmented generation (RAG) to make the results more relevant and meaningful. And you'll do all of this hands-on in a ready-made environment with no extra installs required.
No experience is needed on these technologies, although we do assume you do have a basic understanding of LLMs.
Attendees will need the following to do the hands-on labs:
Learning and understanding AI concepts is satisfying and rewarding, but the fun part is learning how to work with AI yourself. In this 1/2 day workshop, author, trainer, and experienced technologist Brent Laster will help you do both! We’ll explain why and how to run AI models locally, the basic ideas of agents and RAG, and show how to assemble a simple AI agent in Python that leverages RAG and uses a local model through Ollama. And you'll get to follow through with hands-on labs and produce your own instance running on your system in a GitHub Codespace
In this workshop, we'll walk you through what it means to run models locally, how to interact with them, and how to use them as the brain for an agent. Then, we'll enable them to access and use data from a PDF via retrieval-augmented generation (RAG) to make the results more relevant and meaningful. And you'll do all of this hands-on in a ready-made environment with no extra installs required.
No experience is needed on these technologies, although we do assume you do have a basic understanding of LLMs.
Attendees will need the following to do the hands-on labs:
Just as CI/CD and other revolutions in DevOps have changed the landscape of the software development lifecycle (SDLC), so Generative AI is now changing it again. Gen AI has the potential to simplify, clarify, and lessen the cycles required across multiple phases of the SDLC.
In this session with author, trainer, and experienced DevOps director Brent Laster, we'll survey the ways that today's AI assistants and tools can be incorporated across your SDLC phases including planning, development, testing, documentation, maintaining, etc. There are multiple ways the existing tools can help us beyond just the standard day-to-day coding and, like other changes that have happened over the years, teams need to be aware of, and thinking about how to incorporate AI into their processes to stay relevant and up-to-date.
Microservices have fundamentally changed the way we develop and deploy applications. Everything from team topologies, to DevOps to observability—everything changed, and for the better.
However, it's not all rainbows and unicorns. Operationalizing microservices is hard. Microservices encourage WET (write everything twice) to ensure that services are as decoupled from each other as possible. But how does that work when we have to deal with cross-cutting concerns that we need for every service?
Enter the service mesh. Service meshes like Istio allow us to “slot” in cross-cutting architectural concerns within a kubernetes cluster, letting our services focus on solving actual business concerns.
In this fast-paced session, we will blitz through what Istio is, how it works, and what facilities it offers to DRY out your microservices. Come see how Istio can make your cluster programmable and application-aware.
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.
AI inference is the new production workload — always on, cost-intensive, and increasingly complex. Many teams face latency spikes at P99, runaway GPU bills, and limited observability across their agentic and RAG pipelines.
This session delivers practical, vendor-aware patterns for reliable and sustainable inference at scale.
You’ll explore queueing, caching, GPU pooling, FinOps, and GreenOps strategies grounded in the Google Cloud AI/ML Well-Architected Framework, Azure AI Workload Guidance, and the Databricks Lakehouse Principles — enabling you to build inference systems that are performant, efficient, and planet-friendly.
Problems Solved
What You’ll Learn
Agenda
Opening & Context
: Why inference reliability, observability, and sustainability define the next stage of enterprise AI.
Case study: A RAG system suffering from unpredictable latency and GPU overspend — what went wrong and what patterns fix it.
Pattern 1: Reliable Inference Flow Design Engineering for bursty demand. Patterns: async queues, back-pressure controls, serverless triggers, GPU pooling vs autoscaling, and caching strategies for RAG.
Pattern 2: Observability & Instrumentation Full-stack tracing for inference workloads. Prompt-level metrics, vector query instrumentation, GPU telemetry, OpenTelemetry integration, and structured prompt logging.
Pattern 3: FinOps for AI Controlling inference cost without losing reliability. Cost attribution, tagging GPU workloads, quantization and model distillation, choosing preemptible/spot instances, and cross-cloud FinOps tooling (GCP Recommender, Azure Advisor, Databricks Cost Profiler).
Pattern 4: GreenOps & Sustainability , Reducing the environmental footprint of AI pipelines. SCI (Software Carbon Intensity) metrics, carbon-aware scheduling, time-shifting inference jobs, and sustainable scaling practices.
Cross-Cloud Well-Architected Anchors Mapping patterns to major frameworks:
Wrap-Up & Discussion Recap of proven design patterns, FinOps + GreenOps checklist, and architectural recommendations for enterprise AI teams.
Key Framework References
Takeaways
Dynamic Programming (DP) intimidates even seasoned engineers. With the right lens, it’s just optimal substructure + overlapping subproblems turned into code. In this talk, we start from a brute-force recursive baseline, surface the recurrence, convert it to memoization and tabulation, and connect it to real systems (resource allocation, routing, caching). Along the way you’ll see how to use AI tools (ChatGPT, Copilot) to propose recurrences, generate edge cases, and draft tests—while you retain ownership of correctness and complexity. Expect pragmatic patterns you can reuse in interviews and production.
Why Now
Key Framework
Core Content
Learning Outcomes
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.
APIs are everywhere! Yet, designing APIs that are intuitive, evolvable, and developerfriendly remains a challenge. This workshop introduces the API Design First approach, which emphasizes collaboration, consistency, and exceptional developer experience by focusing on crafting your API contract before implementation. We’ll explore why API Design First matters, how it compares to the traditional Code First method, and how adopting this approach can transform the way teams build APIs.
Through interactive exercises, you’ll gain handson experience with OpenAPI, learning to craft “good” API contracts grounded in RESTful principles. You'll also dive into API Design Reviews, participating in mock sessions to understand how collaboration can elevate the quality and consistency of your designs. By experiencing proven API Design First practices, you’ll leave with a clear roadmap to enhance your own APIs and elevate your organization’s API program. Whether you’re a developer, architect, or product manager, this workshop equips you with the skills, tools, and mindset to create APIs that deliver lasting value and exceptional developer satisfaction.
APIs are everywhere! Yet, designing APIs that are intuitive, evolvable, and developerfriendly remains a challenge. This workshop introduces the API Design First approach, which emphasizes collaboration, consistency, and exceptional developer experience by focusing on crafting your API contract before implementation. We’ll explore why API Design First matters, how it compares to the traditional Code First method, and how adopting this approach can transform the way teams build APIs.
Through interactive exercises, you’ll gain handson experience with OpenAPI, learning to craft “good” API contracts grounded in RESTful principles. You'll also dive into API Design Reviews, participating in mock sessions to understand how collaboration can elevate the quality and consistency of your designs. By experiencing proven API Design First practices, you’ll leave with a clear roadmap to enhance your own APIs and elevate your organization’s API program. Whether you’re a developer, architect, or product manager, this workshop equips you with the skills, tools, and mindset to create APIs that deliver lasting value and exceptional developer satisfaction.
Building an AI model is the easy part—making it work reliably in production is where the real engineering begins. In this fast-paced, experience-driven session, Ken explores the architecture, patterns, and practices behind operationalizing AI at scale. Drawing from real-world lessons and enterprise implementations, Ken will demystify the complex intersection of machine learning, DevOps, and data engineering, showing how modern organizations bring AI from the lab into mission-critical systems.
Attendees will learn how to:
Design production-ready AI pipelines that are testable, observable, and maintainable
Integrate model deployment, monitoring, and feedback loops using MLOps best practices
Avoid common pitfalls in scaling, governance, and model drift management
Leverage automation to reduce friction between data science and engineering teams
Whether you’re a software architect, developer, or engineering leader, this session will give you a clear roadmap for turning AI innovation into operational excellence—with the same pragmatic, architecture-first perspective that Ken is known for.
Most teams track numbers—but few measure what truly matters. In this insightful and practical session, Ken Sipe breaks down how to align organizational goals with measurable outcomes using Objectives and Key Results (OKRs) and Key Performance Indicators (KPIs) that actually drive success.
Ken will cut through the buzzwords and frameworks to show how engineering teams, product leaders, and executives can build a measurement culture that’s both data-driven and purpose-aligned. You’ll learn how to define metrics that motivate, avoid vanity indicators, and establish traceability from daily work to strategic outcomes.
Key takeaways include:
How to craft meaningful OKRs that align technical and business goals
The difference between activity, output, and outcome metrics—and why it matters
Techniques for cascading objectives across teams without creating chaos
How to use metrics as a feedback system, not a weapon
Real-world examples of OKRs and KPIs that improved clarity, accountability, and results
Whether you’re scaling an engineering organization or trying to bring more focus to your current team, this session will help you turn measurement into momentum—and ensure that success isn’t just tracked, but achieved.
Most of us don't want to go back to the days of malloc and free, but the magic of garbage collectors while convenient can be mysterious and hard to understand.
In this talk, you'll learn about the many different garbage collectors available in JVMs. The strength and weaknesses of the different allocation and collection strategies used by each collector. And how garbage collectors keep evolving to support today's hardware and cloud environments.
This talk will cover the core concepts in garbage collection: object reachability, concurrent collectors, parallel garbage collectors, and generational garbage collectors. These concepts will be covered by following the progression of garbage collectors in the HotSpot JVM.
Unlike other languages, Java had a well-defined memory model from the very beginning, but over the years additional packages and low-level features have been added to make the most of today's hardware.
In this talk, we'll discuss concurrency in detail starting at the hardware up to Java's latest synchronization mechanisms and finally onto high-level concurrent collections.
This talk will cover hardware memory fences, Java's synchronized and volatile, Atomic classes, newer capabilities added by VarHandles, and some select high-level concurrent collections.
Fortunately for most Java developers the just-in-time compiler just works and appears to do so by magic. And yet sometimes, we find ourselves facing a performance problem, so what do we when the magic stops?
In this talk, we’ll learn a few key concepts behind the magic of modern optimizing compilers: intrinsics, basic blocks, static single assignment, and inlining. By learning these key concepts, you’ll learn to save time not trying to optimize the things that the compiler can already do for you and to focus on the things that matter most.
This talk will provide a high-level overview of just-in-time compilation.
The talk will cover when the JVM triggers just-in-time compilation, an overview of core compiler concepts, and speculative optimizations and deoptimization which make the JVM unique.
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.
If everyone agrees with you, you’re probably not innovating, you’re just conforming faster. History’s breakthroughs rarely came from consensus; they came from heretics, hackers, and the hopelessly curious. In this talk, Michael Carducci takes aim at the myth of collective wisdom and explores why the crowd is almost always optimized for the past. Through stories of misfits who changed the world—from computing pioneers to magicians who reinvented wonder; Carducci reveals the hidden patterns of real innovation: discomfort, doubt, and persistence in the face of polite disbelief.
You’ll learn how to recognize the subtle forces that suppress new ideas, how to trust your intuition when it runs counter to consensus, and how to cultivate the curiosity and courage that real innovation demands. This is a talk for the misfits, the tinkerers, and the quietly visionary… because progress has always started at the edges.
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:
MLOps is a mix of Machine Learning and Operations. It is the new frontier for those interested in or knowledgeable about both of these disciplines. MLOps supports the operationalization of machine learning models developed by data scientists and delivers the model for processing via streaming or batch operations. Operationalizing Machine Learning Models is nurturing your data from notebook to deployment through pipelines.
In this workshop, we will describe the processes:
Some of the technologies we will discover include:
Our exercises will include running and understanding MLFlow.
None
MLOps is a mix of Machine Learning and Operations. It is the new frontier for those interested in or knowledgeable about both of these disciplines. MLOps supports the operationalization of machine learning models developed by data scientists and delivers the model for processing via streaming or batch operations. Operationalizing Machine Learning Models is nurturing your data from notebook to deployment through pipelines.
In this workshop, we will describe the processes:
Some of the technologies we will discover include:
Our exercises will include running and understanding MLFlow.
None
In this half-day workshop, we’ll practice Test-Driven Development (TDD) by solving a real problem step by step. You’ll learn how to think in tests, write clean code through refactoring, and use your IDE and AI tools effectively. We’ll also explore how modern Java features (like lambdas and streams) enhance testability, and discuss what’s worth testing — and what’s not.
In this half-day workshop, we’ll practice Test-Driven Development (TDD) by solving a real problem step by step. You’ll learn how to think in tests, write clean code through refactoring, and use your IDE and AI tools effectively. We’ll also explore how modern Java features (like lambdas and streams) enhance testability, and discuss what’s worth testing — and what’s not.
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.
AI agents are moving from novelty to necessity — but building them safely, predictably, and observably requires more than clever prompts. This workshop gives developers a practical introduction to AI agent engineering using Embabel, with an emphasis on the habits, patterns, and mental models needed to design trustworthy agents in real systems.
Across two focused sessions, you’ll learn how to ground agents in strong domain models (DICE), design goal-driven behaviours (GOAP), enforce safety through invariants and preconditions, and make every action explainable through observability.
You’ll run and inspect a fully working reference agent, extend its domain, add new actions, and validate behaviour through explainable planning logs. You'll explore how to select and deploy models tuned to provide the best and most cost-effective agent behaviour for your users.
By the end of this full day workshop, you’ll know how to:
Build agents anchored in typed domain models
Design composable, goal-oriented behaviours
Use preconditions and invariants as safety guardrails
Debug agents through explainability, not guesswork
Extend an agent with new domain objects and actions without breaking existing flows
Apply a repeatable habit stack for reliable agent engineering
Whether you’re designing workflow agents, platform automations, or domain-specific assistants, this workshop gives you the practical skills and engineering discipline to build agents that behave safely and reason predictably — fit for production, and even fit for regulated environments.
The AI revolution isn’t coming — it’s already here, in our editors, our pipelines, our incident channels, our platforms. But while everyone is racing to bolt “AI-powered” onto their products, a quieter, more consequential truth is emerging:
The future won’t belong to teams with the biggest models. It will belong to teams with the best habits.
This keynote is a fast-paced journey into the craft of AI engineering — the behaviours, reflexes, and mental disciplines that separate teams who build safe, reliable, explainable AI systems from those who unleash unpredictable ones into production.
Through vivid stories of teams who got these habits right — and cautionary tales of those who didn’t — you’ll see why AI engineering is less about algorithms and more about discipline: the daily behaviours that make AI predictable, governable, and safe in the wild.
Internal developer platforms hold promise: faster delivery, better reliability, happier engineers. Yet they often stall—caught in organisational inertia, tool complexity, and unclear value.
These two high-impact 90-minute sessions give you the core mental models and practical artefacts to shift from tool-chase to strategic platform value. You’ll walk away with real maps, a clear focus, and next-step experiments—not just ideas. If you’re looking to make your platform team a force for value, not just operations, this compact format delivers.
By the end of the workshop you'll know:
How to see your platform ecosystem clearly using tools like Wardley Mapping, User Needs Mapping, Value Stream Mapping and OODA loops.
How to treat the platform as a product, shifting mindset from internal project to self-service, developer-centric product.
How to apply the pattern language of platform design (Golden Path, Self-Service, Abstraction, Composability, Guardrails, Observability, Extensibility, Incremental Roll-out).
How to use DSRP + UNM + VSM to reveal where value stalls, flow breaks, and cognitive load spikes.
How to design smallest viable changes, build an impact roadmap, and influence adoption through “Elephant & Rider” thinking (rational vs emotional mindsets).
You'll also get a sneak peek into the future of platforms: AI/automation, evolving loops, and building resilience into your ecosystem.
If your platform team is stuck in the grind—shipping tickets, fighting fires, juggling tools, and wondering why nothing ever seems to change—this workshop will give you the clarity and leverage you’ve been missing. You’ll learn to read your organisation like a map: where value flows, where it dies, where cognitive load spikes, and where small, strategic platform moves can unlock disproportionate impact.
This isn’t another “tools tour”. Whether you’re building an IDP from scratch or rescuing one that’s drifting, you’ll leave with a clear roadmap, a set of tested patterns, and the influence skills to actually make the work land. Platform engineering is no longer about managing complexity—it’s about creating the conditions where developers can thrive. Join us, map your ecosystem, design the future, and turn your platform team into the strategic engine your organisation needs.
By the end of this half day workshop you'll know:
How to see your platform ecosystem clearly using tools like Wardley Mapping, User Needs Mapping, Value Stream Mapping and OODA loops.
How to treat the platform as a product, shifting mindset from internal project to self-service, developer-centric product.
How to apply the pattern language of platform design (Golden Path, Self-Service, Abstraction, Composability, Guardrails, Observability, Extensibility, Incremental Roll-out).
How to use DSRP + UNM + VSM to reveal where value stalls, flow breaks, and cognitive load spikes.
How to design smallest viable changes, build an impact roadmap, and influence adoption through “Elephant & Rider” thinking (rational vs emotional mindsets).
You'll also get a sneak peek into the future of platforms: AI/automation, evolving loops, and building resilience into your ecosystem.
If your platform team is stuck in the grind—shipping tickets, fighting fires, juggling tools, and wondering why nothing ever seems to change—this workshop will give you the clarity and leverage you’ve been missing. You’ll learn to read your organisation like a map: where value flows, where it dies, where cognitive load spikes, and where small, strategic platform moves can unlock disproportionate impact.
This isn’t another “tools tour”. Whether you’re building an IDP from scratch or rescuing one that’s drifting, you’ll leave with a clear roadmap, a set of tested patterns, and the influence skills to actually make the work land. Platform engineering is no longer about managing complexity—it’s about creating the conditions where developers can thrive. Join us, map your ecosystem, design the future, and turn your platform team into the strategic engine your organisation needs.
Internal developer platforms hold promise: faster delivery, better reliability, happier engineers. Yet they often stall—caught in organisational inertia, tool complexity, and unclear value.
These two high-impact 90-minute sessions give you the core mental models and practical artefacts to shift from tool-chase to strategic platform value. You’ll walk away with real maps, a clear focus, and next-step experiments—not just ideas. If you’re looking to make your platform team a force for value, not just operations, this compact format delivers.
By the end of the workshop you'll know:
How to see your platform ecosystem clearly using tools like Wardley Mapping, User Needs Mapping, Value Stream Mapping and OODA loops.
How to treat the platform as a product, shifting mindset from internal project to self-service, developer-centric product.
How to apply the pattern language of platform design (Golden Path, Self-Service, Abstraction, Composability, Guardrails, Observability, Extensibility, Incremental Roll-out).
How to use DSRP + UNM + VSM to reveal where value stalls, flow breaks, and cognitive load spikes.
How to design smallest viable changes, build an impact roadmap, and influence adoption through “Elephant & Rider” thinking (rational vs emotional mindsets).
You'll also get a sneak peek into the future of platforms: AI/automation, evolving loops, and building resilience into your ecosystem.
If your platform team is stuck in the grind—shipping tickets, fighting fires, juggling tools, and wondering why nothing ever seems to change—this workshop will give you the clarity and leverage you’ve been missing. You’ll learn to read your organisation like a map: where value flows, where it dies, where cognitive load spikes, and where small, strategic platform moves can unlock disproportionate impact.
This isn’t another “tools tour”. Whether you’re building an IDP from scratch or rescuing one that’s drifting, you’ll leave with a clear roadmap, a set of tested patterns, and the influence skills to actually make the work land. Platform engineering is no longer about managing complexity—it’s about creating the conditions where developers can thrive. Join us, map your ecosystem, design the future, and turn your platform team into the strategic engine your organisation needs.
By the end of this half day workshop you'll know:
How to see your platform ecosystem clearly using tools like Wardley Mapping, User Needs Mapping, Value Stream Mapping and OODA loops.
How to treat the platform as a product, shifting mindset from internal project to self-service, developer-centric product.
How to apply the pattern language of platform design (Golden Path, Self-Service, Abstraction, Composability, Guardrails, Observability, Extensibility, Incremental Roll-out).
How to use DSRP + UNM + VSM to reveal where value stalls, flow breaks, and cognitive load spikes.
How to design smallest viable changes, build an impact roadmap, and influence adoption through “Elephant & Rider” thinking (rational vs emotional mindsets).
You'll also get a sneak peek into the future of platforms: AI/automation, evolving loops, and building resilience into your ecosystem.
If your platform team is stuck in the grind—shipping tickets, fighting fires, juggling tools, and wondering why nothing ever seems to change—this workshop will give you the clarity and leverage you’ve been missing. You’ll learn to read your organisation like a map: where value flows, where it dies, where cognitive load spikes, and where small, strategic platform moves can unlock disproportionate impact.
This isn’t another “tools tour”. Whether you’re building an IDP from scratch or rescuing one that’s drifting, you’ll leave with a clear roadmap, a set of tested patterns, and the influence skills to actually make the work land. Platform engineering is no longer about managing complexity—it’s about creating the conditions where developers can thrive. Join us, map your ecosystem, design the future, and turn your platform team into the strategic engine your organisation needs.
In this example-driven session, we'll take a look at how to build both explicit agentic workflows using Spring AI as well as defining autonomous agents using Embabel.
Over the past few years, we've seen the buzz around Generative AI evolve from simple prompts, to document- and tool-augmented prompts, to more formalized collections of tools and prompts in Model Context Protocol (MCP). And for awhile now, agents are all the buzz. Unfortunately, this has presented a paradox wherein everyone knows what agents are and at the same time, nobody knows what agents are.
Regardless of what you think an agent is, it's clear that agents are the most useful when they are able to work within the ecosystems of existing enterprise systems. Since many enterprise systems are based in Java, it would make sense to develop agents in Java so that they can take advantage of prior work that has been developed in Java and the skillsets that were involved. In short, it's unnecessary to develop in Python if you don't already have Python in play in such a system.
Fortunately, frameworks such as Spring AI make easy work of integrating Generative AI in Java. And applying agentic workflow patterns in Java is just as easy. What's more, an agentic framework such as Embabel (which is built on Spring and Spring AI) make developing autonomous, self-planning agents in Java as straightforward as it is to develop web applications or APIs in Java.
In this example-driven session, you'll learn how to build an MCP server in Java using Spring AI, integrate it with clients such as Claude Code and Cursor, and even create your own MCP clients.
On their own, Large Language Models (LLMs) are only able to generate responses based on their training. While their training may be vast, it will not include any actual data from your organization's databases and systems. What's more, an LLM may be able to answer questions, they are unable to actually interact with your enterprise and take action.
Enter Model Context Protocol (MCP). MCP defines a standard with which you can collection a set of related tools, prompts, and resources and make those available to an LLM to make use of. With MCP, your LLMs will be able to interact with databases, APIs, and other components in your enterprise to get things done.
Building and using MCP in Java has never been easier than it is now with Spring AI. Spring AI introduced support for MCP in its 1.0 release and improved upon it tremendously in Spring AI 1.1.
In this session, we'll cover several useful prompt engineering techniques as well as some emerging patterns that are categorized within the “Agentic AI” space and see how to go beyond simple Q&A to turn your LLM of choice into a powerful ally in achieving your goals.
At it's core, Generative AI is about submitting a prompt to an LLM-backed API and getting some response back. But within that interaction there is a lot of nuance, particularly with regard to the prompt itself.
It's important to know how to write effective prompts, choosing the right wording and being clear about your expectations, to get the best responses from an LLM. This is often called “prompt engineering” and includes several patterns and techniques that have emerged in the Gen AI space.
By now, you've no doubt noticed that Generative AI is making waves across many industries. In between all of the hype and doubt, there are several use cases for Generative AI in many software projects. Whether it be as simple as building a live chat to help your users or using AI to analyze data and provide recommendations, Generative AI is becoming a key piece of software architecture.
So how can you implement Generative AI in your projects? Let me introduce you to Spring AI.
For over two decades, the Spring Framework and its immense portfolio of projects has been making complex problems easy for Java developers. And now with the new Spring AI project, adding Generative AI to your Spring Boot projects couldn't be easier! Spring AI brings an AI client and templated prompting that handles all of the ceremony necessary to communicate with common AI APIs (such as OpenAI and Azure OpenAI). And with Spring Boot autoconfiguration, you'll be able to get straight to the point of asking questions and getting answers your application needs.
In this handson workshop, you'll build a complete Spring AIenabled application applying such techniques as prompt templating, Retrieval Augmented Generation (RAG), conversational history, and tools invocation. You'll also learn prompt engineering techniques that can help your application get the best results with minimal “hallucinations” while minimizing cost.
In the workshop, we will be using…
Optionally, you may choose to use a different AI provider other than OpenAI such as Anthropic, Mistral, or Google Vertex (Gemini), but you will need an account with them and some reasonable amount of credit with them. Or, you may choose to install Ollama (https://ollama.com/), but if you do be sure to install a reasonable model (llama3:latest or gemma:9b) before you arrive.
Know that if you choose to use something other than OpenAI, your workshop experience will vary.
By now, you've no doubt noticed that Generative AI is making waves across many industries. In between all of the hype and doubt, there are several use cases for Generative AI in many software projects. Whether it be as simple as building a live chat to help your users or using AI to analyze data and provide recommendations, Generative AI is becoming a key piece of software architecture.
So how can you implement Generative AI in your projects? Let me introduce you to Spring AI.
For over two decades, the Spring Framework and its immense portfolio of projects has been making complex problems easy for Java developers. And now with the new Spring AI project, adding Generative AI to your Spring Boot projects couldn't be easier! Spring AI brings an AI client and templated prompting that handles all of the ceremony necessary to communicate with common AI APIs (such as OpenAI and Azure OpenAI). And with Spring Boot autoconfiguration, you'll be able to get straight to the point of asking questions and getting answers your application needs.
In this handson workshop, you'll build a complete Spring AIenabled application applying such techniques as prompt templating, Retrieval Augmented Generation (RAG), conversational history, and tools invocation. You'll also learn prompt engineering techniques that can help your application get the best results with minimal “hallucinations” while minimizing cost.
In the workshop, we will be using…
Optionally, you may choose to use a different AI provider other than OpenAI such as Anthropic, Mistral, or Google Vertex (Gemini), but you will need an account with them and some reasonable amount of credit with them. Or, you may choose to install Ollama (https://ollama.com/), but if you do be sure to install a reasonable model (llama3:latest or gemma:9b) before you arrive.
Know that if you choose to use something other than OpenAI, your workshop experience will vary.
Modern application observability involves tracking key metrics and tracing the flow of an application, even across service boundaries. Spring Boot 3 introduced some powerful metrics and tracing capabilities based on Micrometer to open a window into your application's inner-workings.
Among the things you might want to keep an eye on in your Generative AI applications are how many interactions and how much time is spent with vector stores and AI provider APIs and, of course, how many tokens are being spent by your application. And being able to trace the flow of prompts, data, and responses through your application can help identify problems and bottlenecks.
Great news! Spring AI comes equipped to record metrics and tracing information through Micrometer. In this session, you'll learn how to put Spring AI observability to work for you. You'll learn about the metrics it exposes as well as the keys you can use to build dashboards and tracing to build a window into your Generative AI applications.
Enterprise Architecture (EA) has long been misunderstood as a bottleneck to innovation, often labeled the “department of no.” But in today’s fast-paced world of Agile, DevOps, Cloud, and AI, does EA still have a role to play—or is it a relic of the past?
This session reimagines the role of EA in the modern enterprise, showcasing how it can evolve into a catalyst for agility and innovation. We’ll explore the core functions of EA, its alignment with business and IT strategies, and how modern tools, techniques, and governance can transform it into a driver of value. Attendees will leave with actionable insights on building a future-ready EA practice that thrives in an ever-changing technological landscape.
Architecture is often defined as “hard to change”. Within software architecture, an architecture pattern is a reusable solution to a commonly occurring problem in software architecture within a specific context. Architecture anti-patterns are their diabolical counterparts—wherein they sound good in theory, but in practice lead to negative consequences. And given that they affect both the architectural characteristics and the structural design of the system, are incredibly expensive and have far-reaching consequences.
This session explores various architecture patterns, how one can easily fall into anti-patterns, and how one can avoid the antipatterns. We will do qualitative analysis of various architecture patterns and anti-patterns, and introduce fitness functions govern against anti-patterns.
An architecture pattern is a reusable solution to a commonly occurring problem in software architecture within a specific context. Architecture patterns affect the “-ilities” of a system, such as scalability, performance, maintainability, and security as well as impact the structural design of the system.
This session explores various architecture patterns, their applicability and trade-offs. But that's not all—this session will also provide insight into the numerous intersections of these patterns with all the other tendrils of the organization, including implementation, infrastructure, engineering practices, team topologies, data topologies, systems integration, the enterprise, the business environment, and generative AI. And we will see how to govern each pattern using fitness functions to ensure alignment.
Platform engineering is the latest buzzword, in a industry that already has it's fair share. But what is platform engineering? How does it fit in with DevOps and Developer Experience (DevEx)? And is this something your organization even needs?
In this session we will aim to to dive deep into the world of platform engineering. We will see what platform engineering entails, how it is the logical succession to a successful DevOps implementation, and how it aims to improve the developer experience. We will also uncover the keys to building robust, sustainable platforms for the future
Platform engineering is the latest buzzword, in a industry that already has it's fair share. But what is platform engineering? How does it fit in with DevOps and Developer Experience (DevEx)? And is this something your organization even needs?
In this session we will aim to to dive deep into the world of platform engineering. We will see what platform engineering entails, how it is the logical succession to a successful DevOps implementation, and how it aims to improve the developer experience. We will also uncover the keys to building robust, sustainable platforms for the future
This 1/2 day workshop introduces participants to Claude Code, Anthropic’s AI-powered coding assistant. In three hours, attendees will learn how to integrate Claude Code into their development workflow, leverage its capabilities for productivity, and avoid common pitfalls. The workshop also introduces the concept of subagents (specialized roles like Planner, Tester, Coder, Refactorer, DocWriter) to show how structured interactions can improve accuracy and collaboration.
Format: 3-hour interactive workshop (2 × 90-minute sessions + 30-minute break).
Audience: Developers and technical professionals with basic programming knowledge.
Focus Areas:
Core capabilities and limitations of Claude Code.
Effective prompting and iteration techniques.
Applying Claude Code for code generation, debugging, refactoring, and documentation.
Using subagents for structured workflows as an optional advanced technique.
Deliverables:
5 hands-on labs (10–12 minutes each).
Experience with everyday Claude Code workflows plus a brief introduction to subagents.
To do the labs in this workshop, you must have a Claude Code Pro subscription already so you will have access to Claude Code. If you do not, you will not be able to use Claude Code in this workshop. See https://www.anthropic.com/pricing.
This 1/2 day workshop introduces participants to Claude Code, Anthropic’s AI-powered coding assistant. In three hours, attendees will learn how to integrate Claude Code into their development workflow, leverage its capabilities for productivity, and avoid common pitfalls. The workshop also introduces the concept of subagents (specialized roles like Planner, Tester, Coder, Refactorer, DocWriter) to show how structured interactions can improve accuracy and collaboration.
Format: 3-hour interactive workshop (2 × 90-minute sessions + 30-minute break).
Audience: Developers and technical professionals with basic programming knowledge.
Focus Areas:
Core capabilities and limitations of Claude Code.
Effective prompting and iteration techniques.
Applying Claude Code for code generation, debugging, refactoring, and documentation.
Using subagents for structured workflows as an optional advanced technique.
Deliverables:
5 hands-on labs (10–12 minutes each).
Experience with everyday Claude Code workflows plus a brief introduction to subagents.
To do the labs in this workshop, you must have a Claude Code Pro subscription already so you will have access to Claude Code. If you do not, you will not be able to use Claude Code in this workshop. See https://www.anthropic.com/pricing.
As cloud architectures evolve, AI is quickly becoming a foundational component rather than an add-on.
This session explores the architectural principles behind building scalable hybrid clouds and shows how AI can elevate them—from predictive scaling to intelligent workload optimization. We’ll look at patterns already emerging in the industry and map out a clear approach for designing resilient, AI-augmented systems that are ready for the next wave of innovation.
API security goes beyond protecting endpoints—it requires defense across infrastructure, data, and business logic. In this talk, I’ll present a structured approach to implementing Zero Trust security for APIs in a cloud-native architecture.
We’ll cover how to establish a strong foundation across layers—using mTLS, OAuth2/JWT, policy-as-code (OPA), GitOps for deployment integrity, and cloud-native secrets management. The session addresses real-world threats like misconfigurations, privilege escalation, and API abuse, and shows how to mitigate them with layered controls in Kubernetes-based environments on Azure and AWS.
Attendees will walk away with actionable practices to secure their API ecosystem end-to-end— without slowing development teams down.
Here I’ll break down how GitOps simplifies the operational challenges around cloud and Kubernetes environments. We’ll look at how a Git-driven model brings consistency, automation, and better visibility across both infrastructure and application delivery.
The goal is to share a clear and practical approach to reducing operational overhead and creating a more reliable DevOps workflow.