Independent project · Messaging & task management
Rabbitme
Messaging infrastructure your team can actually work with.
Configure brokers, see where messages are waiting, and run background jobs from one workspace. I built Rabbitme to bring RabbitMQ, NATS, and distributed task processing together, with tenant isolation and access control built into the application.
See waiting messages, active consumers, and resource limits before digging into individual queues.
From “is the job running?” to a clear view of the work.
A background job depends on more than application code. Messages need somewhere to go, workers need the right capabilities, and developers need to understand what happened when delivery or execution goes wrong. Rabbitme brings those operations into a shared web workspace.
I designed and built the platform across the interface, API, broker integrations, and worker protocol. The challenge was making infrastructure approachable while keeping each tenant’s resources and permissions enforced on the server.
Put developers in control
Create queues and streams, inspect messages, and manage application credentials through a consistent interface. RabbitMQ and NATS operations sit alongside the jobs that depend on them.
Make background work visible
Match tasks to capable workers, set concurrency and retry behavior, then inspect execution history and saved results. Job processing comes with the tools to understand its outcome.
Give each team its own workspace
Organization sign-in automatically provisions a workspace. Roles, scoped credentials, and server-side authorization define who can access its resources and what they can do.
A simpler interface starts with stronger boundaries.
The core design decision was to make the application responsible for access and orchestration. A Go API authorizes tenant operations against RabbitMQ and NATS, while TaskHub gives producers and workers a dedicated protocol. The Vue interface makes those capabilities available in one place.
- Vue 3 & TypeScriptWeb interface
- Tailwind CSS and shadcn-vue support a shared interface for messaging, task execution, and administration. Live updates use Server-Sent Events.
- Go & GinApplication API
- The API handles infrastructure operations and server-side tenant authorization, backed by MySQL. OAuth/OIDC sign-in provisions workspaces with administrator and member roles.
- RabbitMQ & NATSMessaging infrastructure
- RabbitMQ queues, exchanges, bindings, policies, and Shovels sit alongside isolated NATS accounts and JetStream streams and consumers.
- TaskHubProducer and worker protocol
- A WebSocket and MessagePack protocol lets external producers and workers submit and process jobs without receiving broker credentials. Capability-based matching, concurrency limits, timeouts, and retries govern execution.
Tenant isolation
Authorization is enforced on the server, with isolated workspaces and scoped messaging credentials.
Operational visibility
Live updates, broker health metrics, historical charts, activity logs, and CSV exports make infrastructure activity inspectable.
Recoverable configuration
Versioned snapshots support administrator-controlled restoration. Docker Compose environments include migrations, persistent storage, and automated NATS identity setup.
What was built
Go, Gin, Vue 3, TypeScript, Tailwind CSS, shadcn-vue, MySQL, RabbitMQ, NATS JetStream, WebSockets, MessagePack, Server-Sent Events, OAuth/OIDC, and Docker.
- RabbitMQ management: Queue, exchange, binding, and policy management, message publishing and retrieval, connection monitoring, and message transfers through dynamic Shovels.
- NATS integration: Isolated accounts, scoped credentials, and management of JetStream streams and consumers.
- TaskHub: A task processing system with capability-based worker matching, configurable concurrency, timeouts, retries, execution history, and saved results.
- Authentication and access control: OAuth/OIDC single sign-on, automatic workspace provisioning, administrator and member roles, and server-side tenant authorization.
- Monitoring and auditing: Live interface updates, broker health metrics, historical charts, activity logs, and CSV exports.
- Configuration recovery: Versioned configuration snapshots and administrator-controlled restoration.
- Deployment: Docker Compose environments with database migrations, persistent storage, and automated NATS identity setup.
Infrastructure operations, delivered as a usable product.
Rabbitme connects the full workflow: sign in, enter an isolated workspace, configure messaging, connect applications, and inspect background work. Monitoring, access management, and recovery are part of that same experience.
One place to operate
RabbitMQ administration, NATS JetStream, and TaskHub share an interface, so developers can move between messaging setup and job execution with the workspace context in view.
A narrower access boundary for workers
External producers and workers use TaskHub’s WebSocket and MessagePack protocol. They can submit and process jobs without receiving credentials for the underlying broker.
Evidence when something needs attention
Execution history and saved results explain what happened to a task. Broker metrics, historical charts, and activity logs help investigate the infrastructure around it.
A path back from configuration changes
Versioned snapshots give administrators a controlled restoration workflow. Deployment includes migrations, persistent storage, and NATS identity setup.
This project brings together the work I care about: designing distributed systems, enforcing security boundaries, and turning operational complexity into software people can use.
Building a platform your team needs to operate?
Rabbitme shows how I approach infrastructure products, from backend boundaries to the daily developer workflow. If your team faces a similar challenge, let’s talk.