Architecture Corner
Discussion about software development, architecture and how to navigate our current landscape. If you want to know more, please check the blog https://medium.com/@mbneto and subscribe for free to the Architecture Corner Newsletter at https://architecturecorner.substack.com/
Episodes
🎙️ From TokenMaxxing to TokenMining
Architecture Corner Newsletter PodcastAI coding budgets are getting torched, and 2026 is the year the bill finally came due. In this episode, we dig into how token consumption became a productivity metric (and why that backfired), and what the industry is doing about it now that the free-for-all is ending.We will cover:Why token usage became a proxy for developer productivity — and how Goodhart
Using Open Telemetry to monitor what your coding agent is doing
Are you flying blind with your AI coding agent?In this episode, we detail what actually happens inside tools like GitHub Copilot and Claude Code beyond the prompt you type.We cover: How LLMs use context windows (and why they "forget") The sharp quality drop that hits at ~40% context usage How to use OpenTelemetry to observe token usage, traces, and system prompts in real timeDon't fo
The Challenges of Evolving Your Service: API Versioning
Once you ship a public API, you've made a promise. Keeping it while still moving forward turns out to be harder than most teams expect.In this episode, we will cover:What qualifies as a backward-compatible change, and what doesn'tWhy does introducing a new API version cost more than just writing new codeThe real reason clients delay upgrades, and what you can do about itHow to support mult
Stop Chasing Updates: Building a Sustainable AI Coding Workflow
The AI development landscape keeps shifting, leaving many developers frustrated as they try to keep up with each new model, tool, and workflow. But what if the answer isn't chasing every update, but building a more intentional approach?In this episode, we will cover:How custom instructions can reduce repetitive prompting and improve consistencyUsing MCP servers to connect your AI tools with e
Managing Trade-offs and Continuous Improvements: DynamoDB multi-attribute Keys
Welcome to the Architecture Corner PodcastIn this edition, we will explore the pros and cons of DynamoDB as a backdrop to talk about the evolution and trade-offs that any architect will have to make.If you want to know more, check the full article at https://medium.com/itnext/managing-trade-offs-and-continuous-improvements-dynamodb-multi-attribute-keys-4eeb0019d79fAnd subscribe, for free, to the A
Spec-Driven Development: A Structured Approach to AI-Assisted Coding
Architecture Corner Newsletter Podcast – where we explore practical frameworks and tools that shape how we build software in the AI era.As AI coding assistants become commonplace, the industry is moving beyond simple prompt-and-pray approaches toward more structured methodologies. This episode examines spec-driven development and how it bridges the gap between traditional software practices and AI
Software Estimations and Agile: Finding the Balance
Architecture Corner Newsletter Podcast - where we explore the practical challenges of software development and discover actionable solutions for real-world scenarios.Estimations and agile methodologies often seem at odds with each other, creating tension in development teams. Many developers struggle with providing meaningful estimates while embracing agile's flexibility, leading to either ove
Event Catalog: Advanced Documentation for Event-Driven Systems
Architecture Corner Newsletter Podcast - exploring documentation strategies that scale with your event-driven architectureEvent Catalog offers capabilities beyond basic service documentation, providing structured approaches to manage complex distributed systems. This episode examines practical features that support enterprise-scale event-driven architectures.In this episode we will cover:Organizat
EventCatalog: Building Documentation for Event-Driven Systems
Architecture Corner Newsletter Podcast explores the tools and practices that make complex software architectures more manageable and maintainable.Event-driven applications often struggle with scattered documentation and poor discoverability of their messaging contracts. EventCatalog emerges as an open-source solution that brings order to this complexity through a documentation-as-code approach.In
Technology Radar: Navigating the "Move Fast" Culture Without Losing Direction
Architecture Corner Newsletter Podcast. In today's development landscape, teams face constant pressure to accelerate delivery while the AI revolution adds even more urgency to ship faster. But speed without direction can lead to chaos - scattered technology choices, knowledge fragmentation, and the dreaded "Tower of Babel" effect in your tech stack.In this episode we will cover:The h
The Developer's AI Dilemma - Coding is Dead, Long Live Coding!
Architecture Corner Newsletter Podcast - The AI revolution has developers split between those declaring code obsolete and others dismissing the hype entirely. But what's the reality behind the headlines about disappearing programming jobs and "vibe coding" taking over?In this episode we will cover:The real story behind the 25% drop in developer job postings and what factors are actua
Finding Balance in Software Development — The Importance of Context
Architecture Corner Newsletter Podcast explores the ongoing debates around software development patterns and practices, examining why developers often find themselves on opposite sides of architectural decisions.In this episode we will cover:The controversy surrounding popular patterns like SOLID principles, hexagonal architecture, and domain-driven designWhy some developers advocate for always us
Step Functions Evolution: JSONata and Simplified I/O Transform Workflow Development
Architecture Corner Newsletter Podcast explores the latest developments in cloud-native architectures and serverless computing patterns that are reshaping how we build distributed systems.In this episode we will cover:AWS Step Functions' new JSONata support and how it shifts functionality from Lambda functions to the state machine itselfThe introduction of variables and simplified Input/Output
Multi-Region Active-Active Patterns: Building for True High Availability
Architecture Corner Newsletter PodcastWhen disaster strikes and takes down an entire region, can your application keep serving users without missing a beat? Multi-region active-active setups promise the shortest recovery times, but they come with their own set of challenges around data synchronization, routing, and complexity trade-offs.In this episode we will cover:The three core patterns for act
Disaster Recovery Strategies for Modern Applications
Architecture Corner Newsletter Podcast - When redundancy and graceful degradation aren't enough, it's time to think beyond single regions and prepare for the worst-case scenarios that can take down entire data centers.In this episode we will cover:Why single-region availability zones have limitations and when you need multi-region strategiesFour disaster recovery approaches: backup and res
Graceful Degradation and Asynchronous Processing for High Availability
Architecture Corner Newsletter Podcast - When system failures are inevitable, the key isn't preventing them but designing around them. Today we explore practical strategies that keep your applications running when dependencies fail, without breaking the bank on complex infrastructure.In this episode we will cover:Implementing graceful degradation patterns to maintain service during dependency
Redundancy and Persistence: Building Resilient Applications
Architecture Corner Newsletter Podcast - Application availability isn't just about uptime percentages; it's about designing systems that gracefully handle failure through strategic redundancy and data persistence patterns.In this episode we will cover:Redundancy fundamentals - How load balancers and reverse proxies distribute traffic across multiple instances and the challenges of maintain
The Real Cost of High Availability: Beyond the Five Nines
Architecture Corner Newsletter Podcast — When your application goes down, every second counts. But what does it really take to achieve those coveted availability percentages, and more importantly, what are you willing to pay for them?In this episode we will cover:Understanding availability metrics and what "five nines" actually means in practiceThe hidden costs and complexity that come w
Don't Ask Permission To Do Your Job Correctly: Escaping The Technical Debt Trap
Architecture Corner Newsletter Podcast - Where we tackle the real challenges that keep developers up at night and explore practical solutions for building better software systems.Technical debt consistently ranks as developers' top frustration, but the problem runs deeper than most teams realize. The issue isn't just accumulating shortcuts - it's falling into what experts call "cr
Load Testing Serverless & Asynchronous Systems: Beyond Traditional Approaches
Architecture Corner Newsletter Podcast explores the complexities of modern distributed systems and the evolving practices needed to ensure their reliability at scale.In this episode we will cover:Why traditional load testing falls short for serverless and asynchronous architecturesThe hidden bottlenecks that synchronous response times can't revealMeasuring what matters: from message queuing to
Balancing Developer Experience with AWS Step Functions Service Integration
Architecture Corner Newsletter Podcast - When migrating workflows to AWS Step Functions, developers often face a critical decision: should they leverage service integrations or stick with traditional Lambda-based approaches? This choice significantly impacts code complexity, testing strategies, and overall developer experience.In this episode we will cover:The migration path from traditional imple
Serverless vs Kubernetes - Building a Decision Framework
Architecture Corner Newsletter Podcast - Choosing the right hosting solution can make or break your application's success, yet many teams fall into the trap of defaulting to familiar technologies without considering the specific requirements at hand.In this episode we will cover:The evolution of application hosting from bare metal to modern cloud solutionsKey characteristics and trade-offs bet
Temporal vs AWS Step Functions: Building Resilient Distributed Systems
Architecture Corner Newsletter Podcast - When distributed systems fail (and they will), how do you handle recovery, state management, and execution continuity without drowning in complexity?In this episode we will cover:The fundamental challenges of building fault-tolerant distributed applicationsHow Temporal's persistent execution model works under the hoodKey architectural differences betwee
Advanced Error Handling in Event-Driven Workflows
Architecture Corner Newsletter Podcast. When workflows fail midway through execution, traditional dead-letter queues often become catch-all repositories that lack proper context, making debugging a detective exercise through scattered logs and systems.In this episode we will cover:The limitations of standard dead-letter queue approaches in saga and process manager patternsRollback strategies for m
Advanced Error Handling in Event-Driven Systems
Architecture Corner Newsletter Podcast. Event-driven architectures bring powerful benefits but introduce new challenges in error detection and handling that many teams struggle to address effectively.In this episode we will cover:The fundamental shift from synchronous to asynchronous error handling patternsHow choreographed sagas can restore visibility into distributed system failuresThe proper us
Event Sourcing Made Simple: Exploring Emmett Framework
Architecture Corner Newsletter Podcast - Event sourcing has long been viewed as a complex pattern that requires significant investment to implement properly. While powerful, its perceived complexity often creates barriers for teams considering adoption.In this episode we will cover:Why event sourcing complexity becomes a barrier to adoptionHow Emmett framework reduces ceremony while maintaining fu
Fundamentals of Software Architecture: Your Engineering Path Forward
Architecture Corner Newsletter Podcast - Breaking down the essential foundations every developer needs to transition into software architecture roles.In this episode we will cover:The core responsibilities that define a software architect's role beyond just technical skillsHow to balance technical breadth versus depth as you develop your architectural thinkingThe four key elements every softwa
AsyncAPI: Beyond Basic Documentation - Advanced Patterns and Real-World Implementation
Architecture Corner Newsletter Podcast - Diving into the practical applications and advanced capabilities of AsyncAPI for asynchronous API documentation and code generation.In this episode we will cover:Handling complex scenarios with multiple environments and dynamic reply channelsCode generation capabilities across TypeScript, C#, Java, Go, and RustValidation and governance integration within CI
AsyncAPI: Bridging the Documentation Gap for Event-Driven Architecture
The Architecture Corner Newsletter Podcast explores the tools and practices that shape modern software systems. Today, we dive into AsyncAPI, a specification that brings the same documentation rigor we expect from REST APIs to the world of asynchronous messaging and event-driven systems.In this episode, we will cover:The challenges teams face when documenting asynchronous communication patterns co
Graceful Degradation: Building Resilient Systems That Bend Without Breaking
Architecture Corner Newsletter Podcast - When dependencies fail and traffic spikes hit, most applications crumble. But what if your system could adapt instead of crash? Today we explore how to design applications that maintain functionality even when things go wrong.In this episode we will cover:Why system reliability decreases exponentially with each new dependencyThe business mindset shift from
BPMN for Cross-Team Collaboration in Software Development
Architecture Corner Newsletter Podcast explores how Business Process Model and Notation (BPMN) can bridge the communication gap between business stakeholders, product teams, and engineering in software development projects.In this episode we will cover:Common communication challenges in multi-team software projects, including the "broken telephone" effect and fragmented team perspectives
DynamoDB APIs and Expressions: From Actions to Implementation
Architecture Corner Newsletter Podcast explores the practical side of working with AWS DynamoDB, moving beyond basic concepts to understand how developers actually interact with this NoSQL database service.In this episode we will cover:The three categories of DynamoDB API actions and when to use each approachExpression attribute names and values for building dynamic queriesKey optional parameters
Idempotency: Building Resilient Systems That Handle Duplicates
Architecture Corner Newsletter Podcast - When systems fail and clients retry, duplicate requests become inevitable. The question isn't whether duplicates will happen, but how your system will handle them.In this episode we will cover:Why duplicate requests are unavoidable in distributed systems and the real-world scenarios that cause themThe core concept of idempotency and how it protects your
Beyond the Hype - Avoiding Dogmatic Thinking in Software Development
Architecture Corner Newsletter Podcast - Every developer faces the temptation to blindly follow the latest best practices, frameworks, and architectural patterns without questioning their true value or fit for the specific context at hand.In this episode we will cover:The psychology behind why developers become dogmatic about technologies and practicesHow confusing implementation processes with ac
Event Versioning in Distributed Systems
Architecture Corner Newsletter Podcast. When building event-driven architectures, one critical decision often gets overlooked until it becomes a problem: how do you handle event versioning? This fundamental aspect can make or break your system's ability to handle real-world challenges like out-of-order messages, duplicates, and missing events.In this episode we will cover:Why event versioning
DynamoDB: Beyond the Key-Value Misconception
Architecture Corner Newsletter Podcast explores the design decisions and trade-offs that shape modern distributed systems. Today we dive into AWS DynamoDB, a managed NoSQL database that's often misunderstood as just another key-value store.In this episode we will cover:Core misconceptions about DynamoDB and why they persist in the developer communityPrimary keys, secondary indexes, and the mod
Not All Events are Created Equal: Choosing the Right Event Pattern for Your Architecture
Architecture Corner Newsletter Podcast - When building event-driven systems, the simple concept of an "event" opens up a world of design decisions that can make or break your architecture's success.In this episode we will cover:The fundamental differences between thin events, event-carried state transfer, and event-sourcing patternsTrade-offs between coupling and performance when des
When Distributed Transactions Make Sense: Understanding the Saga Pattern
Architecture Corner Newsletter Podcast, exploring the complexities of distributed system design and when traditional database transactions aren't enough.In this episode we will cover:The fundamental challenge of maintaining consistency across distributed servicesHow to identify when your system actually needs a saga versus simpler solutionsThe critical decision framework: asking if failed task
Shifting Perspectives: API Design at the Core of Development
Architecture Corner Newsletter Podcast. We explore the strategic shift from traditional bottom-up development to putting API design first, examining why this approach has become critical for modern software teams.In this episode, we will cover:The fundamental principles behind API-first development and why it matters for client adoptionPractical techniques for defining intent and creating live doc
Blue/Green and Canary Deployments with AWS Step Functions
Architecture Corner Newsletter Podcast explores the latest AWS capabilities that bring progressive deployment strategies to serverless orchestration workflows.In this episode we will cover:The challenges of deploying Step Function changes without impacting all users simultaneouslyHow AWS Step Functions now supports versions and aliases for controlled rolloutsSetting up traffic splitting between di
Functional Core and Imperative Shell: Bridging FP and Enterprise Architecture
Architecture Corner Newsletter Podcast explores how functional programming principles can transform enterprise development without abandoning clean architecture practices.In this episode we will cover:The fundamentals of pure functions and immutability in enterprise contextsHow the functional core and imperative shell pattern separates business logic from side effectsImplementing Domain-Driven Des
API vs. Messaging: Making the Right Choice for Your Architecture
Architecture Corner Newsletter Podcast - where we dive into the technical decisions that shape modern software systems.In this episode, we will cover:The fundamental differences between API and messaging communication patternsWhen synchronous responses are necessary versus when asynchronous processing works betterHow team expertise and tooling availability should influence your technology choicesM
AI Revolution: Friend or Foe for Software Development?
Architecture Corner Newsletter Podcast - where we explore the intersection of technology trends and software architecture decisions that shape our industry.In this episode we will cover:The current state of AI hype and how it compares to past technology disruptionsWhy language generation models have captured mainstream attention nowThe reality of AI's impact on software development workflows a
When Scaling Is Not An Option: A Simple Asynchronous Pattern
Architecture Corner Newsletter Podcast - exploring practical software architecture solutions for real-world challenges.In this episode we will cover:The three types of API requests and how to identify which ones can handle delayed responsesHow message queues can serve as a buffer to manage traffic spikes without infrastructure scalingTwo communication patterns for asynchronous processing: polling
Scaling AWS Step Functions: When Standard Maps Hit Their Limits
Architecture Corner Newsletter Podcast - Your deep dive into cloud architecture patterns and real-world implementation strategies.In this episode, we will cover:Understanding AWS Step Functions Map state capabilities and constraintsThe 256KB payload limitation and its impact on large-scale processingConcurrency bottlenecks with standard Maps (40 execution limit)How Distributed Maps solve size and
Serverless Backlash: Context is King in Architecture Decisions
Architecture Corner Newsletter Podcast - where we dive into real-world architecture decisions and the lessons they teach us about building better systems.In this episode we will cover:Amazon Prime Video's shift away from serverless and the 90% cost reduction that followedWhy context matters more than following architectural trends blindlyThe principle of continuous improvement and when to adap
DocumentDB Streams: A Cure For Your NoSQL CDC Blues?
Architecture Corner Newsletter Podcast, where we explore cloud architecture patterns and AWS services that can transform how you build modern applications.In this episode we will cover:Change Data Capture (CDC) fundamentals and why it matters for application integrationDocumentDB Streams capabilities and how they enable reactive architecturesThe recent Lambda event source integration that simplifi
The Certification Trap: When Getting Certified Becomes the Goal Instead of the Journey
Architecture Corner Newsletter Podcast - where we dissect the trends and decisions shaping modern software architecture and engineering careers.In this episode we will cover:The explosion of tech certifications and why everyone seems to be pursuing themHow social media creates unrealistic expectations about certification timelines and outcomesThe disconnect between passing exams and actual job per
Scaling Software Architecture: Building an Architectural Mindset in Your Development Team
Architecture Corner Newsletter Podcast - where we explore practical approaches to software architecture challenges and help you build better systems.In this episode we will cover:How to evaluate new technologies responsibly instead of chasing every shiny frameworkThe three key questions to ask before adopting any new tool or technologyArchitecture presentations as a method for knowledge sharing ac
Code reviews are more than just catching bugs
In this episode we will cover:Why treating pull requests as peer reviews transforms team knowledge sharingThe hidden costs of large PRs and how they compromise review qualityPractical strategies for authors to create reviewable code changesHow reviewers can focus on what matters most: clarity and correctnessBreaking down common pitfalls that derail the review processBuilding discipline around time
Solving concurrency challenges with AWS Step Functions
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 short
Scaling Software Architecture: Federation, Radar, and Catalog Approaches
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 structuresUsing technology radars to guide adoption decisions from "hold" to "adopt" phasesBu
Tackling Data Consistency in Event-Driven Systems
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 systemsHow EventBridge Pipes can simplify you
Scaling software architecture beyond the ivory tower
We will cover:What software architecture really is and why it's not just about technical decisions made in isolationThe three major pitfalls that derail architecture practices - from overly abstract solutions to technology FOMOWhy architects shouldn't make all the decisions and how to identify which choices actually matterReal examples of when simple beats complex, including an insurance c
Concurrency Control with AWS Lambda and SQS
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 executionsTraditional approaches to m
EventBridge Pipes - Enrichment and Transformation For the Win
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 DiveHow to add custom logic without rebuilding your entire pipelineReal-world scenarios for reaching external services and APIsSynchronous processing and automatic retry mechanismsInput Transformation StrategiesBuilt-in
The Reality of Coupling in Event-Driven Architecture
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 systemsThree distinct types of coupling that impact your architecture decisionsWhy "zero coupling" might be an impos
EventBridge Pipes - The Missing Link in Your Event Architecture?
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 architectureReal-world implementation scenarios with DynamoDB Streams, SQS,
The Real Story of No-Code and Low-Code Development
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 t
Rethinking Time in Your Architecture
From Step Functions to EventBridge Scheduler: Simplifying Temporal ModelingJoin 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:The f
Cache Me If You Can - When Caching Helps and When It Hurts
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 solutionThree core caching patterns: read-through, write-through, and write-behind—with their hidden trade-offsThe
Runtime Reality Check for TypeScript Developers
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 runtimeValidation boundaries – Where and when
The Knowledge Acceleration Problem
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 behi
Rethinking How We Model Time in Software Systems
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 thi
Demystifying DDD Aggregate Design
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 aggregateBusiness invariants decoded: How to distinguish between true (atomic) and eventual invariants—and why it matters for your architecture
Beyond DDD Basics - Mastering Multi-Bounded Context Integration
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 CoverThe lan
Rethinking Infrastructure as Code
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 alternativesSAM's approach to simplifying CloudFormation for serverless appl
Rethinking Kafka in the Serverless Era
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 budgets
Vertical Software Development: Putting Agile Theory into Practice
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 ar
How do you test a distributed workflow without deploying anything?
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.
Approaching Observability from a Domain-Oriented Perspective
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
AWS Kinesis: On-demand option
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
When Abstractions Actually Matter (And When They Don't)
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 superpowerThe hidden value of layered architecture beyond "easy rewrites"A migration story that saved weeks of developme
AWS Step Functions in Production - What They Don't Tell You
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 baconConcurrent execution patterns that slash processing timeIdempotency features that prevent duplicate nightmaresThe Gotchas:The 25K event limit that nobody talks about (and how to work around it)Why t
Mastering AWS SQS + Lambda Batch Processing
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 reprocessingHow AWS evolved from Kinesis-only solutions to include SQS batch item reportingThe new ReportBatchItemFailures feature and how it transf
When REST is Not Enough
In this episode, we look into the limitations that emerge when REST's CRUD-focused approach meets complex business domains. We will cover:The hidden costs of oversimplifying complex domains with basic CRUD operationsHow task-based UI approaches preserve business intent in your API designPractical strategies for identifying when your aggregates have grown too largeThe role of Domain-Driven Desi
Adopting an Event-Driven Architecture: Kinesis
In this final part, we look at Kinesis and how it revolutionizes event-driven architecture! We'll explore:How Kinesis differs from traditional messaging solutions like SQS, SNS, and EventBridgeThe unique streaming approach that keeps data accessible to multiple consumersEssential components like shards, data records, and streamsPractical strategies for scaling and handling increased throughput
Adopting an Event-Driven Architecture: EventBridge
In this episode, we continue to explore AWS Services and this time we will talk about EventBridge.We'll explore:How EventBridge fits into the AWS messaging ecosystemWhen to choose EventBridge over SNS/SQSContent-based filtering capabilities you can't get elsewhereReal-world integration patterns with SaaS providers and Step FunctionsFor more details check here.If you are interested in mor
Adopting an Event-Driven Architecture: SNS
Last episode we covered SQS and its place in event-driven architecture.This episode we will cover:In this episode, we explore:Why standard queues fall short in complex systemsHow SNS enables the publisher/subscriber pattern with remarkable flexibilityThe game-changing fan-out capabilities that transform how your applications communicateStrategic approaches to message filtering that can dramaticall
Adopting an Event-Driven Architecture: SQS
This week we look at SQS as part of our tooling with an event-driven architecture.What you'll discover:The core components that make event-driven architecture tickWhy point-to-point messaging remains a powerful decoupling strategyThe critical differences between Standard and FIFO queues that can make or break your applicationAdvanced techniques for scaling throughput while maintaining message inte
