Serverless, the hard parts
Yan Cui | Developer Advocate at Lumigo
Serverless promises infinite scale and zero ops, but the reality for most teams is more… complicated.
In this talk, we’ll look at the hard parts of serverless: unpredictable performance and cost, local development and testing, and the mindset change needed for success.
Yan will draw on his real-world experiences and share practical strategies and patterns to overcome these challenges. So your team can deliver reliable, secure, and cost-efficient serverless applications at scale.
Level L200
Diagrams will Save Your Serverless Spaghetti: Mapping Boundaries to Visualise Complex Architectures
Isabel Maccabee | Senior Software Engineer, Kraken
As organisations grow, the lack of hierarchy of serverless often results in “Serverless Spaghetti”; thousands of lambdas, buckets, streams, and databases all connected in opaque ways. Communicating these complex relationships on a diagram inevitably becomes chaotic, inconsistent and immediately out of date.
This session introduces a tiered domain-mapping diagramming framework. The power of this framework is in allowing the act of diagramming to enforce clear boundaries within your serverless estate. This talk will help you harness that power.
By building on the principles of the C4 model, we will explore how to re-align architectural tiers to bridge the gap between high-level business logic and low-level cloud infrastructure. The result is a "zoomable" architecture that reduces cognitive load for various audiences, from engineers to stakeholders.
**Key Takeaways:**
- The Rule of Granularity: How to build a "zoomable" architecture, decoupling high-level strategy from low-level implementation swaps (e.g. moving from an SQS queue to a Kinesis Stream) without requiring a total diagram overhaul.
- Defining the Service Boundaries: In serverless architectures, business logic is often encoded in the infrastructure - blurring the lines between the platform and application layer. We’ll discuss how diagrams make it easier to define boundaries and the benefits of grouping resources into units that are deployable by a single pipeline.
- Reaping the Operational Rewards: Practical methods for mapping these diagrammatic boundaries to AWS Tagging to enable consistent billing and ownership across the business. This will let you point at a diagram and say “This part of the diagram costs this much”.
- Sustainable Documentation: A pragmatic look at emerging strategies for maintenance, including architectural guilds, automated "scorecards," and touching on the future role of AI in keeping code and diagrams in sync.
- Beyond the Big Picture: Practical pro-tips on arrow semantics, hyperlinking, and the fine art of making complex systems look simple.
Instead of a fog of icon-heavy chaos, transform your organisation’s diagrams into functional blueprints that bridge the gap between architectural design, deployment units, and the bottom line.
Level L100
Bedrock Ships Faster Than Its Security Primitives
Osama Okunbo | Security Engineer, Immibuddy
Bedrock makes shipping an AI agent straightforward. Guardrails, IAM integration, CloudTrail invocation logging, knowledge bases, action groups. The building blocks are there, the docs are solid, and a working agent can be in production in a weekend.
The security primitives around those building blocks are still catching up. This session covers six attack paths against a Bedrock agent, tested against a reference implementation built to model the kind of production deployment a compliance-constrained SaaS would ship. Prompt injection through document ingestion pipelines. Tool invocation abuse via action groups. Secrets leaking from agent context into CloudWatch and X-Ray.
Credential escalation through execution role misconfiguration. Memory poisoning via OpenSearch-backed knowledge bases. And the one most teams miss, inference-time exfiltration of sensitive prompt context into the model provider's own observability.
For each I show the chain, the CloudWatch or CloudTrail signal that reveals it, and the AWS-native control that stops it where one exists. Some attacks have clean controls. Some do not yet, and I am honest about which is which. I cover what to build at the IAM, VPC, and KMS layers to close the gaps that Bedrock Guardrails alone do not cover, and how to keep agentic workloads inside the same ISO 27001 and SOC 2 evidence envelope as the rest of an AWS estate.
This is a practitioner talk drawn from hands-on work with agentic systems in regulated environments, presented on a sanitised reference architecture.
Attendees leave with a Bedrock threat model, a CloudWatch and CloudTrail detection ruleset, an honest view of what Guardrails covers, and a concrete list of controls to layer on top.
Level L300
Your AI Tools Might Be Ready. Your Organisation Isn't
Owen Hawkins | Principal Solutions Architect, AWS
The vision for AI-native development is compelling. The gap between that vision and a working, auditable production system is where almost every organisation is stuck right now.
Most teams have AI coding tools. A developer here, a team there, moving faster. But individual productivity gains aren't organisational transformation — and faster code generation without traceability just creates faster technical and compliance debt.
In this talk, I'll share what it actually looks like when organisations try to make that shift. Not the demo. The Monday morning after the demo.
Drawing on real customer engagements, I'll cover three things: how to evaluate AI development tooling at an organisational level rather than an individual one; what AI-DLC genuinely demands from your teams and your leadership — and what fights back when you try to change; and the path to production — treating the spec as a first-class pipeline artefact, validated against version-controlled organisational standards before a line of code is written, then backed by the pipeline controls you already trust (SAST, policy-as-code, dependency scanning) on the generated code itself. Two layers of guardrails using the same mental model your teams already understand — just applied earlier.
I'll show briefly what spec-driven development looks like in practice, but the real conversation is about the organisational conditions and the controls that make AI-generated code something you can actually trust in production — not just in a sandbox.
You'll leave with an honest picture of where the friction is, and some opinionated ideas on how to close the gap — drawn from customers who are working through this right now.
Level L200
Hidden trade-offs in distributed architectures
Anahit Pogosova | AWS Data Hero & Cloud Architecture and Engineering Lead, F-Secure
Asynchronous event-driven architectures enable loosely coupled, scalable, and resilient systems. But the devil is in the details, and the true complexity lies in how components interact under real-world pressure. Ordering, idempotency, failure handling, latency, and cost aren’t shaped by high-level architecture diagrams with boxes and arrows — they’re shaped by the strategies and services you choose to integrate systems in distributed environments.
In this talk, you’ll uncover common design trade-offs behind integration decisions, illustrated with lessons from the field working with services like AWS Lambda, Amazon DynamoDB, and AWS Step Functions. You’ll leave with a sharper intuition for how distributed architectures behave, and how to design event-driven systems that are both resilient and intentional.
Level L300
Lessons learn building a Serverless first business with AI
Mark Sailes | Solutions Architect, Amazon Web Services
Lee Gilmore | AWS Serverless Hero & Serverless Advocate
In March, Lee Gilmore and Mark Sailes took their business idea and turned it into a real product.
Being die hard AWS Serverless fans they naturally built with a serverless first mindset. In this talk
learn about what worked well, and what they would never do again. Lee and Mark will share how they
used steering docs, hooks and skills to tailor AI output, and how they used MCP and an AI-DLC to
collaborate.
Level L300
Rethinking Microservices: Lessons from Refactoring to AWS Lambda Durable Functions
Matheus das Mercês | AWS Community Builder @ Serverless | Senior Cloud Engineer, PostNL
In March, Lee Gilmore and Mark Sailes took their business idea and turned it into a real product.
Being die hard AWS Serverless fans they naturally built with a serverless first mindset. In this talk
learn about what worked well, and what they would never do again. Lee and Mark will share how they
used steering docs, hooks and skills to tailor AI output, and how they used MCP and an AI-DLC to
collaborate.
Level L300
Context Over Code: Why AI-DLC Is an Organisational Transformation, Not a Productivity Hack
Matt Houghton | AI, Data and Analytics Architect at CDL Software, AWS Community Builder, AWS Ambassador. AWS Gold Jacket.
AI coding assistants are everywhere, but faster code generation isn't the problem most teams need to solve. At CDL, we rolled out Amazon Q Developer to 150+ engineers and saw real results — but we quickly realised the bigger opportunity wasn't in the tools, it was in rethinking how we work.
This talk covers our journey from AI code companion to AI-Driven Development Lifecycle (AI-DLC): how we trialled and scaled AI tooling, why we built a Context Store to give AI access to decades of institutional knowledge, and what it actually takes to make AI-native development work in practice. We'll cover steering, semantic retrieval with Bedrock Knowledge Bases and MCP, verification debt, and why the developers who thrive aren't the fastest coders — they're the ones who curate context and own quality.
Level L200
Red teaming AWS Strands + hands-on security mitigations
Stefano Amorelli | Senior Staff Software Engineer - AI - Cybersecurity, FinTech
The adoption of Agentic AI systems that autonomously plan, reason, and execute real-world actions is increasing exponentially.
Hence securing these systems has become a critical challenge. Unlike traditional LLMs, AI agents operate tools, manage credentials, communicate with other agents, and make decisions across trust boundaries. This expands the attack surface.
This session takes a hands-on, builder-first approach to agentic AI security using AWS Strands Agents SDK.
We follow the OWASP Top 10 for Agentic Applications that addresses this new reality with the newly released ten Agentic Security Issues (ASI01–ASI10), covering threats from agent goal hijacking and tool misuse to cascading multi-agent failures and rogue agent behavior.
We will walk through examples of the OWASP Top 10 agentic risks. This includes goal hijacking through indirect prompt injection, identity and privilege abuse via over-permissioned tool access, supply chain vulnerabilities in MCP server integrations, memory and context poisoning of RAG stores, and insecure inter-agent communication.
We will walk-through live demonstrations of vulnerable agent patterns alongside their hardened counterparts, leveraging Strands' tool decorator system, AWS Bedrock Guardrails integration, and multi-agent orchestration primitives.
Level L400
Letting It Think For Itself: Permissions, Context, and the Tension of Semi-Autonomous AI Agents
Julian Wiffen | Chief of AI and Data Science, Matillion & Maia
Every team building with AI agents hits the same tension: to be useful, the agent needs permissions - access to data, the ability to trigger pipelines, the authority to act while nobody's watching. But the more autonomy you grant, the more you need to trust that the agent knows what it's doing and won't cause damage.
This talk shares what we've learned building Maia, an AWS Bedrock powered virtual data engineer that operates semi-autonomously across async workflows. We'll cover the practical architecture of letting an AI agent work on its own - how we manage model permissions, git-based guardrails, and multi-persona interaction through what we call Mission Control - and why none of it works without a context engine underneath.
The context engine captures tribal knowledge (from Slack threads, analyst notes, business rules) as a byproduct of everyday work, giving the agent enough understanding of your business to act intelligently rather than just execute blindly. We'll demo the difference context makes: the same agent, the same task, with and without the context layer - so you can see how the quality of autonomous work degrades when the agent doesn't know what "right" looks like.
If you're building agentic systems and wrestling with how much rope to give them, this session is for you.
Level L300
Immutable Patterns of System Design; From Monolith to Agentic AI
James Eastham | Talking Serverless @ Datadog | International Speaker | Microsoft MVP
Technology is changing rapidly and it often feels like the skills you learned just a few years ago are becoming obsolete. From simple, single process apps running on-premises, through the cloud revoloution. From monoliths to microservices. Service oriented architecture to event-driven architecture. And now, we have agentic AI. As someone working on modern software, you've got a lot to think about. But really, how much has actually changed?
You still need your software to be reliable, performant and to solve a problem for your users. And regardless of what 'style' of system your building, there are some unchanging patterns that are always going to help you.
In this talk, you'll learn all about these unchanging patterns of systems design. This isn't an escoteric talk. This is a talk that is going to give you practical patterns of system design that you can take away and use in your business. Whether your working on a 20 year old monolith, working on the cutting edge of agentic AI, or whatever hype train comes next in software development. You'll have the skills to ensure your systems are always reliable, performant and solve real problems.
Level L300
The Sound of Databases
Renato Losio | Cloud Expert, AWS Data Hero, InfoQ Editor
Databases are not just about storing data. They are about time. And nothing exposes time like music. In this session, we use sound to explore how AWS databases behave under pressure. Instead of charts and traditional benchmarks, we listen.
By turning database behavior into music, we reveal how different services handle timing, consistency, and scale. Small delays, uneven performance, and unexpected pauses quickly become audible.
We will compare several AWS databases, relational and non-relational, serverless and provisioned, and let them perform. If a database can’t sing, it probably can’t scale.
Level L300
Open Standards for Agents
Ryan Cormack | Principal Engineer, Motorway
In this session Ryan will look at the various open source technologies available to us when it comes to building AI Agents and the open protocols that power them. We'll focus on how we can use AWS's open source Strands Framework to build custom agents, that can work with open protocols like Agent Client Protocol, AG UI and A2UI for building interfaces for our agents. We'll look at how we can run these agents on Bedrock AgentCore Runtime and monitor them with open standards like Open Telemetry in Cloudwatch. Finally we'll look at how Agent2Agent can allow our agents to talk to each other over http.
Notes: I'll primarily look at how AWS's Strands framework adopts open standards for running agents and how we can run and operate them on AgentCore Runtime. This is a rapidly changing landscape and the concrete specifics may change between now and October, but content will be up to date
Level L300
Taming Dead-Letter Queues: A Serverless Framework for Triage, Patch, and Replay
Chidimma Dominic Nweke | Software Engineer | Cloud-Native Systems & Applied AI
IDead Letter Queues (DLQs) are supposed to protect production systems, but in reality, they often become a graveyard; messages pile up, replays are risky, and the same failures keep repeating. Even worse, a "blast replay" can trigger a retry storm, double-processing, or a brand-new incident.
In this session, we'll build a practical AWS-native approach to DLQ remediation that's safe, observable, and repeatable. You'll see how to turn DLQs into a controlled recovery pipeline using services like SQS, Durable Functions, DynamoDB, and EventBridge, with guardrails like throttled replay, stop condition, quarantine, and idempotency.
We'll walk through a reference architecture that works not only for SQS-triggered Lambdas, but also for EventBridge and SNS failure paths, and we will cover how to generalize the same approach for DLQ-like failures from other workloads.
If you’ve ever opened a DLQ and thought "where do I even start?", this session turns that moment into an automated, measurable, and production-friendly recovery practice.
Level L300
Orchestrating a workflow in Lambda
Chris Dobson | Senior engineer, Trustpilot & AWS Community Builder
There’s a new kid on the block in the world of workflow orchestration, the Lambda Durable Function, which allows an orchestration to be created as a single Lambda Function which can run for up to a year.
-
How do you build an orchestration?
-
How much will it cost?
-
What pitfalls should you look out for?
-
Can it do everything you need?
-
How do you test or debug it?
Are just some of the questions I had about this new extensions to Lambda.
This talk will take an existing production workflow and look at how it could be built as a Lambda Durable Function from start to finish. I’ll implement the complete workflow, look at how the checkpoint/replay execution model affects this implementation, test and debug the workflow, and look at versioning all through a number of demos which have helped me answer those questions.
Level L200
Building a real-time voice agent that feels conversational, not transactional
Matthew Wilson | Distinguished Software Engineer, Instil
Niall Keys | Software Engineer, Instil | AI
In 2025 we were tasked with building a real-time voice assistant for on-the-ground sales reps working in global Pharma. They were struggling to keep accurate notes after meetings, capture outcomes from conversations and update their CRM often doing this admin work in their own personal time.
In this talk we share the story of building a production-grade voice agent on AWS using Amazon Nova Sonic 2.
This application had a measurable real-world impact on work–life balance of the sales reps. However building something that feels conversational is very different from stitching together AI services.
We’ll cover the hard lessons learnt from building real-time voice applications:
- Keeping an agent on task over multi-turn conversations.
- Managing context windows.
- Handling turn detection in noisy, real-world environments.
- Architecting for conversations longer than Lambda’s 15 minute timeout.
We’ll also explore why evals and observability with CloudWatch become mission-critical when prompt tweaks and model swaps can subtly degrade behaviour in ways traditional monitoring won’t catch.
This session is for engineers building AI systems that need to feel conversational, not transactional and who are discovering that “serverless” sometimes means knowing when not to use Lambda and look at ECS Fargate instead.
Level L300
Building Secure and Efficient SaaS Platforms on AWS Serverless
Guilherme Dalla Rosa | CTO, MerCloud
Let's go on a journey through the world of multi-tenant architectures on AWS using serverless technologies. In this talk, we will uncover the key aspects of multi-tenancy, including security, tenant isolation, and performance.
We will learn how to utilise Cognito for authentication, DynamoDB to store millions of tenant-partitioned records and lambda for compute. We will also explore different deployment models and their tradeoffs, and, finally, we will learn how to implement policy-based isolation with IAM to keep our execution context tied to one specific tenant and avoid data leakage.
By the end of this talk, you will feel more confident building SaaS applications on AWS with serverless technologies and you will have learned some of the many insights that come from the AWS Well-Architected SaaS Lens.
Level L300
Are YOU an Agent?
How do you survive in the agentic world as a software engineer?
Sheen Brisals | Technologist, O'Reilly Author, AWS Hero, and Team Topologies Advocate
The era when organizations relied solely on skilled programmers to write countless lines of code is fading. Developers who once enjoyed crafting well-structured and well-documented code in their preferred programming languages are now openly turning to their Generative AI coding partners to generate code. Here, language is no longer a barrier.
It’s gradually becoming clear that when it comes to coding productivity, human developers are no match for the code-dumping co-pilots. As this trend continues and gains momentum, how do you survive as a software engineer?
Are you worried that AI and Agents are taking away your job? Are you quietly thinking to yourself that you might lose out in your profession?
This talk will explore your profession from a different perspective. It will examine what has kept you and me as human intellectuals for centuries.
Surviving in this agentic world demands more than just being close to AI Agents and their constantly evolving ecosystem. It requires you to be an agent yourself, one who is far more capable than your GenAI allies.
Level L200
Supporting Ukraine’s National Gen AI CoE with AWS Rapid Flexible Infrastructure
Eric Applewhite | Director | Engineering, AI & Data | Government & Public Services, Deloitte
Against the backdrop of conflict, limited funds, and fragmented architecture, the CoE needed a way to rapidly launch PoCs to scale. Directly supports Ukraine's strategic objective of leveraging technology for economic growth and citizen services. Ukraine launched its national Gen AI CoE in 2024 and launch its first Open Data PoC in 2025.
Delivered Open Data Source Validator PoC in 11 weeks, reducing data set review times from 30 minutes to 2 minutes per data set. And turning a 3 year data backlog into a 12 week one. Our AWS alliance and access to AWS assets provided the critical flexibility, pace, and foundational assets to deliver a scale ready PoC. Our talk will describe the background, outcomes, approach, and critical role AWS played.
Level L100
Context engineering for beginners
Ricardo Sueiras | Principal Advocate for Open Source, AWS
AI Coding Assistants promise to revolutionise developer productivity, yet many engineers struggle to achieve consistent results. Drawing from my twelve month journey with these tools, this talk reveals practical strategies for transforming frustrating experiences into reliable outcomes. I will dive into the topic of “Context Engineering”, why it matters, and how it helps improve the consistency and quality of the code generated. Whether you're new to AI assistants or looking to refine your approach, you'll leave with a better understanding of the potential of these tools' to improve your development efficiency.
Level L200
