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" phases
• Building architecture catalogs that capture recurring patterns and solutions
• Why bidirectional communication between architecture levels reduces bottlenecks
• Practical approaches to reduce the dependency on senior architects while maintaining quality

For more details check ⁠here⁠.

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

---

https://architecturecorner.substack.com

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 your implementation with minimal code
• Practical scenarios for publishing domain events versus thin integration events
• Real-world code examples using DynamoDB and transaction writes
• Performance considerations and monitoring strategies for production systems

For more details check ⁠here.

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

---

https://architecturecorner.substack.com

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 insurance cost calculation case study
• How to avoid the "technology merry-go-round" and make deliberate choices about new tools and frameworks
• The importance of staying grounded in business outcomes rather than chasing technical perfection

For more details check ⁠here.

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

---

https://architecturecorner.substack.com

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 to managing Lambda concurrency and their limitations
• How reserved concurrency works and its potential drawbacks
• AWS's Maximum Concurrency feature for SQS event sources
• The difference between reserved and maximum concurrency settings
• Real-world scenarios where concurrency control prevents system overload
• Best practices for implementing concurrency controls without losing messages

For more details check here.

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

----

https://architecturecorner.substack.com

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

• Built-in configuration options vs. custom Lambda functions
• When to use JSON Path transformations
• Console testing features you didn't know existed

Production Readiness

• Error handling patterns and dead letter queue configurations
• Monitoring strategies and CloudWatch integration
• Performance considerations and cost implications

Decision Framework

• Should you migrate from your existing Lambda-based solutions?
• Hosted workers vs. serverless: when Pipes makes sense
• Cost-benefit analysis for different architectural patterns

For more details check ⁠here.

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

---

https://architecturecorner.substrack.com

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 impossible dream
• Real-world challenges you'll face: out-of-order events, message duplication, and debugging complexity

For more details check ⁠here⁠.

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

---

https://architecturecorner.substack.com/

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, SQS, and SNS
• How filtering can save you costs and reduce complexity
• SAM template examples and practical configuration tips
• When EventBridge Pipes makes sense (and when it doesn't)

For more details check ⁠here.

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

---

https://architecturecorner.substack.com

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 that matter: Understanding what low-code and no-code really mean for developers and business users
• Platform deep-dive: How AWS Step Functions, Google AppSheet, and Microsoft Power Apps approach the challenge differently
• A practical case study comparing traditional coding versus low-code implementation for a shipping label workflow
• The hidden costs and unexpected benefits that emerge when theory meets reality
• Where these tools fit (and don't fit) in the broader technology adoption cycle

For more details, check ⁠here⁠.

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

---

See https://architecturecorner.substack.com