go-event-publisher

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

1|Updated Jun 20, 2026
One-click install
npx skills add https://github.com/shafibabar/SDLC-Artifact-Factory --skill go-event-publisher
Or copy as Structured Prompt for Agent
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.