DEV Community: Eesuola Opeyemi

Building a Scalable Notification System with RabbitMQ and Microservices

Eesuola Opeyemi — Sat, 15 Nov 2025 04:10:30 +0000

Ever wondered how apps like Slack, WhatsApp, or Gmail send millions of notifications without breaking a sweat? The secret lies in asynchronous message queues.

In this article, I'll write about my learning and insight through building a production-ready notification system using RabbitMQ, Node.js, Fastify, Docker and SendGrid as part of my HNG Internship project.

*But, why we need message queue.? *
This below is call without queue message, I mean it is Synchronous in nature.

app.post('/send-notification', async (req, res) => { await sendEmail(req.body); res.send('Email sent'); });
But this can cause problems if service(email) is down, the the request will fail immediately. Also, API response is slow (waits for email to send), No retry logic in place and Can't scale email sending independently.

Below is with queue message i.e Asynchronous = don’t wait, continue working with another task.

`// Publish to queue - returns immediately
app.post('/send-notification', async (req, res) => {
await publishToQueue(req.body);
res.send('Notification queued'); // Instant response
});

// Separate consumer processes the queue
consumeQueue(async (message) => {
await sendEmail(message);
});`

Just like I stated above the problems in Synchronous approach. The asynchronous is just the opposite; Fast API responses, retry logic, persistence of message and etc

Key Learnings

Asynchronous is Better Message queues allow services to work independently without blocking each other.
Always Retry Transient failures are common. Automatic retries with exponential backoff are essential.
Monitor Everything Track queue length, processing time, and error rates to catch issues early.
Design for Failure Services will fail. Build systems that gracefully handle and recover from failures

Learning progress
I had ZERO experience with:

RabbitMQ (message queues)
Fastify (Node.js framework)
Microservices architecture
Asynchronous messaging patterns

So I decided to get hands on:

I completed a 35-minute Fastify crash course from Traversy Media.
I Studied RabbitMQ fundamentals through YouTube tutorials and documentations
I built, broke, and rebuilt the system several times. > I strongly recommend reading documentations with YouTube tutorials.

I also recommend using an email address that belongs to your own domain for smooth delivery on SendGrid. I used my Hostinger domain email, and it worked well. SendGrid won’t accept Gmail or other public email providers because I don’t own those domains. "So, I’d advise using an email address from a domain you own."

WHAT I BUILT:

Email Service consuming from RabbitMQ queues
Retry logic with exponential backoff (2s, 4s, 8s)
Dead letter queue for failed messages
Integration with SendGrid for email delivery
Docker containerization for deployment

The end result ? here you go;

Handles 1,000+ notifications/minute
99.5% delivery success rate
Automatic retries prevent message loss
Services scale independently

The magic of RabbitMQ: If my Email Service crashes and restarts, messages wait patiently in the queue. Nothing is lost. This is how apps like Slack, WhatsApp, and Gmail handle millions of messages daily!

The best part was seeing messages flow through RabbitMQ, get processed, and arrive in my inbox just seconds later. That first successful test felt like pure magic!

Huge thanks to HNG Internship (@HNG Internship) for providing hands-on, real-world projects that push you to learn, adapt, and deliver!

Let's Connect!
If you found this helpful or have questions, drop a comment below! I'd love to hear about your experiences with message queues and microservices
X
linkedin

Supabase Functions vs Firebase Cloud Functions — Why we Switched for our Eventra Project

Eesuola Opeyemi — Sat, 08 Nov 2025 10:32:48 +0000

Supabase Functions vs Firebase Cloud Functions — Why we Switched for our Eventra Project

While building Eventra, an event management and ticketing platform, we used Supabase Functions and honestly, I was impressed.

They handled almost everything I needed without me spinning up a separate backend server:

Creating new event orders
Verifying payments through Paystack webhooks
Generating tickets after successful payment
Sending automated emails and confirmations

All these were simple serverless functions deployed directly from Supabase.

What are Supabase Functions?

Supabase Functions are serverless functions that run on Deno (not Node.js).

They let you write backend logic in TypeScript or JavaScript and deploy them directly to the Supabase Edge network.

That means they’re fast, secure, and automatically scale without any infrastructure setup.

They integrate tightly with Supabase Auth, Database, and Storage, making them feel like a natural part of your backend.

Supabase Functions in My Project

Here’s what I built with them in Eventra

create-order : Handles new event orders. Validates data and stores order info in the database.
payment-webhook : Listens for Paystack payment events, verifies transactions, and updates order statuses.
generate-ticket : Creates unique event tickets after payment confirmation.
send-mail : Sends confirmation and ticket delivery emails automatically.

Together, these four functions automated the entire transaction flow without a dedicated backend server.

Supabase Functions vs Firebase Cloud Functions

Feature	Supabase Functions	Firebase Cloud Functions
Runtime	Deno (TypeScript, modern JS, Web APIs)	Node.js only
Deployment	`supabase functions deploy`	`firebase deploy --only functions`
Database Integration	Native Postgres (SQL)	Firestore or Realtime DB (NoSQL)
Auth Integration	Built-in with Supabase Auth JWTs	Needs Firebase Auth setup
Speed & Performance	Edge-deployed (low latency, almost no cold starts)	Can experience cold starts
Openness	Fully open-source	Proprietary
Local Testing	`supabase functions serve`	Firebase emulator suite

Why I Think Supabase Is Better (for My Use Case)

Runs at the Edge: Functions execute close to users super fast.

SQL-Powered: Works seamlessly with Supabase’s Postgres database.

Simple Workflow: No external setup I can build, test, and deploy from one place.

Open Source: Easier to customize and self-host compared to Firebase.

It’s like having a full backend platform that feels modern, fast, and transparent.

💬 Final Thoughts

While Firebase Cloud Functions remain solid for Node.js and NoSQL projects,

Supabase Functions give developers a cleaner, faster, and more flexible option especially if you love SQL and want everything in one place.

In my case, using them for Eventra made the backend process smoother, cheaper, and a bit friendly to work with it.

supabase #serverless #firebase #deno #webdev #backend #opensource #javascript

What do you think?

Have you tried Supabase Functions yet?

What’s your experience compared to Firebase Cloud Functions?

Building Eventra: My First Hackathon Journey with Hedera The Challenge

Eesuola Opeyemi — Fri, 07 Nov 2025 01:05:45 +0000

The Challenge

When I joined my first hackathon with Hedera, I had no idea what I was getting into. Grouped with talented individuals, we faced the ultimate challenge: solve a real problem, benefit the community, and leverage Hedera’s technology—all while learning entirely new technologies from scratch.

The Problem We Tackled

In Nigeria, 10.3% of the population owns or uses cryptocurrency, but most don’t know how to use it for everyday purchases like event tickets. We asked ourselves: How do we build a platform that serves both Web3 natives and complete beginners?

Enter Eventra - a fraud-proof, fast, and fair event ticketing platform built on Hedera Hashgraph.

What is Eventra?
creates a transparent, low-cost event management platform that:

• Prevents ticket fraud - Every ticket is an NFT, impossible to duplicate

• Enables dual payments - Users can pay with Hedera (HBAR) or traditional methods (Paystack)

• Provides permanent proof of attendance - NFT certificates for participants

• Fair resale marketplace - Organizers earn 5% royalty on resales
• Rewards system - Points for ticket purchases
• Comprehensive analytics - Detailed event reports for organizers

Why Hedera?

Hedera made this possible through:

• Ultra-low fees(~$0.0001 per transaction)
• Lightning-fast finality (3-5 seconds) for instant verification
• Carbon-negative network - environmentally sustainable
• Enterprise governance - trusted by universities, corporations, and governments

My Learning Journey (The Real Story)

Here’s the thing: I had zero experience with TypeScript, Solidity, or Supabase before this hackathon. When Firebase started requiring credit cards, I switched to Supabase—a tool I’d barely touched.

Week 1-2: Crash Course Mode

• Dove into Solidity documentation
• Binge-watched Naz Dumanskyy’s tutorials (absolute lifesaver!)
• Built micro-projects to test my knowledge
• YouTube and AI became my debugging partners

The Reality Check

I was the only backend developer on the team. The pressure was real. I encountered:

• Supbase Functions issues
• Countless TypeScript bugs
• Moments of what did I get myself into?

But here’s what I learned: asking “ridiculous” questions is how you grow. The community, documentation, and fellow developers were incredibly supportive.

Tech Stack

Backend: TypeScript + Supabase (Functions & Database)
Blockchain: Hedera Hashgraph (Smart Contracts in Solidity)
Payments: Hedera Token Service + Paystack Integration
NFTs: Hedera Token Service for ticket minting

Key Features Implemented

Dual Payment System

Integrated both Hedera (crypto) and Paystack (fiat) to ensure accessibility for everyone.

NFT Ticketing

Every ticket is minted as an NFT on Hedera blockchain with:

Permanent proof of ownership
Impossible to counterfeit
Transferable on our marketplace

Fair Resale Marketplace

Transparent pricing
Organizers earn 5% royalty automatically
Prevents scalping while maintaining liquidity

Proof of Attendance NFTs

Attendees receive permanent certificates they can showcase in their Web3 portfolios.

Analytics Dashboard

Organizers get comprehensive insights into ticket sales, attendance patterns, and revenue.

Lessons Learned

Don’t be afraid to start from zero - Two weeks ago, I couldn’t write a line of Solidity
Community matters - Hackathons are collaborative, not competitive
Build micro-projects first - Testing knowledge before diving into production saves time
AI is a tool, not a crutch - Use it to understand, not just copy-paste
Team diversity is strength - Different skill sets create better solutions

What’s Next?

This hackathon taught me that the best way to learn is by building something that matters. Eventra isn’t just a project it’s a solution to real problems in event management and Web3 accessibility.

Resources That Helped Me

Hedera Documentation
Naz Dumanskyy’s YouTube Channel
Supabase Documentation
The amazing Hedera developer community

To anyone considering their first hackathon: Do it. You’ll learn more in a few weeks than months of tutorials. The discomfort means you’re growing.

What was your first hackathon experience like? Drop a comment below!

Hedera #Web3 #Hackathon #Blockchain #TypeScript #FirstTimer

Booksy Agent — Your AI Reading Companion

Eesuola Opeyemi — Tue, 04 Nov 2025 10:03:22 +0000

Introduction

Reading is an incredible way to grow, but keeping track of what you’ve read, where you stopped, and what you learned can quickly get messy especially for avid readers. That’s the problem I wanted to solve with Booksy Agent.

Booksy Agent is an AI-powered reading companion that helps you manage your books, summarize chapters, track reading progress, and generate personalized recommendations, all through a conversational interface.

What problem I solved

Readers often lose track of progress, forget book insights, and have no structured way to manage reading goals. Booksy solves this by combining AI summarization, note-taking, and reading analytics into one smart assistant.

Why I chose this agent

I chose to build a reading focused agent because it’s relatable and practical. Everyone reads whether it’s for learning or leisure and this agent makes reading more intentional and intelligent. It also demonstrates how AI can enhance everyday habits using automation, structured data, and context-aware conversation.

The Tech Stack

Mastra Framework — the backbone for agent creation, orchestration, and routing.
Google Gemini AI — powers smart summaries, insights, and recommendations.
Open Library & Google Books APIs — fetch book metadata, cover images, and author info.
TypeScript — ensures type safety and maintainable, scalable code.
Telex.im Integration — connects the agent to Telex via the A2A (Agent-to-Agent) protocol.

Building the Agent

Setting Up Mastra Mastra provides an elegant way to define agents, tools, and AI models. Here’s the core setup for the Booksy Agent: import { Agent } from "@mastra/core/agent"; import { bookManagementTool, bookSearchTool, bookSummaryTool } from "../tools/book-tools"; import { readingProgressTool, readingStreakTool, readingNotesTool } from "../tools/reading-tools"; import { Memory } from '@mastra/memory'; import { LibSQLStore } from '@mastra/libsql';

export const booksyAgent = new Agent({
name: "Booksy Reading Companion",
instructions: `
You're a helpful AI reading companion that helps users manage their reading journey.

**Your capabilities:**
- Track reading progress across multiple books
- Generate chapter summaries and key takeaways
- Maintain reading streaks and motivation
- Take and organize reading notes
- Provide personalized book recommendations

model: "google/gemini-2.5-flash",
tools: {
bookManagementTool,
bookSearchTool,
bookSummaryTool,
readingProgressTool,
readingStreakTool,
readingNotesTool,
},
memory: new Memory({
storage: new LibSQLStore({
url: 'file:../mastra.db', // path is relative to the .mastra/output directory
}),
}),
});
This setup defines the agent’s identity and binds its tools — giving it the ability to handle book management and reading progress commands.

Creating Tools

Tools are how the agent performs specific actions like adding books, tracking progress, or taking notes.
Example: A simple book management tool.
import { createTool } from "@mastra/core";
import { z } from "zod";
import { bookStorage } from "../utils/storage";
import { Book, BookStatus } from "../utils/definitions";

export const bookManagementTool = createTool({
id: "manage-book",
description: "Add, update, or retrieve books in the user's library",
inputSchema: z.object({
action: z.enum(["add", "update", "get", "list"]).describe("Action to perform"),
bookId: z.string().optional().describe("Book ID for update/get operations"),
title: z.string().optional().describe("Book title"),
author: z.string().optional().describe("Book author"),
totalChapters: z.number().optional().describe("Total number of chapters"),
currentChapter: z.number().optional().describe("Current chapter number"),
genre: z.string().optional().describe("Book genre"),
status: z.enum(["reading", "completed", "want-to-read"]).optional(),
}),
outputSchema: z.object({
success: z.boolean(),
message: z.string(),
book: z.any().optional(),
books: z.array(z.any()).optional(),
}),
Each tool is modular, easy to test, and can be reused or expanded.

AI Integration

Booksy uses Google Gemini AI to automatically generate chapter summaries, key takeaways, and book recommendations.
Here’s a simplified example of AI summarization:
import { Agent } from "@mastra/core/agent";

export interface SummaryOptions {
bookTitle: string;
author: string;
chapter: number;
length: "short" | "medium" | "long";
userNotes?: string[];
context?: string;
}

export interface ChapterSummary {
summary: string;
keyTakeaways: string[];
actionableInsights: string[];
quotes?: string[];
relatedConcepts?: string[];
}

export class AISummaryService {
private summaryAgent: Agent;

constructor() {
// Create a specialized agent for summarization
this.summaryAgent = new Agent({
name: "Summary Generator",
instructions: `
You are an expert book summarization assistant. Your role is to create
insightful, actionable summaries of book chapters.

    **Guidelines:**
    - Focus on key concepts and main ideas
    - Extract actionable insights the reader can apply
    - Identify memorable quotes if provided
    - Connect ideas to broader themes
    - Be concise but comprehensive
    - Use clear, accessible language

    **Summary Lengths:**
    - SHORT: 2-minute read (150-200 words) - Just the essentials
    - MEDIUM: 5-minute read (400-500 words) - Balanced detail
    - LONG: 10-minute read (800-1000 words) - Comprehensive analysis

    Always structure your response as JSON with:
    {
      "summary": "Main summary text",
      "keyTakeaways": ["point 1", "point 2", "point 3"],
      "actionableInsights": ["action 1", "action 2"],
      "quotes": ["quote 1", "quote 2"],
      "relatedConcepts": ["concept 1", "concept 2"]
    }
  `,
  model: "google/gemini-2.5-flash", // Fast and cost-effective
});

This gives users the ability to explore and add real books seamlessly.

Telex.im Integration

To make Booksy usable within Telex, I implemented the A2A (Agent-to-Agent) protocol for communication between Booksy and other agents.
import { registerApiRoute } from "@mastra/core/server";
import { randomUUID } from "crypto";

export const a2aAgentRoute = registerApiRoute("/a2a/agent/:agentId", {
method: "POST",
handler: async (c) => {
try {
const mastra = c.get("mastra");
const agentId = c.req.param("agentId");

  // Parse JSON-RPC 2.0 request
  const body = await c.req.json();
  const { jsonrpc, id: requestId, method, params } = body;

  // Validate JSON-RPC 2.0 format
  if (jsonrpc !== "2.0" || !requestId) {
    return c.json(
      {
        jsonrpc: "2.0",
        id: requestId || null,
        error: {
          code: -32600,
          message:
            'Invalid Request: jsonrpc must be "2.0" and id is required',
        },
      },
      400
    );
  }

This allows Booksy to respond to AI-driven messages inside the Telex.im ecosystem.

Challenges & Solutions
What worked well

Mastra’s structure made it simple to define and organize tools.

Gemini AI handled summarization and recommendations impressively.

The A2A integration connected smoothly with Telex.

What was difficult

Managing API rate limits from Google Books.

Maintaining state between reading sessions.

Fine-tuning AI summaries to stay accurate and concise.

How I solved problems

Implemented a caching layer for API results.

Used in-memory storage for temporary session tracking.

Adjusted prompt templates for better summarization balance.

Conclusion
What I learned

Building Booksy taught me how to combine AI reasoning, API integrations, and conversational interfaces into one coherent system. It also deepened my understanding of Mastra’s modular design and Telex’s agent ecosystem.

Future improvements

Integrate Goodreads or Notion export.

Add a “Reading Goals” tracker.

Support audiobooks and sync reading across devices.

Introduce a leaderboard for reading streaks.

Links

🔗 GitHub Repo: [https://github.com/eesuola/Booksy-Agent]

🌐 Live Demo: https://red-melodic-sunset-40618f2d-c6b7-4294-bd35-4883323b8e26.mastra.cloud/a2a/agent/booksyAgent

🤖 Telex Agent Link:[https://telex.im/telex-ai-intergration/home/colleagues/019a4d37-ff96-797a-a07e-1e5652a7e124/019a4d37-eae8-7979-b4a6-769b60698c78]

DEV Community: Eesuola Opeyemi

Building a Scalable Notification System with RabbitMQ and Microservices

Supabase Functions vs Firebase Cloud Functions — Why we Switched for our Eventra Project

Supabase Functions vs Firebase Cloud Functions — Why we Switched for our Eventra Project

What are Supabase Functions?

Supabase Functions in My Project

Supabase Functions vs Firebase Cloud Functions

Why I Think Supabase Is Better (for My Use Case)

💬 Final Thoughts

Tags

supabase #serverless #firebase #deno #webdev #backend #opensource #javascript

What do you think?

Building Eventra: My First Hackathon Journey with Hedera The Challenge

Hedera #Web3 #Hackathon #Blockchain #TypeScript #FirstTimer

Booksy Agent — Your AI Reading Companion