Architecture Corner

Asynchronous architectures are everywhere in modern cloud development, but they bring unique concurrency challenges that can trip up even experienced engineers. When your Step Functions are running wild and your downstream services are getting overwhelmed, you need practical solutions that actually work in production. In this episode we will cover: Why traditional SQS concurrency controls fall sho...

Software architecture practice needs to scale beyond individual architects, and there are proven strategies to make this happen across your organization. We will cover: How federated models with Technology Architecture Groups and Domain Architecture Groups create scalable decision-making structures Using technology radars to guide adoption decisions from "hold" to "adopt" phase...

When building event-driven architectures, you'll inevitably face the challenge of keeping your database state and published events in sync. One failed operation can leave your entire system in an inconsistent state, causing downstream services to miss critical updates. We will cover: The transactional outbox pattern and why it matters for distributed systems How EventBridge Pipes can simplify...

We will cover: What software architecture really is and why it's not just about technical decisions made in isolation The three major pitfalls that derail architecture practices - from overly abstract solutions to technology FOMO Why architects shouldn't make all the decisions and how to identify which choices actually matter Real examples of when simple beats complex, including an insuran...

Managing concurrency in serverless applications can significantly impact your system's performance and reliability. When your Lambda functions start overwhelming downstream services or hitting execution limits, you need practical solutions that don't require complex custom code. We will cover: The core challenges of concurrency in asynchronous serverless executions Traditional approaches t...

Join us as we dive deep into AWS EventBridge Pipes and explore whether this service truly fills the gaps in your event-driven systems. What We'll Cover: The Enrichment Stage Deep Dive How to add custom logic without rebuilding your entire pipeline Real-world scenarios for reaching external services and APIs Synchronous processing and automatic retry mechanisms Input Transformation Strategies B...

Is EDA really the decoupling solution we think it is? Join us as we dive into the nuanced world of Event-Driven Architecture with insights from Mario Bittencourt's analysis on coupling challenges. We'll explore: The promise versus reality of decoupling in distributed systems Three distinct types of coupling that impact your architecture decisions Why "zero coupling" might be an i...

Ever wondered if there's a better way to connect your event sources without writing custom glue code? Join us as we dive into AWS EventBridge Pipes, a service that brings Unix pipeline concepts to modern event-driven architectures. What We'll Cover: The pipeline philosophy behind EventBridge Pipes and its four-stage architecture Real-world implementation scenarios with DynamoDB Streams, SQ...

In this episode, we cut through the marketing noise to examine what no-code and low-code development deliver in practice. We'll explore the fundamental differences between these approaches, walk through real implementations from major cloud providers like AWS, Google, and Microsoft, and analyze a concrete use case that reveals the true trade-offs involved. What We'll Cover: The definitions...

From Step Functions to EventBridge Scheduler: Simplifying Temporal Modeling Join us as we explore how AWS EventBridge Scheduler is changing the game for time-based business logic. We'll dive into the evolution from complex Step Functions workflows to streamlined scheduling solutions, examining real-world scenarios like e-commerce order processing with remorse periods. What You'll Learn: Th...

In this episode, we dive into the world of caching strategies with Mario Bittencourt's insights on when caching makes sense—and when it creates more problems than it solves. What We'll Explore: The real reasons behind high-latency applications and whether caching is actually the solution Three core caching patterns : read-through, write-through, and write-behind—with their hidden trade-off...

In this episode, we dive into one of TypeScript's most overlooked limitations: the gap between compile-time types and runtime reality. When your carefully typed interfaces meet dynamic data from APIs, user inputs, or external services, things can go sideways fast. What We'll Cover: The TypeScript illusion – Why your types don't protect you at runtime Validation boundaries – Where and w...

How do you stay current when human knowledge now doubles every 12 hours? Join us as we dive into the reality facing today's tech professionals: the exponential growth of information and the challenge of keeping pace. We'll explore practical strategies for continuous learning, from individual habits that work to organizational approaches that scale. What We'll Cover: The shocking math b...

In this episode, we explore temporal modeling: a paradigm shift that treats the passage of time as a first-class citizen in software architecture. We'll uncover why traditional schedulers might be working against you and how reactive approaches to time-based events can transform both your code and your business logic. What We'll Cover: Why structure-first modeling misses the story of how t...

In this episode, we'll unpack the confusion surrounding aggregate design and reveal why most developers get it wrong from the start. What We'll Cover: The aggregate misconception : Why having related entities doesn't automatically mean you have an aggregate Business invariants decoded : How to distinguish between true (atomic) and eventual invariants—and why it matters for your archite...

Join us as we tackle one of Domain-Driven Design's most challenging aspects: integrating multiple bounded contexts. When developers move beyond DDD fundamentals, they often hit a wall with multi-context integration. In this episode, we explore how to connect different bounded contexts without losing the clarity and boundaries that make DDD powerful in the first place. What We'll Cover The...

The infrastructure-as-code landscape is shifting. While tools like Terraform and Serverless Framework have been reliable workhorses, AWS SAM and CDK are emerging as potential game-changers for serverless development. In this episode, we dive into: The current state of infrastructure tooling and why teams are looking for alternatives SAM's approach to simplifying CloudFormation for serverless a...

Managing Kafka clusters has long been a resource-intensive challenge that keeps DevOps teams awake at night. But what if there was a way to get all the power of Kafka without the operational overhead? In this episode, we dive into the world of serverless streaming solutions and explore how platforms like Upstash are changing the game. We'll unpack: Why traditional Kafka deployments drain budge...

In this episode, we explore how teams can bridge the gap between Agile theory and real-world development. We explore the layered vs. vertical development debate, examine how feature slicing affects code reviews, and share a practical approach to incrementally building software that aligns with business value without overengineering from the outset. Tune in to hear how small shifts in mindset and a...

In this episode, we look at the challenges of mocking AWS Step Functions — especially when service integrations like SQS or Lambda are involved. We explore the limitations of local emulation, how AWS recently improved support for mocking specific states, and what this unlocks for development and testing scenarios.

In this episode, we explore how to approach observability in distributed systems with a lens that goes beyond tooling and into design. Let's break down how a domain-oriented perspective can reduce noise, bring clarity, and make instrumentation more intentional. We’ll talk about why correlation IDs matter, how tracing ties it all together, and how domain probes can shift how your teams think ab...

Thinking of adding streaming to your app? In this episode, we explore the AWS Kinesis on-demand mode — what it solves, what it doesn’t, and how it compares to other messaging options like Kafka and MSK. We’ll walk through how scaling works, what to watch out for with partition keys, and when the traditional model may still be the better choice. Tune in if you’re navigating the trade-offs of stream...

Are you tired of hearing "just use interfaces" without understanding why? This episode cuts through the noise around software abstractions with real-world stories and practical insights. We'll explore: Why the common arguments for interfaces miss their true superpower The hidden value of layered architecture beyond "easy rewrites" A migration story that saved weeks of devel...

In this episode, we will explore the lessons learned after a full year of production experience with Step Functions across multiple teams. The Wins: Built-in retry mechanisms that actually save your bacon Concurrent execution patterns that slash processing time Idempotency features that prevent duplicate nightmares The Gotchas: The 25K event limit that nobody talks about (and how to work around it...

In this episode, we'll explore how batching can boost throughput and reduce costs in your serverless applications, but also introduce unique challenges around error handling. You'll Learn: The core challenge of partial batch failures and message reprocessing How AWS evolved from Kinesis-only solutions to include SQS batch item reporting The new ReportBatchItemFailures feature and how it tr...