The Curious Engineer

All blogs / Software / engineering practice

Event-Driven by Oskar Dudycz

event-driven.io

Practical articles, training, and consulting about Event Sourcing, event-driven architecture, CQRS, and software architecture.

Software / engineering practiceDistributed systems / cloudDatabases

’23’24’25’26
Posts
300 from 11 Jun 2023 to 19 Oct 2026
Posting
weekly (33 in the last year)
Kind
personal blog
Feed
https://event-driven.io/rss.xml

2026 27

  1. Thoughts on Dynamic Consistency Boundary
  2. Sharing is (not always) caring. PgBouncer pooling modes in practice
  3. Open Source, a relic, a charity or still the thing?
  4. We all wanted to be Netflix, who do we want to be next?
  5. Avoid Duke Nukem Forever Mode
  6. Start Small, Grow Big: how to pick the first feature for Event Sourcing
  7. Fractal Architecture, Cognitive Load, Vertical Slices and other terms that do(n't) fit your head
  8. Vertical slices, their ownership and external dependencies
  9. Fixing bugs in Event Sourcing is hard, for real?
  10. Throw, Result, or neither?
  11. On swimming, learning and my journey to being the last one
  12. Addition by subtraction in Software Design
  13. Announcing Strictland - new contract testing library for message compatibility
  14. You can fork a package, but can you own it?
  15. How soon is now in PostgreSQL?
  16. On mashing up modelling techniques for fun and profit
  17. Don't overestimate domain expertise
  18. Vibing, Harness and OODA loop
  19. Yoda Principle for better integrations
  20. Anti-patterns in event modelling - Passive-Aggressive Events
  21. The one where Oskar explains Example Mapping
  22. Interactive Rubber Ducking with GenAI
  23. The End of Coding? Wrong Question
  24. Parse, Don't Guess
  25. How I cheated on transactions. Or how to make tradeoffs based on my Cloudflare D1 support
  26. On rebuilding read models, Dead-Letter Queues and Why Letting Go is Sometimes the Answer
  27. Rebuilding Event-Driven Read Models in a safe and resilient way

2025 46

  1. Architecture Weekly is 5 years old! 🎉
  2. Multi-tenancy and dynamic messaging workload distribution
  3. Checkpointing the message processing
  4. Consumers, projectors, reactors and all that messaging jazz in Emmett
  5. Requeuing Roulette in Event-Driven Architecture and Messaging
  6. Handling Events Coming in an Unknown Order
  7. Dealing with Race Conditions in Event-Driven Architecture with Read Models
  8. On Messaging and Distributed Systems with Ian Cooper
  9. New Recording on Event modelling anti-patterns from DDDEU
  10. Sneaky Code Bites Back
  11. PostgreSQL partitioning, logical replication and other Q&A about PostgreSQL Superpowers
  12. Just use SQL they say... Or how accidental complexity piles on
  13. My thoughts on Vertical Slices, CQRS, Semantic Diffusion and other fancy words
  14. Compilers Aren't Just for Programming Languages
  15. Requiem for a 10x Engineer Dream
  16. Why Open Source Isn't Always Fair. Dual licenses explained
  17. Workflow Engine design proposal, tell me your thoughts
  18. The Order of Things: Why You Can't Have Both Speed and Ordering in Distributed Systems
  19. Dealing with Eventual Consistency, and Causal Consistency using Predictable Identifiers
  20. Predictable Identifiers: Enabling True Module Autonomy in Distributed Systems
  21. Start Alone, Then Together: Why Software Modelling Needs Solitary Brainstorming
  22. Secondary Indexes and the Specialized Storage Dilemma
  23. Do we still need the QA role?
  24. Killer metrics, or why you should know upfront when to remove the new feature
  25. Residuality Theory: A Rebellious Take on Building Systems That Actually Survive
  26. The Underestimated Power of Hot Spots and Notes in EventStorming
  27. Hints on getting to speak at conferences
  28. Why We Should Learn Multiple Programming Languages
  29. Business Won't Let Me and other lies we tell to ourselves
  30. PostgreSQL JSONB - Powerful Storage for Semi-Structured Data
  31. Monolith-First - are you sure?
  32. What we don't know that we don't know
  33. We are no superhumans
  34. TypeScript Migrates to Go: What's Really Behind That 10x Performance Claim?
  35. Whole Architecture Weekly content is free now!
  36. Practical Introduction to Event Sourcing with Emmett
  37. So you want to break down monolith? Read that first.
  38. How does Kafka know what was the last message it processed? Deep dive into Offset Tracking
  39. Documenting Event-Driven Architecture with EventCatalog and David Boyne
  40. Defining Your Paranoia Level: Navigating Change Without the Overkill
  41. React Query: A solution for Frontend State Management challenges? With Tomasz Ducin
  42. Understanding Kafka's Consumer Protocol: A Deep Dive into How Consumers Talk to Brokers
  43. Kafka Consumers: Under the Hood of Message Processing
  44. How Kafka Producer Works internally
  45. How to build MongoDB Event Store
  46. Thoughts on Platforms, Core Teams, DORA Report and all that jazz

2024 59

  1. Locks, Queues and business workflows processing
  2. Distributed Locking: A Practical Guide
  3. On getting the meaningful discussions, and why that's important
  4. The Write-Ahead Log: A Foundation for Reliability in Databases and Distributed systems
  5. Applying Observability: From Strategy to Practice with Hazel Weakly
  6. Deduplication in Distributed Systems: Myths, Realities, and Practical Solutions
  7. Ordering, Grouping and Consistency in Messaging systems
  8. Idempotent Command Handling
  9. Building your own Ledger Database
  10. Tech Debt doesn't exist, but trade-offs do
  11. Frontent Architecture, Backend Architecture or just Architecture? With Tomasz Ducin
  12. Bootstrapping CRUD with Pongo
  13. Don't Oversell Ideas: Trunk-Based Development Edition
  14. Running a regular SQL on Pongo documents
  15. Why to measure and make our system observable? How to reason on chaotic world
  16. Pongo behind the scenes
  17. Webinar #23 - Gojko Adzic on designing product development experiments with Lizard Optimization
  18. Webinar #22 - On Performance Testing with Jarosław Pałka
  19. Making your system observability predictable
  20. When Logs and metrics are not enough: Discovering Modern Observability
  21. Pongo gets strongly-typed client, migrations, and command line tooling
  22. Show me the money! Practically navigating the Cloud Costs Complexity
  23. Using S3 but not the way you expected. S3 as strongly consistent event store
  24. My Architecture Drivers
  25. Webinar #21 - Michael Drogalis: Building the product on your own terms
  26. Architecture Weekly #192 - Talk is cheap, show me the numbers! Benchmarking and beyond!
  27. Using event metadata in event-driven projections
  28. Is It Production Ready?
  29. Writing and testing event-driven projections with Emmett, Pongo and PostgreSQL
  30. Architecture Weekly #190 - Queuing, Backpressure, Single Writer and other useful patterns for managing concurrency
  31. Mastering Database Connection Pooling
  32. Event Sourcing on PostgreSQL in Node.js just became possible with Emmett
  33. Pongo - Mongo but on Postgres and with strong consistency benefits
  34. Filtering EventStoreDB subscriptions by event types
  35. How to automatically setup pgAdmin with a Docker database
  36. Setting up NGINX load balancer for .NET WebApi
  37. Combining the To-Do List and the Passage Of Time patterns for resilient business workflows
  38. Let's build the worst Event Sourcing system!
  39. Why you should batch message processing and how to do it with .NET AsyncEnumerable
  40. Docker Compose Profiles, one the most useful and underrated features
  41. How to write a left-fold streams collector in Java
  42. This is not your uncle's Java! Modelling with Java 22 records pattern matching in practice
  43. How to configure a custom Test Container on the EventStoreDB example
  44. Mocking the native Node.js Test Runner
  45. How to build an in-memory Message Bus in TypeScript
  46. Event modelling anti-patterns explained
  47. I'm no longer Marten maintainer
  48. Testing Event Sourcing, Emmett edition
  49. Join my Event Sourcing workshops at Techorama and DDD Europe and speed up your journey!
  50. How to tackle compatibility issues in ECMA Script modules (and in general)
  51. Keeping our overachieving freak on a leash
  52. Should you always keep streams short in Event Sourcing?
  53. Implementing Closing the Books pattern
  54. Announcing Emmett! Take your event-driven applications back to the future!
  55. Production-Grade Event Sourcing Workshop - Modelling, DevOps, Process
  56. How TypeScript can help in modelling business workflows
  57. Stream ids, event types prefixes and other event data you might not want to slice off
  58. Should you record multiple events from business logic?
  59. Not all issues are complex, some are complicated. Here's how to deal with them

2023 30

  1. What Dune can tell us about setting our goals
  2. Why I won't use .NET Aspire for now
  3. Hitchhiker's Guide To Moving From Relational Data To Events
  4. A few notes on migrating storage library
  5. Are you Marten or Wolverine user? Tell us more!
  6. How to deal with privacy and GDPR in Event-Driven systems
  7. We introduced support plans for Marten
  8. GDPR for busy developers
  9. Anti-patterns in event modelling - Clickbait event
  10. Women in IT
  11. In the defence of Object-Relational Mappers
  12. Internal and external events, or how to design event-driven API
  13. How to design software architecture pragmatically
  14. Is the Strategy Pattern an ultimate solution for low coupling?
  15. Oops I did it again, or how to update past data in Event Sourcing
  16. Architecture Weekly became the Substack Bestseller!
  17. My journey from Aggregates to Functional Composition
  18. Event transformations, a tool to keep our processes loosely coupled
  19. Prototyping, an underestimated design skill
  20. Behaviour-Driven Design is more than tests
  21. Could you help me by filling a short survey about an online course?
  22. A simple way to configure integration tests pipeline
  23. How to scale out Marten
  24. How to set global setting for XUnit tests
  25. How to create a Docker image for the Marten application
  26. Vertical Slices in practice
  27. Follow the money to get a better design
  28. Removability over Maintainability
  29. Recap of Event Sourcing Live 2023
  30. A few words on communication

Undated 138

  1. The Holy Grail syndrome
  2. Anti-patterns in event modelling - I'll just add one more field
  3. Is the audit log a proper architecture driver for Event Sourcing?
  4. A few notes on running open source project after Marten v6 release
  5. General strategy for migrating relational data to document-based
  6. How to test event-driven projections
  7. Publishing read model changes from Marten
  8. Postgres Superpowers in Practice
  9. Event stores are key-value databases, and why that matters
  10. ChatGPT, revolution or not?
  11. Ensuring uniqueness in Marten event store
  12. Projecting Marten events to Elasticsearch
  13. How to handle multiple commands in the same transaction
  14. Fun with serial JSON
  15. Don't let Event-Driven Architecture buzzwords fool you
  16. Set up OpenTelemetry with Event Sourcing and Marten
  17. Event-driven projections in Marten explained
  18. Explicit validation in C# just got simpler!
  19. Stacking the bricks in the software development process
  20. Guide to Projections and Read Models in Event-Driven Architecture
  21. How to validate business logic
  22. Let's build event store in one hour!
  23. Don't be like Ebenezer Scrooge. A few words about workaholism
  24. Explicit events serialisation in Event Sourcing
  25. The magic is that there is no magic. Or how to understand design patterns.
  26. Share your story on Event Sourcing Live 2023
  27. Testing asynchronous processes with a little help from .NET Channels
  28. Mapping event type by convention
  29. How to get all messages through Postgres logical replication
  30. How events can help in making the state-based approach efficient
  31. Never Lose Data Again - Event Sourcing to the Rescue!
  32. How Postgres sequences issues can impact your messaging guarantees
  33. Writing and testing business logic in F#
  34. Push-based Outbox Pattern with Postgres Logical Replication
  35. Testing business logic in Event Sourcing, and beyond!
  36. Dive a bit deeper, look a bit wider
  37. On the importance of setting boundaries in team management
  38. It doesn't have to be toxic at work
  39. Event Versioning with Marten
  40. Slim your aggregates with Event Sourcing!
  41. How playing on guitar can help you to be a better developer?
  42. What do the British writer and his fence have to do with Software Architecture?
  43. Why are we afraid of our decisions?
  44. Straightforward Event Sourcing with TypeScript and NodeJS
  45. Union types in C#
  46. How to effectively compose your business logic
  47. Event-driven distributed processes by example
  48. Is keeping dates in UTC really the best solution?
  49. Should you generate the client code from the API?
  50. Unobvious things you need to know about key-value stores
  51. Ogooreck, a sneaky testing library in BDD style
  52. Should you throw an exception when rebuilding the state from events?
  53. Why I'm leaving Event Store and getting ready for the next episode
  54. Power of ignorance, or how to write simple code
  55. What onion has to do with Clean Code?
  56. A few tricks on how to set up related Docker images with docker-compose
  57. Persistent vs catch-up, EventStoreDB subscriptions in action
  58. How to build a simple event pipeline
  59. Are Temporal Tables an alternative to Event Sourcing?
  60. Agile vs Introverts
  61. The risk of ignoring risks
  62. Twelve things I learned about Java during my last code review
  63. Small rant about the Software Design
  64. Introduction to Event Sourcing - Self Paced Kit
  65. How to ensure uniqueness in Event Sourcing
  66. “I'm not interested in politics” is not actual anymore
  67. 15 tips on how to run meetings effectively
  68. Immutable Value Objects are simpler and more useful than you think!
  69. How to quickly scale a legacy monolith?
  70. I tested it on production and I'm not ashamed of it
  71. A simple trick for idempotency handling in the Elastic Search read model
  72. Using strongly-typed identifiers with Marten
  73. Should a programmer's creativity be shown in code formatting?
  74. No, it can never happen!
  75. Integrating Marten with other systems
  76. How to do snapshots in Marten?
  77. CQRS is simpler than you think with .NET 6 and C# 10
  78. Keep your streams short! Temporal modeling for fast reads and optimal data retention
  79. Simple patterns for events schema versioning
  80. Event Streaming is not Event Sourcing!
  81. How to register all CQRS handlers by convention
  82. Long-polling, how to make our async API synchronous
  83. Dealing with Eventual Consistency and Idempotency in MongoDB projections
  84. How to use ETag header for optimistic concurrency
  85. Tell, don't ask! Or, how to keep an eye on boiling milk
  86. What does Mr Bean opening the car have to do with programming?
  87. What does a construction failure have to do with our authorities?
  88. Let's talk about positions in event stores
  89. How to build event-driven projections with Entity Framework
  90. 10 notes on the 10th blogging anniversary
  91. Anti-patterns in event modelling - State Obsession
  92. How to slice the codebase effectively?
  93. Will it scale... down?
  94. Computer says no! Why we might have an issue with Artificial Intelligence soon
  95. Anti-patterns in event modelling - Property Sourcing
  96. How to build and push Docker image with GitHub actions?
  97. How to build an optimal Docker image for your application?
  98. Notes about C# records and Nullable Reference Types
  99. In what language are programmers writing?
  100. Snapshotting Strategies
  101. Form a wall! And other concerns about security
  102. Let's take care of ourselves! Thoughts on compatibility
  103. How to get the current entity state from events?
  104. When not to use Event Sourcing?
  105. Generic does not mean Simple
  106. Structural Typing in TypeScript
  107. When Agile is not enough
  108. How to scale projections in the event-driven systems?
  109. Snapshots in Event Sourcing
  110. Why are senior devs afraid to code?
  111. How to create a custom GitHub Action?
  112. Memoization, a useful pattern for quick optimization
  113. How using events helps in a teams' autonomy
  114. How to enhance and configure your site search with Algolia?
  115. Events should be as small as possible, right?
  116. How to create projections of events for nested object structures?
  117. How to get started with Open Source?
  118. How to successfully do documentation without a maintenance burden?
  119. How money in Cloud impacts Architectural decisions?
  120. Can command return a value?
  121. CQRS facts and myths explained
  122. Why Partial is an extremely useful TypeScript feature?
  123. How to set up a test matrix in XUnit?
  124. What's the difference between a command and an event?
  125. Saga and Process Manager - distributed processes in practice
  126. What if I told you that Relational Databases are in fact Event Stores?
  127. What texting your Ex has to do with Event-Driven Design?
  128. Sociological aspects of Microservices
  129. How (not) to cut microservices
  130. Bring me problems, not solutions!
  131. Outbox, Inbox patterns and delivery guarantees explained
  132. How to (not) do the events versioning?
  133. Optimistic concurrency for pessimistic times
  134. Why a bank account is not the best example of Event Sourcing?
  135. Revolution now!
  136. Architect Manifesto
  137. Borys had the best dribbling
  138. Talks