# event-sourcing

Event sourcing is a software architecture pattern that records application state changes as an ordered, append-only sequence of events, which can be replayed to reconstruct state.

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## What to get right before you ship webhooks

DevFeed: [What to get right before you ship webhooks](<https://devfeed.tech/articles/what-to-get-right-before-you-ship-webhooks-145864.md>)

Original publisher: [Read original article](<https://www.sitepoint.com/webhooks-best-practices-before-you-ship/>)

Author: SitePoint Sponsors

Published: 2026-11-20T07:35:47Z

Content type: tutorial

Language: en

Sources: [SitePoint](<https://devfeed.tech/sources/sitepoint.md>)

Topics: [Publish-subscribe pattern](<https://devfeed.tech/topics/pubsub.md>), [event-sourcing](<https://devfeed.tech/topics/event-sourcing.md>), [Cryptography](<https://devfeed.tech/topics/cryptography.md>), [API Logging](<https://devfeed.tech/topics/api-logging.md>), [Documentation](<https://devfeed.tech/topics/documentation.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-apis](<https://devfeed.tech/tags/ai-apis.md>), [anthropic](<https://devfeed.tech/tags/anthropic.md>), [api](<https://devfeed.tech/tags/api.md>), [apis](<https://devfeed.tech/tags/apis.md>), [code](<https://devfeed.tech/tags/code.md>), [deduplication](<https://devfeed.tech/tags/deduplication.md>), [delivery](<https://devfeed.tech/tags/delivery.md>), [developer-tools](<https://devfeed.tech/tags/developer-tools.md>), [event](<https://devfeed.tech/tags/event.md>), [js](<https://devfeed.tech/tags/js.md>), [log](<https://devfeed.tech/tags/log.md>), [node-js](<https://devfeed.tech/tags/node-js.md>), [retries](<https://devfeed.tech/tags/retries.md>), [standard](<https://devfeed.tech/tags/standard.md>), [webhooks](<https://devfeed.tech/tags/webhooks.md>)

### AI overview

Webhooks remove the delay and request load of polling for long-running jobs, but reliable delivery needs durable event storage and clear receiver-facing behavior. The excerpt recommends writing each event to an append-only, per-customer log in the same transaction as the state change, then exposing it through a cursor-based pull endpoint with documented retention. Use a stable event format and IDs, signed raw payloads with per-endpoint secrets, backoff retries stored across restarts, and receiver deduplication; webhook delivery can still be duplicated or arrive out of order. It also calls for per-endpoint limits, blocking private-network destinations and redirects, and customer-visible delivery attempts and replay tools. Teams can build delivery themselves or keep the event log and relay rows to Svix, which handles signing, retries, endpoint disabling, and a customer portal. The excerpt includes adaptable Node.js examples and cites Standard Webhooks verification libraries.

### Source excerpt

Before you ship webhooks: an event log, signed payloads, retries with backoff, deduplication and delivery logs, with working Node.js code and Standard Webhooks. Continue reading What to get right before you ship webhooks on SitePoint.

## The Compute ICE-AGE: OPAL ONE, Continuity That Persists While Reasoning Is Idle

DevFeed: [The Compute ICE-AGE: OPAL ONE, Continuity That Persists While Reasoning Is Idle](<https://devfeed.tech/articles/the-compute-ice-age-opal-one-continuity-that-persists-while-reasoning-is-idle-139758.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2602.16736>)

Author: R. Jay Martin II

Published: 2026-11-18T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>)

Topics: [event-sourcing](<https://devfeed.tech/topics/event-sourcing.md>), [long-running](<https://devfeed.tech/topics/long-running.md>), [database-consistency](<https://devfeed.tech/topics/database-consistency.md>), [AI Chat](<https://devfeed.tech/topics/ai-chat.md>)

Tags: [17](<https://devfeed.tech/tags/17.md>), [22](<https://devfeed.tech/tags/22.md>), [apple-silicon](<https://devfeed.tech/tags/apple-silicon.md>), [atomic](<https://devfeed.tech/tags/atomic.md>), [authorization](<https://devfeed.tech/tags/authorization.md>), [bounded](<https://devfeed.tech/tags/bounded.md>), [canonical](<https://devfeed.tech/tags/canonical.md>), [concurrent](<https://devfeed.tech/tags/concurrent.md>), [continuation](<https://devfeed.tech/tags/continuation.md>), [costs](<https://devfeed.tech/tags/costs.md>), [cpu](<https://devfeed.tech/tags/cpu.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-os](<https://devfeed.tech/tags/cs-os.md>), [failure](<https://devfeed.tech/tags/failure.md>), [graph](<https://devfeed.tech/tags/graph.md>), [growth](<https://devfeed.tech/tags/growth.md>), [hardware](<https://devfeed.tech/tags/hardware.md>), [interfaces](<https://devfeed.tech/tags/interfaces.md>), [local](<https://devfeed.tech/tags/local.md>), [lookup](<https://devfeed.tech/tags/lookup.md>), [model-context-protocol](<https://devfeed.tech/tags/model-context-protocol.md>), [reasoning](<https://devfeed.tech/tags/reasoning.md>)

### AI overview

OPAL is a CPU-resident C++17 graph engine designed to preserve application memory independently of probabilistic reasoning. It retains record identities, relationships, and accepted numerical state across sessions, with defined updates, canonical checkpoints, and recovery after restart; Bounded Local Generator Classes provide the mathematical basis for bounded local evolution. On Apple Silicon M2 Pro, resident-update P50 was 0.083 microseconds at 100,000, 1 million, and 5 million retained Atomic Memory Vertices. The measured calls include validation, indexed lookup, and numerical mutation; initialization and storage growth were measured separately. Reported checks covered replay, conflict rejection, concurrency, allocation failures, fresh-process recovery, and byte-identical checkpoints across engine versions. The installed PYAMV package passed 17 SDK contract and 20 workload checks, while KINDRED's Model Context Protocol interface passed 22 checks of memory operations, authorization, and transport. These abstract-level results report low recurring local-update costs and persistent continuity through five million vertices; they do not establish performance beyond the specified M2 M

### Source excerpt

arXiv:2602.16736v4 Announce Type: replace-cross Abstract: The Compute ICE-AGE separates persistent application memory from probabilistic reasoning. We present OPAL, a CPU-resident C++17 graph engine that preserves record identities, relationships, and accepted numerical state between reasoning sessions. Applications evolve that state through defined updates, save canonical checkpoints, and recover continuity after restart. Bounded Local Generator Classes (BLGC) provide the mathematical foundation for this bounded local evolution. On Apple Silicon M2 Pro hardware, the current-engine resident-update P50 measured 0.083 microseconds at 100,000, 1,000,000, and 5,000,000 retained Atomic Memory Vertices (AMVs). A same-session 1M-5M-1M sequence reproduced that median using one frozen binary and 1,024 prepared targets, with every process passing its correctness checks. These measurements cover complete resident-update calls, including validation, indexed lookup, and numerical state mutation. Initialization and storage-growth costs are reported separately. Reliability tests verified event replay, conflict rejection, concurrent calls, allocation-failure handling, and fresh-process recovery with continued operation. Engine-version comparisons produced byte-identical checkpoints and continuation files. The installed PYAMV Python package passed 17 SDK contract checks and 20 workload checks. KINDRED's Model Context Protocol interface passed 22 distinct focused checks covering memory operations, authorization, and transport. Together, these results demonstrate persistent continuity with low recurring local-update costs through five million retained AMVs, providing working interfaces for applications and developers. The architecture keeps accepted memory available while reasoning is idle, allowing applications to invoke models only when tasks require interpretation, planning, or generation.

## Your AI Agent Is Only as Reliable as the Blockchain State It Observes

DevFeed: [Your AI Agent Is Only as Reliable as the Blockchain State It Observes](<https://devfeed.tech/articles/your-ai-agent-is-only-as-reliable-as-the-blockchain-state-it-observes-129457.md>)

Original publisher: [Read original article](<https://hackernoon.com/your-ai-agent-is-only-as-reliable-as-the-blockchain-state-it-observes?source=rss>)

Author: Atul Kumar

Published: 2026-11-11T15:22:52Z

Content type: article

Language: en

Sources: [HackerNoon](<https://devfeed.tech/sources/hackernoon.md>)

Topics: [Blockchain](<https://devfeed.tech/topics/blockchain.md>), [state-management](<https://devfeed.tech/topics/state-management.md>), [event-sourcing](<https://devfeed.tech/topics/event-sourcing.md>), [consistency](<https://devfeed.tech/topics/consistency.md>), [observability](<https://devfeed.tech/topics/observability.md>), [smart contract](<https://devfeed.tech/topics/smart-contract.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [ai-agent](<https://devfeed.tech/tags/ai-agent.md>), [ai-agent-reliability](<https://devfeed.tech/tags/ai-agent-reliability.md>), [autonomous-blockchain-agents](<https://devfeed.tech/tags/autonomous-blockchain-agents.md>), [blockchain](<https://devfeed.tech/tags/blockchain.md>), [blockchain-indexers](<https://devfeed.tech/tags/blockchain-indexers.md>), [blockchain-state](<https://devfeed.tech/tags/blockchain-state.md>), [blockchain-state-management](<https://devfeed.tech/tags/blockchain-state-management.md>), [data](<https://devfeed.tech/tags/data.md>), [distributed-systems](<https://devfeed.tech/tags/distributed-systems.md>), [event-driven-architecture](<https://devfeed.tech/tags/event-driven-architecture.md>), [event-idempotency](<https://devfeed.tech/tags/event-idempotency.md>), [events](<https://devfeed.tech/tags/events.md>), [indexing](<https://devfeed.tech/tags/indexing.md>), [pipelines](<https://devfeed.tech/tags/pipelines.md>), [state](<https://devfeed.tech/tags/state.md>), [state-reconciliation](<https://devfeed.tech/tags/state-reconciliation.md>)

### AI overview

AI agents acting on blockchain data can make sound decisions from an incorrect or outdated application state. The article identifies duplicate or out-of-order events, delayed indexers, chain reorganisations and concurrent database updates as causes of divergence between observed events and the state an application presents. It recommends durable event storage, idempotent processing with atomic concurrency controls, versioned state metadata, reconciliation against equivalent chain references, and revalidation of critical assumptions before execution. Transaction timeouts should remain explicitly uncertain until the original transaction is checked; agent memory should not be the authoritative status record. The article also recommends testing failure recovery and monitoring indexing lag, reconciliation and transaction lifecycles. Validation strength should match action risk: efficient projections can support routine analysis, while consequential transactions need fresh checks. Idempotency suppresses duplicate effects but does not handle reorganisations by itself.

### Source excerpt

Learn how stale blockchain data, duplicate events, and indexing delays can compromise AI agents, and how to design reliable state pipelines.

## ESAA: Event Sourcing for Autonomous Agents in LLM-Based Software Engineering

DevFeed: [ESAA: Event Sourcing for Autonomous Agents in LLM-Based Software Engineering](<https://devfeed.tech/articles/esaa-event-sourcing-for-autonomous-agents-in-llm-based-software-engineering-127182.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2602.23193>)

Author: Elzo Brito dos Santos Filho

Published: 2026-11-10T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [event-sourcing](<https://devfeed.tech/topics/event-sourcing.md>), [Multi Agent Systems](<https://devfeed.tech/topics/multi-agent-systems.md>)

Tags: [agents](<https://devfeed.tech/tags/agents.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [autonomous](<https://devfeed.tech/tags/autonomous.md>), [autonomous-agents](<https://devfeed.tech/tags/autonomous-agents.md>), [case-studies](<https://devfeed.tech/tags/case-studies.md>), [concurrent](<https://devfeed.tech/tags/concurrent.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [event-sourcing](<https://devfeed.tech/tags/event-sourcing.md>), [llm](<https://devfeed.tech/tags/llm.md>), [multi-agent](<https://devfeed.tech/tags/multi-agent.md>), [orchestration](<https://devfeed.tech/tags/orchestration.md>), [software-engineering](<https://devfeed.tech/tags/software-engineering.md>)

### AI overview

ESAA separates an LLM agent's intent from project changes: agents submit validated JSON intentions, and a deterministic orchestrator validates and records events in an append-only log, applies file-writing effects, and builds a verifiable project view. Boundary contracts, PARCER metaprompting profiles, and hash-based replay verification are intended to support task immutability and traceability. The abstract reports successful verification in two case studies: a single-agent landing page (9 tasks, 49 events) and a clinical dashboard built by four concurrent agents over eight phases (50 tasks, 86 events). These results provide evidence of operation in the reported settings; the supplied text does not establish broader scalability.

### Source excerpt

arXiv:2602.23193v1 Announce Type: cross Abstract: Autonomous agents based on Large Language Models (LLMs) have evolved from reactive assistants to systems capable of planning, executing actions via tools, and iterating over environment observations. However, they remain vulnerable to structural limitations: lack of native state, context degradation over long horizons, and the gap between probabilistic generation and deterministic execution requirements. This paper presents the ESAA (Event Sourcing for Autonomous Agents) architecture, which separates the agent's cognitive intention from the project's state mutation, inspired by the Event Sourcing pattern. In ESAA, agents emit only structured intentions in validated JSON (agent.result or issue.report); a deterministic orchestrator validates, persists events in an append-only log (activity.jsonl), applies file-writing effects, and projects a verifiable materialized view (roadmap.json). The proposal incorporates boundary contracts (AGENT_CONTRACT.yaml), metaprompting profiles (PARCER), and replay verification with hashing (esaa verify), ensuring the immutability of completed tasks and forensic traceability. Two case studies validate the architecture: (i) a landing page project (9 tasks, 49 events, single-agent composition) and (ii) a clinical dashboard system (50 tasks, 86 events, 4 concurrent agents across 8 phases), both concluding with run.status=success and verify_status=ok. The multi-agent case study demonstrates real concurrent orchestration with heterogeneous LLMs (Claude Sonnet 4.6, Codex GPT-5, Antigravity/Gemini 3 Pro, and Claude Opus 4.6), providing empirical evidence of the architecture's scalability beyond single-agent scenarios.

## Revenue Hub Connects Quote to Cash. Your Integration Still Needs a Ledger.

DevFeed: [Revenue Hub Connects Quote to Cash. Your Integration Still Needs a Ledger.](<https://devfeed.tech/articles/revenue-hub-connects-quote-to-cash-your-integration-still-needs-a-ledger-125757.md>)

Original publisher: [Read original article](<https://hackernoon.com/revenue-hub-connects-quote-to-cash-your-integration-still-needs-a-ledger?source=rss>)

Author: Pratik Thakker

Published: 2026-11-10T04:15:08Z

Content type: article

Language: en

Sources: [HackerNoon](<https://devfeed.tech/sources/hackernoon.md>)

Topics: [event-driven data processing](<https://devfeed.tech/topics/event-driven-data-processing.md>), [event-sourcing](<https://devfeed.tech/topics/event-sourcing.md>), [Integration testing](<https://devfeed.tech/topics/integration-testing.md>)

Tags: [accounting](<https://devfeed.tech/tags/accounting.md>), [api](<https://devfeed.tech/tags/api.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [automation](<https://devfeed.tech/tags/automation.md>), [billing](<https://devfeed.tech/tags/billing.md>), [configuration](<https://devfeed.tech/tags/configuration.md>), [contract-management](<https://devfeed.tech/tags/contract-management.md>), [contracts](<https://devfeed.tech/tags/contracts.md>), [data-governance](<https://devfeed.tech/tags/data-governance.md>), [data-integration](<https://devfeed.tech/tags/data-integration.md>), [design](<https://devfeed.tech/tags/design.md>), [enterprise-software](<https://devfeed.tech/tags/enterprise-software.md>), [event](<https://devfeed.tech/tags/event.md>), [hub](<https://devfeed.tech/tags/hub.md>), [hubspot](<https://devfeed.tech/tags/hubspot.md>), [idempotency](<https://devfeed.tech/tags/idempotency.md>), [identity](<https://devfeed.tech/tags/identity.md>), [integration](<https://devfeed.tech/tags/integration.md>), [integrations](<https://devfeed.tech/tags/integrations.md>), [ledger](<https://devfeed.tech/tags/ledger.md>), [ownership](<https://devfeed.tech/tags/ownership.md>), [processing](<https://devfeed.tech/tags/processing.md>), [quote](<https://devfeed.tech/tags/quote.md>), [reconciliation](<https://devfeed.tech/tags/reconciliation.md>), [revenue](<https://devfeed.tech/tags/revenue.md>), [revenue-operations](<https://devfeed.tech/tags/revenue-operations.md>), [system-design](<https://devfeed.tech/tags/system-design.md>)

### AI overview

HubSpot Revenue Hub connects quoting, contracts, billing, and payments, but integrations still need explicit ownership, identity, event handling, and reconciliation to explain how an agreement produced a bill and collection. The article proposes an append-oriented, integration-owned event ledger that distinguishes commitments, scheduled billing, invoices, collections, and accounting measures; records stable business keys, effective time, processing outcomes, and downstream references; and handles retries without repeating financial side effects. It recommends resolving buyer and payer roles explicitly, treating configuration changes as revenue-process policy, testing failure and recovery cases, and classifying reconciliation differences with an owner and evidence requirement. Start with one narrow commercial motion and verify the account's enabled paths and billing behavior: HubSpot documentation describes configuration-dependent requirements, and direct contract creation is documented as beta. Example fields and event states are proposed designs, not native HubSpot properties or workflows.

### Source excerpt

Design Revenue Hub integrations with explicit identity, event processing, billing ownership, and reconciliation instead of assuming connected means correct.

## Debezium 3.7.1.Final Released

DevFeed: [Debezium 3.7.1.Final Released](<https://devfeed.tech/articles/debezium-3-7-1-final-released-126366.md>)

Original publisher: [Read original article](<https://debezium.io/blog/2026/11/09/debezium-3-7-1-final-released/>)

Author: Chris Cranford

Published: 2026-11-09T00:00:00Z

Content type: release

Language: en

Sources: [Debezium](<https://devfeed.tech/sources/debezium-io.md>)

Topics: [Debezium Connector](<https://devfeed.tech/topics/debezium-connector.md>), [Release notes](<https://devfeed.tech/topics/release-notes.md>), [Oracle Database](<https://devfeed.tech/topics/oracle-database.md>), [event-sourcing](<https://devfeed.tech/topics/event-sourcing.md>)

Tags: [2026](<https://devfeed.tech/tags/2026.md>), [change-data-capture](<https://devfeed.tech/tags/change-data-capture.md>), [cves](<https://devfeed.tech/tags/cves.md>), [debezium](<https://devfeed.tech/tags/debezium.md>), [distribution](<https://devfeed.tech/tags/distribution.md>), [drivers](<https://devfeed.tech/tags/drivers.md>), [events](<https://devfeed.tech/tags/events.md>), [maintenance](<https://devfeed.tech/tags/maintenance.md>), [oracle](<https://devfeed.tech/tags/oracle.md>), [published](<https://devfeed.tech/tags/published.md>), [reliability](<https://devfeed.tech/tags/reliability.md>), [series](<https://devfeed.tech/tags/series.md>)

### AI overview

Debezium 3.7.1.Final fixes cases where connector restarts could skip or duplicate change events, restores missing Debezium Server components, updates database drivers to address security findings, and resolves 87 issues. Oracle users should note a snapshot locking change: locks now remain until the initial snapshot finishes, reducing failures caused by concurrent schema changes. The default shared mode still permits reads and writes, though some schema changes wait; extended mode blocks all schema changes and writes, with a configurable lock timeout. Remove the retired snapshot.database.errors.max.retries setting if configured. Other changes include running Oracle column reselection queries on a physical standby, an updated MongoDB driver requiring no configuration changes, and a MySQL driver upgrade whose documented support range starts at MySQL 8.4 and whose SSL keystores must be local files when passed through custom driver properties. The release also includes numerous replication, snapshot, and server fixes.

### Source excerpt

We're pleased to announce Debezium 3.7.1.Final, the first maintenance release of the 3.7 series, focused on stability and reliability. This release resolves a number of cases where change events could be skipped or duplicated after a connector restart, and it restores pieces of the Debezium Server distribution that went missing in 3.7.0.Final. It also brings updated database drivers that address several recently published CVEs. If you use the Oracle connector, be sure to review the breaking changes before upgrading. Read on for the full details! Read more...

## Composable Parts Architecture

DevFeed: [Composable Parts Architecture](<https://devfeed.tech/articles/composable-parts-architecture-121430.md>)

Original publisher: [Read original article](<https://blog.devops.dev/composable-parts-architecture-b660caf40e8f?source=rss----33f8b2d9a328---4>)

Author: Scaibu

Published: 2026-11-06T09:47:16Z

Content type: article

Language: en

Sources: [DevOps.dev](<https://devfeed.tech/sources/devops-dev.md>)

Topics: [software-architecture](<https://devfeed.tech/topics/software-architecture.md>), [architecture-components](<https://devfeed.tech/topics/architecture-components.md>), [Dependency Inversion](<https://devfeed.tech/topics/dependency-inversion.md>), [Publish-subscribe pattern](<https://devfeed.tech/topics/pubsub.md>), [adapter pattern](<https://devfeed.tech/topics/adapter-pattern.md>), [Transactions](<https://devfeed.tech/topics/transactions.md>), [Functional programming](<https://devfeed.tech/topics/functional-programming.md>), [CI/CD](<https://devfeed.tech/topics/cicd.md>), [Integration testing](<https://devfeed.tech/topics/integration-testing.md>), [event-sourcing](<https://devfeed.tech/topics/event-sourcing.md>), [Deployment Strategies](<https://devfeed.tech/topics/deployment-strategies.md>), [rate-limiting](<https://devfeed.tech/topics/rate-limiting.md>)

Tags: [architecture](<https://devfeed.tech/tags/architecture.md>), [clean-architecture](<https://devfeed.tech/tags/clean-architecture.md>), [code](<https://devfeed.tech/tags/code.md>), [components](<https://devfeed.tech/tags/components.md>), [connect](<https://devfeed.tech/tags/connect.md>), [contracts](<https://devfeed.tech/tags/contracts.md>), [crash](<https://devfeed.tech/tags/crash.md>), [data](<https://devfeed.tech/tags/data.md>), [data-ownership](<https://devfeed.tech/tags/data-ownership.md>), [deployment](<https://devfeed.tech/tags/deployment.md>), [design](<https://devfeed.tech/tags/design.md>), [durability](<https://devfeed.tech/tags/durability.md>), [enterprise-architecture](<https://devfeed.tech/tags/enterprise-architecture.md>), [event](<https://devfeed.tech/tags/event.md>), [event-driven-architecture](<https://devfeed.tech/tags/event-driven-architecture.md>), [execution](<https://devfeed.tech/tags/execution.md>), [features](<https://devfeed.tech/tags/features.md>), [independent](<https://devfeed.tech/tags/independent.md>), [integrate](<https://devfeed.tech/tags/integrate.md>), [internals](<https://devfeed.tech/tags/internals.md>), [logic](<https://devfeed.tech/tags/logic.md>), [messages](<https://devfeed.tech/tags/messages.md>), [parts](<https://devfeed.tech/tags/parts.md>), [software-architecture](<https://devfeed.tech/tags/software-architecture.md>)

### AI overview

The architecture aims to let parts change independently by having them depend on published, versioned contracts rather than one another's internals. Each part owns its data and exposes pure logic through ports and replaceable adapters; manifests let the platform validate and wire parts without hand-edited central registries. Events through a durable log are the default connection, while synchronous requests are reserved for cases needing an immediate answer and constrained to short call chains. An atomic outbox, idempotency keys, deduplication, checkpoints, deadlines, and retries make interruptions and duplicate delivery recoverable; consumers keep read-only data copies and reconcile them against their owner. The same contracts and host protocol support different runtimes, with adapters and test kits handling host-specific integration. The excerpt also describes contract versioning, graph validation, and domain-based deployment packing as ways to manage growth. These are architectural prescriptions; the supplied text does not establish implementation results.

### Source excerpt

How small, independent parts connect, share data, survive disconnects, integrate with any host, and grow to 1000+ features -- where adding or changing something touches one place, not a hundred.Contents The six rules Vocabulary The system at a glance Anatomy of a part Contracts Connecting parts Execution model inside a part Data ownership and sharing Integrating with any system Durability: connections that break safely Changing the system Scaling to 1000+ parts Platform components Enforcement Testing Adding a new part: checklist Anti-patterns Open decisions Introduction Most large systems do not fail because a single component is badly written. They fail because components know too much about each other. One service reads another service's tables "just this once"; a handler calls three other services in sequence because it was quicker than designing an event; a central routing file collects one line from every team until nobody can change it without a merge conflict. Each shortcut is harmless on its own. Together they produce a system in which adding a field means editing a hundred files, an outage in one corner takes down everything, and a dropped network connection corrupts data. This document describes a structure that prevents those outcomes by design rather than by discipline. It rests on two ideas: No part knows another part. Parts know contracts. A part is aware of its own logic and of the published, versioned contracts it uses. It never sees another part's code, storage, or deployment details. Because nothing depends on internals, internals can change freely. Every connection is assumed to break, and breaking must cost nothing. Networks drop, processes crash, and messages arrive twice or out of order. Instead of trying to prevent these failures, the structure makes each one harmless: nothing is lost, nothing happens twice, and nothing waits forever. Everything that follows is an elaboration of those two ideas, together with the tooling that keeps them true as

## Replay Is a Family of Assertions: Fork-Safety in Event-Sourced Agent Runtimes

DevFeed: [Replay Is a Family of Assertions: Fork-Safety in Event-Sourced Agent Runtimes](<https://devfeed.tech/articles/replay-is-a-family-of-assertions-fork-safety-in-event-sourced-agent-runtimes-120794.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.06924>)

Author: Yohei Nakajima

Published: 2026-11-06T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [event-sourcing](<https://devfeed.tech/topics/event-sourcing.md>), [Agent Harness](<https://devfeed.tech/topics/agent-harness.md>), [recording](<https://devfeed.tech/topics/recording.md>)

Tags: [agent-runtimes](<https://devfeed.tech/tags/agent-runtimes.md>), [assertions](<https://devfeed.tech/tags/assertions.md>), [conditional](<https://devfeed.tech/tags/conditional.md>), [cost](<https://devfeed.tech/tags/cost.md>), [cs-pl](<https://devfeed.tech/tags/cs-pl.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [effect](<https://devfeed.tech/tags/effect.md>), [execution](<https://devfeed.tech/tags/execution.md>), [f-sharp](<https://devfeed.tech/tags/f-sharp.md>), [fork](<https://devfeed.tech/tags/fork.md>), [hmac](<https://devfeed.tech/tags/hmac.md>), [logs](<https://devfeed.tech/tags/logs.md>), [oracle](<https://devfeed.tech/tags/oracle.md>), [projection](<https://devfeed.tech/tags/projection.md>), [reactive](<https://devfeed.tech/tags/reactive.md>), [schedule](<https://devfeed.tech/tags/schedule.md>), [settlement](<https://devfeed.tech/tags/settlement.md>)

### AI overview

Replay and fork safety in event-sourced agent runtimes depend on which observation is promised. The paper presents an executable F# contract that separates recorded facts from effect requests and evaluates cuts for projection, strict execution replay, external continuation, or counterfactual-world observation. It shows that reactive settlement may be schedule-sensitive, general settlement may not terminate or converge, and disjoint declared writes do not rule out read or trigger interference. Across 5,540 public runtime logs, all 317,296 projection cuts met the stated observation, but 36,251 split a model request and did not license continuation; 120,969 more were conditional on serving a committed oracle result from the record without re-execution. In 121 observed forks, retained-prefix events had zero structural mismatches, but no fork crossed an external-effect boundary. A separate offline conformance fork crossed a recorded oracle boundary, with a generator checking no second fixture-oracle call and a verifier checking receipt/log consistency and a fork-bound HMAC assertion. The authors frame cheap forking as a property-indexed contract requiring explicit evidence and stated 환경

### Source excerpt

arXiv:2611.06924v1 Announce Type: cross Abstract: Event-sourced agent runtimes commonly claim deterministic replay, cheap forking, and lineage. These are families of assertions, not one guarantee. A fixed-log fold may be deterministic while reactive settlement remains schedule-sensitive; a recorded oracle result can enable zero-call replay while the original interaction still changed cost or world state; and a prefix copy cannot undo an action in a discarded suffix. We present an executable F# contract that separates facts from effect requests, makes scheduling explicit, and assesses a cut relative to projection, strict execution replay, external continuation, or a declared counterfactual-world observation. Preserved counterexamples show that general settlement is neither terminating nor confluent and that disjoint declared writes do not prevent read/trigger interference. Against 5,540 public runtime logs, all 317,296 projection cuts satisfy the stated observation, while 36,251 cuts split a model request and do not license continuation; another 120,969 are Conditional because a committed oracle result must be served from the record without re-execution. In 121 observed forks, 16,625 retained-prefix events have zero structural mismatches, but none crosses an external-effect boundary. A separate public offline conformance fork crosses a committed, recorded oracle boundary. Its generator observes that the inherited result is served without a second fixture-oracle call; its verifier checks receipt/log consistency and a fork-bound HMAC assertion under a public conformance key. The result reframes cheap forking as a property-indexed semantic contract with explicit evidence and environment preconditions.

## Google LSA Billing Is a Temporal Data Problem: Why Historical Configuration Matters

DevFeed: [Google LSA Billing Is a Temporal Data Problem: Why Historical Configuration Matters](<https://devfeed.tech/articles/google-lsa-billing-is-a-temporal-data-problem-why-historical-configuration-matters-114854.md>)

Original publisher: [Read original article](<https://hackernoon.com/google-lsa-billing-is-a-temporal-data-problem-why-historical-configuration-matters?source=rss>)

Author: Mayur S

Published: 2026-11-03T11:38:44Z

Content type: article

Language: en

Sources: [HackerNoon](<https://devfeed.tech/sources/hackernoon.md>)

Topics: [event-sourcing](<https://devfeed.tech/topics/event-sourcing.md>), [Temporal data](<https://devfeed.tech/topics/temporal-data.md>), [configuration](<https://devfeed.tech/topics/configuration.md>), [data](<https://devfeed.tech/topics/data.md>)

Tags: [audit](<https://devfeed.tech/tags/audit.md>), [audit-trail](<https://devfeed.tech/tags/audit-trail.md>), [audits](<https://devfeed.tech/tags/audits.md>), [billing](<https://devfeed.tech/tags/billing.md>), [bitemporal-modeling](<https://devfeed.tech/tags/bitemporal-modeling.md>), [configuration](<https://devfeed.tech/tags/configuration.md>), [data](<https://devfeed.tech/tags/data.md>), [data-engineering](<https://devfeed.tech/tags/data-engineering.md>), [data-modeling](<https://devfeed.tech/tags/data-modeling.md>), [data-pipelines](<https://devfeed.tech/tags/data-pipelines.md>), [data-warehouse](<https://devfeed.tech/tags/data-warehouse.md>), [database](<https://devfeed.tech/tags/database.md>), [deduplication](<https://devfeed.tech/tags/deduplication.md>), [distributed-systems](<https://devfeed.tech/tags/distributed-systems.md>), [event](<https://devfeed.tech/tags/event.md>), [event-sourcing](<https://devfeed.tech/tags/event-sourcing.md>), [google](<https://devfeed.tech/tags/google.md>), [google-ads](<https://devfeed.tech/tags/google-ads.md>), [google-local-service-ads](<https://devfeed.tech/tags/google-local-service-ads.md>), [google-lsa](<https://devfeed.tech/tags/google-lsa.md>), [lead](<https://devfeed.tech/tags/lead.md>), [local-service-ads](<https://devfeed.tech/tags/local-service-ads.md>), [models](<https://devfeed.tech/tags/models.md>), [october-2026-lsa-update](<https://devfeed.tech/tags/october-2026-lsa-update.md>), [temporal](<https://devfeed.tech/tags/temporal.md>), [temporal-data](<https://devfeed.tech/tags/temporal-data.md>)

### AI overview

LSA billing audits depend on reconstructing the configuration and evidence around a lead when it occurred, not just inspecting current settings. The article recommends preserving call, configuration, lead-status, and billing records as immutable events; keeping event, ingestion, processing, and evaluation times distinct; versioning configuration with valid and transaction time; and linking records while marking inferred matches and confidence. Reconciliation should retain status changes, handle late arrivals and duplicates, and avoid inventing history when a source exposes only current status. Before migration, preserve available campaign reports and distinguish them from customer lead records. These methods make agency evidence reproducible, but do not establish what Google's internal systems used or reveal its undisclosed decision logic; audits should state gaps and limits.

### Source excerpt

Google LSA billing depends on historical events and configuration. Learn how event sourcing and temporal data models improve lead audits.

## Milvus Source Connector for Debezium: Enabling Event-Driven Vector Architectures

DevFeed: [Milvus Source Connector for Debezium: Enabling Event-Driven Vector Architectures](<https://devfeed.tech/articles/milvus-source-connector-for-debezium-enabling-event-driven-vector-architectures-111256.md>)

Original publisher: [Read original article](<https://debezium.io/blog/2026/11/02/milvus-source-connector-for-debezium/>)

Author: Kartik Angiras

Published: 2026-11-02T00:00:00Z

Content type: article

Language: en

Sources: [Debezium](<https://devfeed.tech/sources/debezium-io.md>)

Topics: [Debezium Connector](<https://devfeed.tech/topics/debezium-connector.md>), [Apache Kafka](<https://devfeed.tech/topics/apache-kafka.md>), [Publish-subscribe pattern](<https://devfeed.tech/topics/pubsub.md>), [event-sourcing](<https://devfeed.tech/topics/event-sourcing.md>), [Embeddings](<https://devfeed.tech/topics/embeddings.md>), [hybrid-search](<https://devfeed.tech/topics/hybrid-search.md>)

Tags: [2026](<https://devfeed.tech/tags/2026.md>), [architectures](<https://devfeed.tech/tags/architectures.md>), [debezium](<https://devfeed.tech/tags/debezium.md>), [elasticsearch](<https://devfeed.tech/tags/elasticsearch.md>), [event](<https://devfeed.tech/tags/event.md>), [event-driven](<https://devfeed.tech/tags/event-driven.md>), [kafka](<https://devfeed.tech/tags/kafka.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [postgres](<https://devfeed.tech/tags/postgres.md>), [redis](<https://devfeed.tech/tags/redis.md>), [source](<https://devfeed.tech/tags/source.md>), [stream](<https://devfeed.tech/tags/stream.md>), [vector](<https://devfeed.tech/tags/vector.md>), [vector-database](<https://devfeed.tech/tags/vector-database.md>)

### AI overview

The Debezium 3.7 Milvus source connector reads Milvus 2.5's Kafka write stream, uses etcd checkpoints and Milvus gRPC for snapshots and schemas, and emits inserts and deletes as Debezium events with typed vector fields. Timetick watermarks restore commit order across virtual channels, and Kafka Connect sinks can deliver changes to systems such as Postgres, Elasticsearch, or S3. The connector requires a self-hosted deployment using Kafka as its broker; Milvus Lite, Pulsar, RocksMQ, and Milvus 2.6 are unsupported. It is incubating: its default checkpoint key can miss changes at snapshot handoff, and a crash while events await ordering can lose them. It uses at-least-once snapshot delivery, so idempotent sinks are important; deletes have only primary-key before images, and upserts appear as delete/insert pairs.

### Source excerpt

Google Summer of Code 2026 with the Debezium community was the best learning experience I have had as an engineer. Over one summer I built a Kafka Connect source connector from scratch for a database with no documented way to read its changes. Most of the work was taking the database apart to find out where those changes live, writing the design down before building any of it, and carrying each piece through review with the Debezium maintainers. The connector shipped in Debezium 3.7. What came out of that summer is a Debezium source connector that turns Milvus, the open source vector database, into a first-class source of change events. I built it because Milvus has no change stream of its own. If you need its inserts and deletes somewhere else (Elasticsearch for keyword search, Redis as a cache, Postgres for reporting), you either write to both systems from the application and drift apart on the first partial failure, or you run a batch export that cannot see a delete. The connector reads the write stream Milvus already publishes to its message queue, puts the events back in commit order, and emits each insert and delete as a normal Debezium change event with the vector as a typed field. From there any Kafka Connect sink is a Milvus integration, and the service that writes to Milvus never has to know. This post covers how it works and what you can build once Milvus is one. Read more...

## Trigger Timing, Deadline Readiness, and Event-Aligned Accounting for Dynamic Ad Insertion

DevFeed: [Trigger Timing, Deadline Readiness, and Event-Aligned Accounting for Dynamic Ad Insertion](<https://devfeed.tech/articles/trigger-timing-deadline-readiness-and-event-aligned-accounting-for-dynamic-ad-insertion-107607.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2609.19899>)

Author: Prashant Chaudhary, Kapil Khandelwal

Published: 2026-10-30T04:00:00Z

Content type: article

Language: en

Sources: [arXiv: Networking](<https://devfeed.tech/sources/arxiv-networking.md>)

Topics: [Temporal data](<https://devfeed.tech/topics/temporal-data.md>), [data-engineering](<https://devfeed.tech/topics/data-engineering.md>), [event-sourcing](<https://devfeed.tech/topics/event-sourcing.md>)

Tags: [accounting](<https://devfeed.tech/tags/accounting.md>), [cs-mm](<https://devfeed.tech/tags/cs-mm.md>), [cs-ni](<https://devfeed.tech/tags/cs-ni.md>), [cs-pf](<https://devfeed.tech/tags/cs-pf.md>), [event](<https://devfeed.tech/tags/event.md>), [latency](<https://devfeed.tech/tags/latency.md>), [ledger](<https://devfeed.tech/tags/ledger.md>), [playback](<https://devfeed.tech/tags/playback.md>), [policies](<https://devfeed.tech/tags/policies.md>), [sessions](<https://devfeed.tech/tags/sessions.md>), [state](<https://devfeed.tech/tags/state.md>), [synthetic](<https://devfeed.tech/tags/synthetic.md>), [timing](<https://devfeed.tech/tags/timing.md>), [trigger](<https://devfeed.tech/tags/trigger.md>)

### AI overview

The study argues that dynamic ad insertion trigger policies should be evaluated against a fixed break deadline using an event ledger that separates triggering, reach, readiness, playback, billability and measurement, and includes every planned break-session pair. Readiness means the prepared state is valid at the deadline; scoring completion instead can reverse policy rankings under specified assumptions when an earlier trigger's extra cost falls between its gains in validity and completion. In 45,000 synthetic sessions, completion scoring reversed comparisons in three of nine short-lifetime conditions, all at the latency setting matching the proved condition. Playhead summaries misclassified up to 41% of reach indicators but did not reverse comparisons in the study. Results are synthetic; code, seeds and event histories are public.

### Source excerpt

arXiv:2609.19899v2 Announce Type: replace-cross Abstract: An ad break in a live stream is a hard deadline. Once a cue arrives, the ad path has seconds to produce a state the player can use, and starting that work earlier buys time while giving the prepared state longer to expire before the break. Comparing trigger policies means scoring which of these happened; the records easiest to collect do not. We separate trigger, reach, readiness, playback, billability and measurement in an observed-event ledger, fix the reference-deadline rule before candidates are assigned, and account for contribution over every planned break-session pair, reached or not. Readiness means the declared state is valid at that deadline. We prove when scoring completion by the deadline instead reverses a policy comparison: for monotone playback with a shared latency law, a fixed state lifetime and common coefficients, the reversal occurs when the earlier policy's extra trigger cost falls between its validity gain and its completion gain. A synthetic study of 45,000 scripted sessions matches this condition on monotone paths, a check of its generator, and, outside its assumptions, finds the same reversal in mixtures with restarts, seeks, late joins and pauses. Playhead summaries misclassify up to 41% of reach indicators yet reverse no comparison in the study: maximum-position errors cancel exactly, and terminal-position errors change only magnitudes. Completion scoring reverses the comparison in three of nine short-lifetime conditions, all at the one latency setting where the proved condition holds. The evidence is synthetic by design; code, seeds and event histories are public.

## Reference Architecture for a Secure, Scalable, and Audit-Ready FinTech Mobile Platform

DevFeed: [Reference Architecture for a Secure, Scalable, and Audit-Ready FinTech Mobile Platform](<https://devfeed.tech/articles/reference-architecture-for-a-secure-scalable-and-audit-ready-fintech-mobile-platform-100958.md>)

Original publisher: [Read original article](<https://proandroiddev.com/reference-architecture-for-a-secure-scalable-and-audit-ready-fintech-mobile-platform-4f0ed1622a01?source=rss----c72404660798---4>)

Author: Vaibhav Shakya | Mr Neo

Published: 2026-10-26T23:22:04Z

Content type: article

Language: en

Sources: [ProAndroidDev](<https://devfeed.tech/sources/proandroiddev-medium.md>)

Topics: [scalable-architecture](<https://devfeed.tech/topics/scalable-architecture.md>), [audit](<https://devfeed.tech/topics/audit.md>), [Access Control](<https://devfeed.tech/topics/access-control.md>), [Threat monitoring](<https://devfeed.tech/topics/threat-monitoring.md>), [trust](<https://devfeed.tech/topics/trust.md>), [Zero Trust](<https://devfeed.tech/topics/zero-trust.md>), [Secure token management](<https://devfeed.tech/topics/secure-token-management.md>), [rate-limiting](<https://devfeed.tech/topics/rate-limiting.md>), [Transactions](<https://devfeed.tech/topics/transactions.md>), [Production Engineering](<https://devfeed.tech/topics/production-engineering.md>), [event-sourcing](<https://devfeed.tech/topics/event-sourcing.md>)

Tags: [added](<https://devfeed.tech/tags/added.md>), [android](<https://devfeed.tech/tags/android.md>), [android-app-development](<https://devfeed.tech/tags/android-app-development.md>), [androiddev](<https://devfeed.tech/tags/androiddev.md>), [api](<https://devfeed.tech/tags/api.md>), [apis](<https://devfeed.tech/tags/apis.md>), [app](<https://devfeed.tech/tags/app.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [audit](<https://devfeed.tech/tags/audit.md>), [authentication](<https://devfeed.tech/tags/authentication.md>), [authorization](<https://devfeed.tech/tags/authorization.md>), [backend](<https://devfeed.tech/tags/backend.md>), [better](<https://devfeed.tech/tags/better.md>), [bot](<https://devfeed.tech/tags/bot.md>), [business](<https://devfeed.tech/tags/business.md>), [but](<https://devfeed.tech/tags/but.md>), [can](<https://devfeed.tech/tags/can.md>), [clients](<https://devfeed.tech/tags/clients.md>), [cybersecurity](<https://devfeed.tech/tags/cybersecurity.md>), [fintech](<https://devfeed.tech/tags/fintech.md>), [mobile](<https://devfeed.tech/tags/mobile.md>), [platform](<https://devfeed.tech/tags/platform.md>), [reference](<https://devfeed.tech/tags/reference.md>), [reference-architecture](<https://devfeed.tech/tags/reference-architecture.md>)

### AI overview

The article's central recommendation is to treat a FinTech mobile platform as a distributed trust system: the app provides signals, while the backend owns authorization and business truth. It outlines separate mobile, edge, identity, risk, domain, data, and audit boundaries, with requests evaluated according to user permissions, device and app integrity signals, and transaction risk; sensitive actions may require step-up verification. For correctness under load, it recommends server-side validation, idempotency for payments and retries, explicit transaction states, and callback deduplication. Audit readiness requires structured, searchable, access-controlled events for allowed, denied, failed, and stepped-up actions, linked through correlation IDs. The text emphasizes tradeoffs: pinning and device binding can add operational or support burdens; short-lived tokens depend on refresh availability; synchronous audit can add latency, while asynchronous pipelines risk loss or ordering issues. Mobile checks and infrastructure scaling alone cannot ensure security or transactional correctness.

### Source excerpt

A FinTech mobile platform is not just a mobile app connected to a backend. It is a distributed trust system. The mobile app sits in the least trusted environment. The backend owns business truth. The platform layer decides how traffic is admitted, observed, throttled, audited, and recovered. Security cannot live only in the mobile app, scalability cannot live only in container orchestration, and audit readiness cannot be added by exporting logs after an incident. A production-grade FinTech architecture needs to answer a few difficult questions clearly. Can the platform evaluate an app session without fully trusting the device? Can it detect abuse while limiting false positives for legitimate users? Can it scale during payment spikes without losing transactional correctness? Can it explain later who did what, when, from which device, through which API path, and under which authorization state? That is the real architecture problem. The Core Principle: Separate Trust, Scale, and Audit Boundaries A common mistake in FinTech systems is treating the mobile app, API, and database as one linear flow. The user logs in. The app calls APIs. The backend writes data. Logs are stored somewhere. Monitoring checks if services are up. That may work for a normal consumer app, but it is weak for a financial platform because the most important failures are not always crashes. They are unauthorized access, replayed requests, manipulated clients, duplicated transactions, silent data drift, delayed settlement, inconsistent ledger states, and missing audit trails. A better architecture separates the platform into explicit boundaries: The mobile boundary handles user interaction, local session protection, device posture signals, app integrity signals, secure storage, and request signing inputs. The edge boundary handles TLS termination, request filtering, rate limiting, bot filtering, request normalization, and correlation ID propagation. The identity boundary handles authentication, sessi

## Audit Replay: The Forgotten Half of Reproducibility

DevFeed: [Audit Replay: The Forgotten Half of Reproducibility](<https://devfeed.tech/articles/audit-replay-the-forgotten-half-of-reproducibility-93922.md>)

Original publisher: [Read original article](<https://hackernoon.com/audit-replay-the-forgotten-half-of-reproducibility?source=rss>)

Author: Karan Sehgal, MSc

Published: 2026-10-21T19:46:20Z

Content type: article

Language: en

Sources: [HackerNoon](<https://devfeed.tech/sources/hackernoon.md>)

Topics: [audit](<https://devfeed.tech/topics/audit.md>), [AI Architecture](<https://devfeed.tech/topics/ai-architecture.md>), [reproducibility](<https://devfeed.tech/topics/reproducibility.md>), [recording](<https://devfeed.tech/topics/recording.md>), [event-sourcing](<https://devfeed.tech/topics/event-sourcing.md>), [software-architecture](<https://devfeed.tech/topics/software-architecture.md>), [versioning](<https://devfeed.tech/topics/versioning.md>), [ML model versioning](<https://devfeed.tech/topics/ml-model-versioning.md>)

Tags: [22](<https://devfeed.tech/tags/22.md>), [about](<https://devfeed.tech/tags/about.md>), [access-controls](<https://devfeed.tech/tags/access-controls.md>), [account](<https://devfeed.tech/tags/account.md>), [afterthought](<https://devfeed.tech/tags/afterthought.md>), [aggregate](<https://devfeed.tech/tags/aggregate.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-assisted](<https://devfeed.tech/tags/ai-assisted.md>), [ai-audits](<https://devfeed.tech/tags/ai-audits.md>), [ai-deployment](<https://devfeed.tech/tags/ai-deployment.md>), [ai-governance](<https://devfeed.tech/tags/ai-governance.md>), [ai-regulation](<https://devfeed.tech/tags/ai-regulation.md>), [ai-systems](<https://devfeed.tech/tags/ai-systems.md>), [all](<https://devfeed.tech/tags/all.md>), [audit](<https://devfeed.tech/tags/audit.md>), [audit-replay](<https://devfeed.tech/tags/audit-replay.md>), [but](<https://devfeed.tech/tags/but.md>), [climate-modeling](<https://devfeed.tech/tags/climate-modeling.md>), [enterprise-ai](<https://devfeed.tech/tags/enterprise-ai.md>), [gdpr-implementation](<https://devfeed.tech/tags/gdpr-implementation.md>), [half](<https://devfeed.tech/tags/half.md>), [mlops](<https://devfeed.tech/tags/mlops.md>), [model](<https://devfeed.tech/tags/model.md>), [regulators](<https://devfeed.tech/tags/regulators.md>), [reproducibility](<https://devfeed.tech/tags/reproducibility.md>), [with](<https://devfeed.tech/tags/with.md>)

### AI overview

Audit replay answers what state supported a specific past decision; model replay only regenerates an output from a current or rerun system. The article argues that defensible audit replay requires three commitments: persist the complete decision-time state as an immutable event, preserve historical versions through event sourcing or bi-temporal indexing, and verify reconstructions with signed cryptographic hashes. It describes a mid-market option using PostgreSQL JSON records in an append-only table and a cloud KMS with separated key access. These records cost more to store than scores alone, but the article characterizes the added infrastructure cost as a few percent in its cited pipeline. Audit replay can establish the state seen and evidence recorded, but does not reproduce opaque or stochastic model reasoning; decision-trace persistence can partly address that where traces are available.

### Source excerpt

Model replay only regenerates outputs, but audit replay reconstructs specific past decisions with proof of fidelity--and only the latter answers regulators.

## SymfonyCon Warsaw 2026: Your Parents Holidayed in Yugoslavia

DevFeed: [SymfonyCon Warsaw 2026: Your Parents Holidayed in Yugoslavia](<https://devfeed.tech/articles/symfonycon-warsaw-2026-your-parents-holidayed-in-yugoslavia-92780.md>)

Original publisher: [Read original article](<https://symfony.com/blog/symfonycon-warsaw-2026-your-parents-holidayed-in-yugoslavia>)

Author: Mélyne FREUZE

Published: 2026-10-21T12:30:00Z

Content type: news

Language: en

Sources: [Symfony](<https://devfeed.tech/sources/symfony-blog.md>)

Topics: [Developer Events](<https://devfeed.tech/topics/developer-events.md>), [event-sourcing](<https://devfeed.tech/topics/event-sourcing.md>), [Symfony](<https://devfeed.tech/topics/symfony.md>)

Tags: [2026](<https://devfeed.tech/tags/2026.md>), [3](<https://devfeed.tech/tags/3.md>), [about](<https://devfeed.tech/tags/about.md>), [airlines](<https://devfeed.tech/tags/airlines.md>), [all](<https://devfeed.tech/tags/all.md>), [announcement](<https://devfeed.tech/tags/announcement.md>), [aviation](<https://devfeed.tech/tags/aviation.md>), [community](<https://devfeed.tech/tags/community.md>), [connect](<https://devfeed.tech/tags/connect.md>), [events](<https://devfeed.tech/tags/events.md>), [great](<https://devfeed.tech/tags/great.md>), [join](<https://devfeed.tech/tags/join.md>), [just](<https://devfeed.tech/tags/just.md>), [poland](<https://devfeed.tech/tags/poland.md>), [speaker](<https://devfeed.tech/tags/speaker.md>), [symfony](<https://devfeed.tech/tags/symfony.md>), [talks](<https://devfeed.tech/tags/talks.md>), [using](<https://devfeed.tech/tags/using.md>), [warsaw](<https://devfeed.tech/tags/warsaw.md>), [you-ve](<https://devfeed.tech/tags/you-ve.md>)

### AI overview

Marek Matulka's SymfonyCon Warsaw talk describes how a hobby flight logger outgrew a simple CRUD schema as airlines, airport names, and borders changed. He will show an event-sourced approach using Symfony, Doctrine, Messenger, and a few hundred lines of PHP, covering append-only events, projections, and temporal queries to determine which country an airport belonged to on a flight date. The excerpt also announces the conference for Nov. 26-27, a community party on Nov. 26, and a free Hackday on Nov. 28 in Warsaw; the full schedule is still to come.

### Source excerpt

Whether you've been using Symfony for years or just started, SymfonyCon Warsaw 2026 is a great place to connect. Join us in Poland on Nov 26-27 for 3 tracks of community talks and side events. 🎤 Speaker announcement We're happy to confirm Marek...

## Budgeted Admission from Timestamped Capacity Records in Shared Clusters

DevFeed: [Budgeted Admission from Timestamped Capacity Records in Shared Clusters](<https://devfeed.tech/articles/budgeted-admission-from-timestamped-capacity-records-in-shared-clusters-93753.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2610.28392>)

Author: Andrew Bond, Syed Izhan Khilji

Published: 2026-10-21T04:00:00Z

Content type: article

Language: en

Sources: [arXiv: Distributed Computing](<https://devfeed.tech/sources/arxiv-distributed-computing.md>)

Topics: [Distributed Systems & Parallel Computing](<https://devfeed.tech/topics/distributed-systems-parallel-computing.md>), [event-sourcing](<https://devfeed.tech/topics/event-sourcing.md>), [Temporal data](<https://devfeed.tech/topics/temporal-data.md>), [audit](<https://devfeed.tech/topics/audit.md>)

Tags: [accounting](<https://devfeed.tech/tags/accounting.md>), [admission](<https://devfeed.tech/tags/admission.md>), [api](<https://devfeed.tech/tags/api.md>), [audit](<https://devfeed.tech/tags/audit.md>), [capacity](<https://devfeed.tech/tags/capacity.md>), [clusters](<https://devfeed.tech/tags/clusters.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [delay](<https://devfeed.tech/tags/delay.md>), [delivered](<https://devfeed.tech/tags/delivered.md>), [delivery](<https://devfeed.tech/tags/delivery.md>), [enumeration](<https://devfeed.tech/tags/enumeration.md>), [feedback](<https://devfeed.tech/tags/feedback.md>), [fixed](<https://devfeed.tech/tags/fixed.md>), [functional](<https://devfeed.tech/tags/functional.md>), [gate](<https://devfeed.tech/tags/gate.md>), [identity](<https://devfeed.tech/tags/identity.md>), [job](<https://devfeed.tech/tags/job.md>), [kubernetes](<https://devfeed.tech/tags/kubernetes.md>), [markov](<https://devfeed.tech/tags/markov.md>), [math-pr](<https://devfeed.tech/tags/math-pr.md>), [policy](<https://devfeed.tech/tags/policy.md>), [records](<https://devfeed.tech/tags/records.md>)

### AI overview

The paper develops a cluster admission procedure for delayed capacity records, bounding the joint probability of admission and unavailability for a binary schedulability unit. It derives a stationary frontier for a symmetric Markov state with fixed observation delay, then combines finite likelihood allocation with a one-sided exact binomial endpoint to calibrate policies; exact enumeration confirms the per-policy confidence target in tested parameter cells. A deterministic guard charges unresolved admissions against the realized allowance and bounds unavailable-state admissions at every prefix, assuming truthful outcome feedback. In a controlled system, an append-only record links source sampling, NATS delivery, randomized admission, Kubernetes objects, and API-derived outcomes. The abstract reports no missing events or identity/state mismatches in the audited functional block, and describes a separate CPU request-accounting check that preserves Job and Pod identity through an unschedulable-to-complete transition.

### Source excerpt

arXiv:2610.28392v1 Announce Type: new Abstract: A cluster admission gate can receive a capacity record that no longer matches current schedulability. We study one exogenous binary schedulability unit under a bound on the joint probability of admission and unavailability. For a symmetric Markov state, we derive the stationary admission frontier for a fixed observation delay and apply finite likelihood allocation to a delay-tagged delivered record. A one-sided exact binomial endpoint calibrates each fitted policy, and exact enumeration confirms the per-policy confidence target in every tested parameter cell. A separate deterministic guard charges every unresolved admission against the realized allowance and bounds unavailable-state admissions at every prefix under truthful outcome feedback. An executable admission procedure composes the allocation and guard. The controlled system binds source sampling, NATS delivery, randomized admission, Kubernetes objects, and API-derived outcomes in one append-only record. Independent audit finds no missing event, identity mismatch, or state mismatch in the completed functional block. A separate CPU request-accounting check preserves Job and Pod identity across an unschedulable-to-complete transition.

## Event Streaming and CDC Infrastructure at Runpod

DevFeed: [Event Streaming and CDC Infrastructure at Runpod](<https://devfeed.tech/articles/event-streaming-and-cdc-infrastructure-at-runpod-84638.md>)

Original publisher: [Read original article](<https://www.runpod.io/blog/event-streaming-cdc-infrastructure>)

Author: Zack McKenna

Published: 2026-10-10T23:11:54Z

Content type: article

Language: en

Sources: [Runpod Blog.](<https://devfeed.tech/sources/runpod-blog.md>)

Topics: [Event-Streaming](<https://devfeed.tech/topics/event-streaming.md>), [event-sourcing](<https://devfeed.tech/topics/event-sourcing.md>), [Debezium Connector](<https://devfeed.tech/topics/debezium-connector.md>), [Apache Kafka](<https://devfeed.tech/topics/apache-kafka.md>), [RabbitMQ](<https://devfeed.tech/topics/rabbitmq.md>)

Tags: [approach](<https://devfeed.tech/tags/approach.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [aws](<https://devfeed.tech/tags/aws.md>), [cdc](<https://devfeed.tech/tags/cdc.md>), [change-feed](<https://devfeed.tech/tags/change-feed.md>), [event-streaming](<https://devfeed.tech/tags/event-streaming.md>), [mysql](<https://devfeed.tech/tags/mysql.md>), [outbox](<https://devfeed.tech/tags/outbox.md>)

### AI overview

Runpod describes replacing database polling with a change data capture event pipeline built around a transactional outbox, MySQL binlog, Vitess VStream, and Kinesis. The article explains how domain events feed operational consumers and a Snowflake analytics pipeline, while schema validation and automated migration keep event and warehouse schemas aligned. It also distinguishes deployed components from consumer work still in development.

### Source excerpt

Learn how Runpod built a real-time event streaming platform using Change Data Capture (CDC), the transactional outbox pattern, and the MySQL binlog to replace database polling, simplify consumers, and automate analytics.

## The Most Dangerous Memory in an AI Agent Is the One That Used to Be True.

DevFeed: [The Most Dangerous Memory in an AI Agent Is the One That Used to Be True.](<https://devfeed.tech/articles/the-most-dangerous-memory-in-an-ai-agent-is-the-one-that-used-to-be-true-77244.md>)

Original publisher: [Read original article](<https://hackernoon.com/the-most-dangerous-memory-in-an-ai-agent-is-the-one-that-used-to-be-true?source=rss>)

Author: Atul Kumar

Published: 2026-10-08T06:15:18Z

Content type: article

Language: en

Sources: [HackerNoon](<https://devfeed.tech/sources/hackernoon.md>)

Topics: [AI Context Management](<https://devfeed.tech/topics/ai-context-management.md>), [AI Agent](<https://devfeed.tech/topics/ai-agent.md>), [event-sourcing](<https://devfeed.tech/topics/event-sourcing.md>), [locking](<https://devfeed.tech/topics/locking.md>)

Tags: [agent-memory-architecture](<https://devfeed.tech/tags/agent-memory-architecture.md>), [agentic-ai](<https://devfeed.tech/tags/agentic-ai.md>), [ai-agents](<https://devfeed.tech/tags/ai-agents.md>), [ai-engineering](<https://devfeed.tech/tags/ai-engineering.md>), [ai-memory](<https://devfeed.tech/tags/ai-memory.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [artificial-intelligence](<https://devfeed.tech/tags/artificial-intelligence.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [conflict-resolution](<https://devfeed.tech/tags/conflict-resolution.md>), [consistency](<https://devfeed.tech/tags/consistency.md>), [distributed-systems](<https://devfeed.tech/tags/distributed-systems.md>), [machine-learning](<https://devfeed.tech/tags/machine-learning.md>), [provenance](<https://devfeed.tech/tags/provenance.md>), [software-architecture](<https://devfeed.tech/tags/software-architecture.md>), [state](<https://devfeed.tech/tags/state.md>), [versioning](<https://devfeed.tech/tags/versioning.md>)

### AI overview

AI agent memory can be accurate when recorded and retrieved yet still be unsafe to use after facts change. The article argues for treating memories as managed, versioned state with validity periods, provenance, source authority, and explicit handling of superseded or conflicting information. It recommends checking validity before assembling model context and requiring fresh verification when memories could affect external actions.

### Source excerpt

AI agents can remember facts that are no longer valid. Learn how memory validity, temporal context, provenance, and state versioning make agent memory safer.

## Concurrency Control: Your Aggregate Is Single-Threaded. Your Cluster Isn't.

DevFeed: [Concurrency Control: Your Aggregate Is Single-Threaded. Your Cluster Isn't.](<https://devfeed.tech/articles/concurrency-control-your-aggregate-is-single-threaded-your-cluster-isn-t-55741.md>)

Original publisher: [Read original article](<https://spin.atomicobject.com/concurrency-control-serialization/>)

Author: Vlad Surganov

Published: 2026-09-21T12:00:49Z

Content type: article

Language: en

Sources: [Atomic Object](<https://devfeed.tech/sources/atomic-object.md>)

Topics: [Concurrency](<https://devfeed.tech/topics/concurrency.md>), [distributed-systems](<https://devfeed.tech/topics/distributed-systems.md>), [event-sourcing](<https://devfeed.tech/topics/event-sourcing.md>), [Back end](<https://devfeed.tech/topics/backend.md>), [Nest](<https://devfeed.tech/topics/nestjs.md>), [systems](<https://devfeed.tech/topics/systems.md>)

Tags: [backend](<https://devfeed.tech/tags/backend.md>), [cluster](<https://devfeed.tech/tags/cluster.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [concurrency-control](<https://devfeed.tech/tags/concurrency-control.md>), [development-practices](<https://devfeed.tech/tags/development-practices.md>), [distributed](<https://devfeed.tech/tags/distributed.md>), [distributed-systems](<https://devfeed.tech/tags/distributed-systems.md>), [event-sourcing](<https://devfeed.tech/tags/event-sourcing.md>), [node](<https://devfeed.tech/tags/node.md>), [postgres](<https://devfeed.tech/tags/postgres.md>), [serialization](<https://devfeed.tech/tags/serialization.md>)

### AI overview

This article explains the difference between serialization and arbitration as concurrency-control mechanisms in distributed systems. It argues that correctness should be enforced at the write boundary with mechanisms such as expected-version checks, while serialization should primarily handle performance. The principle is applied to an event-sourced NestJS CQRS backend running on KurrentDB and Postgres across multiple replicas.

### Source excerpt

Concurrency control comes in two kinds, and most distributed-systems failures are a misassignment between them. Let's look at where to put the single-writer guarantee, what each placement costs, and why the cheapest one has no failure mode at all. There are two mechanisms for keeping two things from stepping on each other, and they are [...] The post Concurrency Control: Your Aggregate Is Single-Threaded. Your Cluster Isn't. appeared first on Atomic Spin.

## Payment Ledger Design for Billing Systems

DevFeed: [Payment Ledger Design for Billing Systems](<https://devfeed.tech/articles/payment-ledger-design-for-billing-systems-10246.md>)

Original publisher: [Read original article](<https://dodopayments.com/blogs/payment-ledger-design/>)

Author: Ayush Agarwal

Published: 2026-07-29T00:00:00Z

Content type: article

Language: en

Sources: [Dodo Payments Blog](<https://devfeed.tech/sources/dodo-payments-blog.md>)

Topics: [event-sourcing](<https://devfeed.tech/topics/event-sourcing.md>), [schema design](<https://devfeed.tech/topics/schema-design.md>), [software-architecture](<https://devfeed.tech/topics/software-architecture.md>), [Database](<https://devfeed.tech/topics/database.md>), [Software Engineering](<https://devfeed.tech/topics/software-engineering.md>)

Tags: [account](<https://devfeed.tech/tags/account.md>), [billing](<https://devfeed.tech/tags/billing.md>), [design](<https://devfeed.tech/tags/design.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [idempotency](<https://devfeed.tech/tags/idempotency.md>), [ledger](<https://devfeed.tech/tags/ledger.md>), [model](<https://devfeed.tech/tags/model.md>), [payment](<https://devfeed.tech/tags/payment.md>), [payments](<https://devfeed.tech/tags/payments.md>), [reconciliation](<https://devfeed.tech/tags/reconciliation.md>), [settlement](<https://devfeed.tech/tags/settlement.md>), [systems](<https://devfeed.tech/tags/systems.md>)

### AI overview

A payment ledger should record immutable, balanced entries between accounts, while a separate transactions table tracks processor state. For each event, debits must equal credits within the same currency; errors are corrected with linked reversal and replacement postings. Prevent duplicate writes by deriving a unique idempotency key from the source event and checking balance inside the posting transaction. Keep processor receivables separate from bank cash, then reconcile receivable movements against settlement reports, accounting for timing, fees, rounding, and dispute reversals. For currency conversions, use two balanced postings linked through an FX conversion account, store amounts in minor units with the rate and timestamp, and maintain balances by account and currency. Current balances can be materialized as a projection rebuilt from the append-only entries. The text says Dodo Payments supplies balance ledger entries and payout breakdowns, and retries webhooks up to eight times with exponential backoff.

### Source excerpt

How to design a double-entry, append-only payment ledger: account model, balanced postings, idempotency, reversals, settlement reconciliation, and multi-currency.

## The Log Is the Agent: Event Sourcing Comes to AI Systems

DevFeed: [The Log Is the Agent: Event Sourcing Comes to AI Systems](<https://devfeed.tech/articles/the-log-is-the-agent-event-sourcing-comes-to-ai-systems-56204.md>)

Original publisher: [Read original article](<https://www.developersdigest.tech/blog/log-is-the-agent-event-sourced-ai>)

Author: Developers Digest

Published: 2026-07-05T00:00:00Z

Content type: article

Language: en

Sources: [Developers Digest](<https://devfeed.tech/sources/developers-digest.md>)

Topics: [event-sourcing](<https://devfeed.tech/topics/event-sourcing.md>), [systems](<https://devfeed.tech/topics/systems.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>)

Tags: [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-systems](<https://devfeed.tech/tags/ai-systems.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [event-sourcing](<https://devfeed.tech/tags/event-sourcing.md>), [hacker-news](<https://devfeed.tech/tags/hacker-news.md>), [news](<https://devfeed.tech/tags/news.md>), [paper](<https://devfeed.tech/tags/paper.md>), [source-of-truth](<https://devfeed.tech/tags/source-of-truth.md>), [systems](<https://devfeed.tech/tags/systems.md>)

### AI overview

A paper proposes making an append-only event log the source of truth for AI agent architecture. The article also notes debate over whether the approach is novel or essentially CQRS with additional steps.

### Source excerpt

A new paper proposes inverting traditional agent architecture - making the append-only event log the source of truth, not an afterthought. HN debates whether this is novel or just CQRS with extra steps.

## Refinement without Specification

DevFeed: [Refinement without Specification](<https://devfeed.tech/articles/refinement-without-specification-25504.md>)

Original publisher: [Read original article](<https://buttondown.com/hillelwayne/archive/refinement-without-specification/>)

Author: Hillel Wayne

Published: 2026-01-20T17:49:07Z

Content type: article

Language: en

Sources: [Newsletter feed for Hillel Wayne's Newsletter](<https://devfeed.tech/sources/newsletter-feed-for-hillel-wayne-s-newsletter.md>)

Topics: [event-sourcing](<https://devfeed.tech/topics/event-sourcing.md>), [Database](<https://devfeed.tech/topics/database.md>), [sql-database](<https://devfeed.tech/topics/sql-database.md>), [legacy systems](<https://devfeed.tech/topics/legacy-systems.md>)

Tags: [boolean](<https://devfeed.tech/tags/boolean.md>), [code](<https://devfeed.tech/tags/code.md>), [column](<https://devfeed.tech/tags/column.md>), [constraint](<https://devfeed.tech/tags/constraint.md>), [database](<https://devfeed.tech/tags/database.md>), [event-sourcing](<https://devfeed.tech/tags/event-sourcing.md>), [events](<https://devfeed.tech/tags/events.md>), [legacy-code](<https://devfeed.tech/tags/legacy-code.md>), [mapping](<https://devfeed.tech/tags/mapping.md>), [migrate](<https://devfeed.tech/tags/migrate.md>), [properties](<https://devfeed.tech/tags/properties.md>), [queries](<https://devfeed.tech/tags/queries.md>), [specification](<https://devfeed.tech/tags/specification.md>), [sql](<https://devfeed.tech/tags/sql.md>), [sql-database](<https://devfeed.tech/tags/sql-database.md>), [table](<https://devfeed.tech/tags/table.md>), [triggers](<https://devfeed.tech/tags/triggers.md>)

### AI overview

The excerpt shows how query changes and refinement mappings can let a database evolve while legacy code continues to receive equivalent results: a non-nullable activation boolean can map to a nullable timestamp, then to an event-sourced activation state. It qualifies the claim that these changes preserve external properties: refinement depends on the properties being preserved. A mutability constraint that prevents activated users from becoming deactivated can hold for the timestamp representation, but appending a deactivation event violates it; removing such events is one proposed fix. The excerpt then begins a further refinement case but cuts off before explaining its outcome.

### Source excerpt

Imagine we have a SQL database with a user table, and users have a non-nullable is_activated boolean column. Having read That Boolean Should Probably Be Something else, you decide to migrate it to a nullable activated_at column. You can change any of the SQL queries that read/update the user table but not any of the code that uses the results of these queries. Can we make this change in a way that preserves all external properties? Yes. If an update would set is_activated to true, instead set it to the current date. Now define the refinement mapping that takes a new_user and returns an old_user. All columns will be unchanged except is_activated, which will be f(new_user).is_activated = if new_user.activated_at == NULL then FALSE else TRUE Now new code can use new_user directly while legacy code can use f(new_user) instead, which will behave indistinguishably from the old_user. A little more time passes and you decide to switch to an event sourcing-like model. So instead of an activated_at column, you have a user_events table, where every record is (user_id, timestamp, event). So adding an activate event will activate the user, adding a deactivate event will deactivate the user. Once again, we can update the queries but not any of the code that uses the results of these queries. Can we make a change that preserves all external properties? Yes. If an update would change is_activated, instead have it add an appropriate record to the event table. Now, define the refinement mapping that takes newer_user and returns new_user. The activated_at field will be computed like this: g(newer_user).activated_at = # last_activated_event let lae = newer_user.events .filter(event = "activate" | "deactivate") .last, in if lae.event == "activate" then lae.timestamp else NULL Now new code can use newer_user directly while old code can use g(newer_user) and the really old code can use f(g(newer_user)). Mutability constraints I said "these preserve all external properties" and that was a

## Processing 11 million rows in minutes instead of hours

DevFeed: [Processing 11 million rows in minutes instead of hours](<https://devfeed.tech/articles/processing-11-million-rows-in-minutes-instead-of-hours-44254.md>)

Original publisher: [Read original article](<https://stitcher.io/blog/processing-11-million-rows>)

Author: Brent

Published: 2026-01-19T00:00:00Z

Content type: article

Language: en

Sources: [Stitcher](<https://devfeed.tech/sources/stitcher-io.md>)

Topics: [event-sourcing](<https://devfeed.tech/topics/event-sourcing.md>), [Laravel](<https://devfeed.tech/topics/laravel.md>), [Database](<https://devfeed.tech/topics/database.md>), [debugging](<https://devfeed.tech/topics/debugging.md>)

Tags: [code](<https://devfeed.tech/tags/code.md>), [database](<https://devfeed.tech/tags/database.md>), [debug](<https://devfeed.tech/tags/debug.md>), [event-sourcing](<https://devfeed.tech/tags/event-sourcing.md>), [laravel](<https://devfeed.tech/tags/laravel.md>), [performance](<https://devfeed.tech/tags/performance.md>)

### AI overview

A software engineer describes rebuilding a server-side analytics system that uses event sourcing and projectors to process more than 11 million visits. The post focuses on diagnosing and optimizing the replay command, which initially processed about 30 events per second per projector and would have taken roughly 50 hours to complete.

### Source excerpt

Read the full post on https://stitcher.io/blog/processing-11-million-rows

## Replaying events using AWS S3

DevFeed: [Replaying events using AWS S3](<https://devfeed.tech/articles/replaying-events-using-aws-s3-23901.md>)

Original publisher: [Read original article](<https://medium.com/smg-real-estate/replaying-events-using-aws-s3-3cc84242025e?source=rss----2186e5b9bd8f---4>)

Author: Marko Savic

Published: 2022-04-08T08:40:24Z

Content type: article

Language: en

Sources: [Homegate Engineering Blog - Medium](<https://devfeed.tech/sources/homegate-engineering-blog-medium.md>)

Topics: [event driven](<https://devfeed.tech/topics/event-driven.md>), [AWS Step Functions](<https://devfeed.tech/topics/aws-step-functions.md>), [set up event-driven architecture AWS](<https://devfeed.tech/topics/set-up-event-driven-architecture-aws.md>), [Amazon Web Services](<https://devfeed.tech/topics/aws.md>), [AWS CloudFormation](<https://devfeed.tech/topics/aws-cloudformation.md>), [event-sourcing](<https://devfeed.tech/topics/event-sourcing.md>)

Tags: [amazon-sqs](<https://devfeed.tech/tags/amazon-sqs.md>), [api](<https://devfeed.tech/tags/api.md>), [api-gateway](<https://devfeed.tech/tags/api-gateway.md>), [aws](<https://devfeed.tech/tags/aws.md>), [aws-lambda](<https://devfeed.tech/tags/aws-lambda.md>), [aws-s3](<https://devfeed.tech/tags/aws-s3.md>), [aws-sns](<https://devfeed.tech/tags/aws-sns.md>), [cloudformation](<https://devfeed.tech/tags/cloudformation.md>), [debugging](<https://devfeed.tech/tags/debugging.md>), [event-driven](<https://devfeed.tech/tags/event-driven.md>), [event-sourcing](<https://devfeed.tech/tags/event-sourcing.md>), [events](<https://devfeed.tech/tags/events.md>), [failed](<https://devfeed.tech/tags/failed.md>), [failure](<https://devfeed.tech/tags/failure.md>), [microservices](<https://devfeed.tech/tags/microservices.md>), [resource](<https://devfeed.tech/tags/resource.md>), [s3](<https://devfeed.tech/tags/s3.md>), [serverless](<https://devfeed.tech/tags/serverless.md>), [sns](<https://devfeed.tech/tags/sns.md>), [software-architecture](<https://devfeed.tech/tags/software-architecture.md>), [step-functions](<https://devfeed.tech/tags/step-functions.md>), [storage](<https://devfeed.tech/tags/storage.md>), [versioning](<https://devfeed.tech/tags/versioning.md>)

### AI overview

Homegate describes using versioned AWS S3 objects to retain event history and replay failed or selected resource imports through AWS Step Functions. The importer stores each event in S3, using the resource ID as the key; bucket versioning preserves prior event versions for replay and debugging. For failures, a DLQ-based approach could have a scheduled Lambda fetch messages and restart the flow with the latest event when conditions such as retryability are met. For manual or flexible replays, an API Gateway endpoint accepts parameters such as resource selections or special handling; Replay SQS sits between handler and listener Lambdas, and the listener fetches events from S3 and starts Step Functions. The text presents these as possible mechanisms, not a guarantee that every failure is automatically recoverable.

### Source excerpt

In the world of event-driven microservices one of the important tasks is to have a mechanism to recover from failed events, as well as to have possibility to replay certain events. We at Homegate deal with serverless microservices. If, at any of these services, we encounter a failure during processing of an resource, we might need to recreate the last event or series of events for given resource. Usecase The central part of ingestion process is AWS StepFunctions that lives in a, so called, importer service. It is responsible for various enrichments and conditional actions on resource. The last step of the step function is sending an event to the AWS SNS which is consumed by many downstream services as you can see in the following diagram. Step functions as central part of ingestion process Here, many open questions can be identified: How to deal with failure within AWS StepFunctions? How to recreate SNS event if needed for downstream system? Would it be possible to replay the whole step function? Solution Possible answer to these questions would be to store events that goes through AWS StepFunctions into some kind of event storage, in Homegate case, we chose AWS S3. In order to support the whole history of events for given resource, S3 bucket versioning is used. This is quite handy for replaying series of events or even for debugging purposes. Here is a sample CloudFormation which enables that functionality: EventLogBucket: Type: 'AWS::S3::Bucket' Properties: BucketName: 'sample-unnique-bucket-name' AccessControl: Private PublicAccessBlockConfiguration: BlockPublicAcls: true BlockPublicPolicy: true IgnorePublicAcls: true RestrictPublicBuckets: true Tags: - Key: service Value: sample-service - Key: env Value: !FindInMap [ Stages, !Ref Stage , Env ] VersioningConfiguration: Status: Enabled That way we can replay the whole step functions flow using last logged event for given resource. That functionality could be available from different places, like DLQ or via api end

## A new major version of Laravel Event Sourcing

DevFeed: [A new major version of Laravel Event Sourcing](<https://devfeed.tech/articles/a-new-major-version-of-laravel-event-sourcing-44069.md>)

Original publisher: [Read original article](<https://stitcher.io/blog/a-new-major-version-of-laravel-event-sourcing>)

Author: Brent

Published: 2021-06-15T00:00:00Z

Content type: release

Language: en

Sources: [Stitcher](<https://devfeed.tech/sources/stitcher-io.md>)

Topics: [event-sourcing](<https://devfeed.tech/topics/event-sourcing.md>), [Laravel](<https://devfeed.tech/topics/laravel.md>), [releases](<https://devfeed.tech/topics/releases.md>), [software-development](<https://devfeed.tech/topics/software-development.md>)

Tags: [event-sourcing](<https://devfeed.tech/tags/event-sourcing.md>), [laravel](<https://devfeed.tech/tags/laravel.md>), [major](<https://devfeed.tech/tags/major.md>), [new-features](<https://devfeed.tech/tags/new-features.md>), [releases](<https://devfeed.tech/tags/releases.md>)

### AI overview

This release post introduces version 5 of spatie/laravel-event-sourcing, describing changes developed and tested over several months. It covers consistent event-handler registration, event queries, aggregate partials, and a command bus that maps commands to handlers.

### Source excerpt

Read the full post on https://stitcher.io/blog/a-new-major-version-of-laravel-event-sourcing

[Next page](<https://devfeed.tech/topics/event-sourcing.md?cursor=WyIyMDIxLTA2LTE1VDAwOjAwOjAwKzAwOjAwIiwgIjc5ZTY3NGIxLTAwYjItNDczOC1hYTEzLTY1M2EwMzI4ZThmMCJd>)