go-event-publisher

Implement a transactional outbox pattern for PostgreSQL to Kafka or Redpanda.

1|Updated Jun 20, 2026

Search Tags:#go #kafka #idempotency #outbox #backpressure #event-publishing #redpanda

Ready to run

npx skills add https://github.com/shafibabar/SDLC-Artifact-Factory --skill go-event-publisher

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: go-event-publisher
Source: https://github.com/shafibabar/SDLC-Artifact-Factory/tree/main/skills/go-event-publisher
Command: npx skills add https://github.com/shafibabar/SDLC-Artifact-Factory --skill go-event-publisher

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This skill solves the dual-write problem where a service crashes between a database commit and a broker publish, causing silent event loss. It provides a robust, transactional outbox pattern to ensure events are reliably delivered even during system failures.

Core Features & Use Cases

Transactional Outbox: Ensures state changes and event recording are atomic within a single database transaction.
Reliable Relay: Implements a supervised, polling-based relay that guarantees at-least-once delivery to Redpanda or Kafka.
Use Case: Use this skill when building microservices that require strict consistency between database state and downstream event-driven systems, such as order processing or financial ledger updates.

Quick Start

Use the go-event-publisher skill to configure the outbox relay and transactional database schema for your service.

Frequently Asked Questions about go-event-publisher

High-intent search queries and answers about installing and using this skill.

FAQPage Schema

What is the transactional outbox pattern and how does it solve the dual-write problem in Kafka?▼

The transactional outbox pattern solves the dual-write problem by ensuring state changes and event recording are atomic within a single PostgreSQL transaction, preventing silent event loss if a service crashes before publishing to Kafka.

How do I implement reliable event publishing from PostgreSQL to Redpanda?▼

You can implement reliable event publishing by using a supervised, polling-based relay that reads events from a PostgreSQL outbox and guarantees at-least-once delivery to Redpanda or Kafka.

How does idempotent event processing work with at-least-once delivery guarantees?▼

Idempotent event processing ensures that even if a relay publishes the same event multiple times due to at-least-once delivery guarantees, downstream consumers process the message only once, preventing duplicate side effects.

Can I use the transactional outbox pattern for high-throughput microservices with backpressure?▼

Yes, the transactional outbox pattern supports memory-bounded batching and backpressure management, making it suitable for high-throughput microservices requiring strict consistency between database state and downstream systems.

When should I use a transactional outbox instead of direct database commits and broker publishes?▼

You should use a transactional outbox when building microservices that require strict consistency, such as order processing or financial ledger updates, to avoid silent event loss during system failures.