A software architecture conference should not leave you with a notebook full of patterns and no clearer idea of what to do on Monday. The useful sessions are the ones that change a decision already waiting in your backlog: where an AI agent can act, how a service survives retries, whether a platform team should own a capability, or how to add observability without rewriting everything.
That is a higher bar than a polished stage and a crowded agenda. Architecture is the practice of making technical choices that remain understandable under change. As AI generates more code and systems gain more autonomy, those choices become harder to reverse. A conference worth attending should help you examine the trade-offs before production makes them expensive.
Start with the decisions your system cannot avoid
The best conference experience begins before the first keynote. Bring a short list of real decisions from your team. Not abstract interests such as "AI" or "microservices," but questions with consequences.
Perhaps your organization is considering an agent that can modify infrastructure. Perhaps a monolith is becoming difficult to change, but splitting it would create operational overhead you cannot yet support. Perhaps you have event-driven workflows that work in the happy path and fail under duplicate delivery, partial failure, or a delayed dependency.
These are architecture questions because they involve boundaries, authority, failure modes, and ownership. They are also questions where a generic answer is rarely useful. Event sourcing can provide a valuable audit trail, but it introduces modeling and operational complexity. A managed service can reduce maintenance, but it can also create constraints around data, cost, portability, and incident response. The right choice depends on the system, the team, and what failure looks like for your users.
A strong program gives you enough technical detail to make those distinctions. Look for speakers who explain the context behind a decision, the alternatives they rejected, and the operational evidence that changed their minds. A production postmortem often teaches more than a neat reference architecture because it shows where assumptions failed.
What a software architecture conference should cover now
Architecture sessions still need to address modularity, Domain-Driven Design, context maps, evolutionary architecture, and distributed systems. Those foundations have not become less relevant. They have become more urgent as teams add generated code, autonomous workflows, and external model providers to systems that were already complex.
The practical question is no longer whether AI will enter the codebase. For many teams, it already has. The question is how much authority it receives.
A useful architecture track should distinguish between an AI system that suggests an answer and one that takes action. Generating a support response is not the same as issuing a refund. Summarizing a deployment is not the same as changing production infrastructure. The second category requires explicit controls: least-privilege access, policy checks, audit logs, isolated handling of untrusted input, and human checkpoints designed to resist automation bias.
That is why AI safety belongs alongside software architecture rather than in a separate future-facing track. Dr. Roman V. Yampolskiy’s work on AI safety and security addresses the central engineering question: who remains accountable when software makes decisions on our behalf? The answer cannot be "the model." Accountability needs to be visible in the system design, access model, and incident process.
The same standard applies to AI delivery. Teams need specific guidance on evaluating retrieval and generation separately in RAG systems, controlling token cost and latency, and selecting hosted, local, on-device, or air-gapped models based on the actual risk and operating environment. An air-gapped production environment has different constraints from a consumer application. A vendor comparison alone will not tell you what to build.
Look for mechanics, not architecture theater
Architecture theater is easy to recognize after the fact. A speaker shows a diagram with clean boxes, arrows, and names for every component. The audience leaves with a vocabulary but no test for whether the design will tolerate an outage, a replayed message, a compromised credential, or a developer making a rushed change at 5 p.m.
The alternative is mechanics. How does the system preserve idempotency when a workflow retries? What happens when a policy service is unavailable? Which data is retained, and which action can be reconstructed from an audit record? How do teams introduce OpenTelemetry into an existing estate without treating observability as a greenfield project? Jimmy Bogard’s work on adding OpenTelemetry to existing systems speaks to the reality most teams face: the system that needs attention is usually the one already earning revenue.
Mechanics also reveal organizational choices. A platform that makes the safe path easy can prevent whole classes of incidents. But platforms need product thinking, clear ownership, and disciplined limits. Centralizing every decision creates a bottleneck. Decentralizing everything can create inconsistent security controls and incompatible operational practices. Good architecture content should acknowledge both costs.
Technical depth matters here. Sessions on encrypted applications, current OAuth and OpenID Connect practice, post-quantum security, private AI tooling, Kubernetes, Kafka, microVMs, SLOs, and graceful degradation may appear specialized. Together, they describe whether a system can be trusted under normal use and abnormal conditions.
Learn from people who changed engineering practice
Speaker credentials matter, but not as a status signal. They matter when the speaker’s work has shaped the methods teams use to reason about change.
Kent Beck made small steps and fast feedback central to modern software design through Extreme Programming, Test-Driven Development, and JUnit. His perspective is especially relevant when AI can produce large volumes of plausible code faster than a team can understand it. More code is not automatically more progress. Feedback loops, tests, readable boundaries, and the ability to reverse a change still determine whether teams can move safely.
Venkat Subramaniam brings the path from specification to production into focus. That path is where many AI-assisted projects fail. The prototype looks convincing, then meets ambiguous requirements, access controls, stale data, latency budgets, and a release process built for conventional software. A serious conference should help attendees close that gap.
Kevlin Henney’s work on programming languages and software design offers another useful reminder: tools influence thought, but they do not absolve engineers from thinking. A language, framework, agent platform, or code generator can make some designs easier and others harder. Understanding those pressures helps teams make deliberate choices rather than inheriting a vendor’s defaults.
Turn sessions into an architecture plan
Do not attempt to attend everything. A program with 102 substantive sessions across six stages requires choices. Select one problem area to explore deeply, then choose a small number of adjacent sessions that challenge your assumptions.
If you are responsible for an AI-enabled product, combine agent design with security, data infrastructure, and leadership content. Pair a session on coordinating specialized agents with one on prompt injection, data exfiltration, or recoverable AI systems. Tricia Diamond’s focus on recoverability is a useful lens: when an automated action goes wrong, can you identify it, stop it, and repair the state without guessing?
If you are working on distributed systems, pair domain modeling with operational content. A context map is more valuable when it leads to a clearer ownership boundary, better integration contract, or a safer migration plan. An idempotent workflow is more valuable when the team also understands the telemetry needed to prove it behaves correctly under load.
Write down three things after each session: a decision your team should revisit, an assumption you need to test, and a person you should involve. That turns a conference from passive consumption into a working input to engineering planning.
Meet the people who carry the same constraints
The hallway conversation is not separate from the technical program. It is where a principal engineer learns how another team handles model access reviews, a CTO compares platform investment trade-offs, or an engineering manager hears how peers are changing review practices for AI-generated code.
Build Stuff 2026 takes place December 2-4 in Vilnius and online, with technical talks, workshops, masterclasses, leadership sessions, and daily keynotes. Dylan Beattie hosts all three days. The program is organized around machine, developer, organizational, and human agency because architecture is not only a matter of components. It is also about who can decide, who can act, and who answers when the system fails.
Bring your unresolved design question. Leave with a smaller set of assumptions, better questions for your team, and a next step you can defend in a design review.
