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)
• Why treating everything as a state can backfire
• Out-of-order execution scenarios that will keep you up at night

The Pain Points:

• Error handling that becomes repetitive fast
• Local development challenges that slow teams down
• When Step Functions make things more complex, not simpler

For more details check here.

If you are interested in more information about software development and architecture, subscribe for free to our ⁠newsletter⁠.

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 transforms error handling
• Practical strategies for implementing robust batch processing in your Lambda functions

For more details check ⁠here⁠.

If you are interested in more information about software development and architecture, subscribe for free to our ⁠newsletter⁠.

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 operations
• How task-based UI approaches preserve business intent in your API design
• Practical strategies for identifying when your aggregates have grown too large
• The role of Domain-Driven Design in shaping more intentional service boundaries
• Real examples from product management systems that illustrate these concepts in action

For more details check ⁠here.

If you are interested in more information about software development and architecture, subscribe for free to our ⁠newsletter⁠.

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 EventBridge
• The unique streaming approach that keeps data accessible to multiple consumers
• Essential components like shards, data records, and streams
• Practical strategies for scaling and handling increased throughput
• Real-world decision frameworks to help you choose the right AWS messaging solution for your specific needs

For more details check ⁠here⁠.

If you are interested in more information about software development and architecture, subscribe for free to our ⁠newsletter⁠.

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 ecosystem
• When to choose EventBridge over SNS/SQS
• Content-based filtering capabilities you can't get elsewhere
• Real-world integration patterns with SaaS providers and Step Functions

For more details check ⁠here⁠.

If you are interested in more information about software development and architecture, subscribe for free to our ⁠newsletter⁠.

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 systems
• How SNS enables the publisher/subscriber pattern with remarkable flexibility
• The game-changing fan-out capabilities that transform how your applications communicate
• Strategic approaches to message filtering that can dramatically reduce complexity

For more details check here.

If you are interested in more information about software development and architecture, subscribe for free to our ⁠newsletter⁠.

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 tick
• Why point-to-point messaging remains a powerful decoupling strategy
• The critical differences between Standard and FIFO queues that can make or break your application
• Advanced techniques for scaling throughput while maintaining message integrity
• Real-world solutions for common challenges like handling large payloads

In this episode, we will explore eventual consistency and, in the process:

• Discover why your perfectly working development code mysteriously fails in production
• Explore practical strategies for handling the infamous "read-after-write" problem
• Learn elegant approaches to manage concurrency without sacrificing performance
• Uncover the trade-offs between simple solutions and sophisticated implementations

• 
  

For more details check here.

If you are interested in more information about software development and architecture, subscribe for free to our ⁠newsletter⁠].