DEV Community: BrewHubPHL

BrewHub PHL: Low Latency, High Caffeine (Notion MCP Operations Ledger)

BrewHubPHL — Thu, 05 Mar 2026 04:08:14 +0000

This is a submission for the Notion MCP Challenge

## What I Built

<BrewHubPHL.com isn't just a software project; it's the digital infrastructure for a physical neighborhood coffee and parcel logistics shop. Managing a physical retail space requires strict security, fast transactions, and immutable audit logs. But reading database tables isn't a great experience for human store managers.

To bridge the gap between our high-speed PostgreSQL database and our human management team, I built the Hub-to-Notion Operations Ledger.

Whenever a barista completes an order on the POS, or a manager performs a high-security action (like an IRS-compliant payroll override), our database automatically and securely syncs that canonical data directly into a Notion Workspace. This turns Notion into a "Live Manager's Logbook" that updates in real-time, without any manual data entry.

## Show us the code

<The magic happens through a highly secure, zero-trust architecture between Supabase, Netlify Functions, and Notion.

Instead of trusting the payload from the database trigger, our Netlify function acts as a secure bridge that re-fetches the canonical data. We also built-in Graceful Degradation: if the Notion API ever goes down, the database catches the exception and returns NEW, ensuring we never stop selling coffee just because a sync failed.

Here is a snippet of our Double-Guarded Postgres Trigger for Auto-Syncing completed orders:
-- 20260304_schema86b_orders_notion_sync.sql
CREATE OR REPLACE FUNCTION public.fn_trg_orders_notion_sync()
RETURNS trigger
LANGUAGE plpgsql
SECURITY DEFINER SET search_path = public, extensions
AS $$
BEGIN
-- Defense-in-depth guard: Only fire on transition to 'completed'
IF (NEW.status = 'completed') AND (OLD.status IS DISTINCT FROM 'completed') THEN
BEGIN
-- Fire webhook to Netlify with signed headers and ONLY the record_id
PERFORM net.http_post(
url := coalesce(current_setting('app.settings.notion_sync_webhook_url', true), 'https://brewhubphl.com/.netlify/functions/notion-sync'),
headers := jsonb_build_object(
'Content-Type', 'application/json',
'X-BrewHub-Action', 'true',
'x-brewhub-secret', current_setting('app.settings.internal_sync_secret', true)
),
body := jsonb_build_object('table', 'orders', 'record_id', NEW.id, 'type', 'UPDATE')
);
EXCEPTION WHEN undefined_function THEN
RAISE WARNING 'pg_net missing, skipping Notion sync';
WHEN OTHERS THEN
RAISE WARNING 'Notion sync trigger failed, but allowing order to complete: %', SQLERRM;
END;
END IF;
RETURN NEW;
END;
$$;

CREATE TRIGGER trg_orders_notion_sync
AFTER UPDATE ON public.orders
FOR EACH ROW
-- Double guard: Postgres level check before invoking function
WHEN (NEW.status = 'completed' AND OLD.status IS DISTINCT FROM 'completed')
EXECUTE FUNCTION public.fn_trg_orders_notion_sync();

## How I Used Notion MCP

<While the Postgres triggers and Netlify functions populate the data, Notion MCP (Model Context Protocol) acts as our "AI Shift Manager."

By adding the Notion MCP server to our .vscode/mcp.json configuration, our AI concierge ("Elise", powered by Claude) has direct read/write access to the Shop Command Center in Notion.

This unlocks an incredible Human-in-the-Loop workflow:

The Daily Pulse: I can ask the AI to "Check the Ledger." The AI uses MCP to read the Sales Ledger database in Notion, summarizes the total revenue and completed orders for the day, and cross-references it with our physical parcel logistics.

Security Audits: The AI scans the Audit Trail page in Notion for any new Manager Overrides (synced via our zero-trust webhooks). If it sees an unusual comp or payroll adjustment, it flags it for my review.

Drafting Briefings: Instead of just outputting text, the AI uses MCP to draft a neat "Morning Briefing" page directly inside my Notion workspace for the opening manager to read the next day.

I built an Infinite AI Debate Arena using the GitHub Copilot CLI 🥊

BrewHubPHL — Wed, 11 Feb 2026 19:29:41 +0000

This is a submission for the GitHub Copilot CLI Challenge

💡 The Idea
What happens if you lock two AI personalities in a room and force them to argue about "Is a hotdog a sandwich?" forever?

For the GitHub Copilot CLI Challenge, I didn't want to just build a utility tool. I wanted to build something chaotic. Enter the AI Debate Arena.

It’s a terminal-based "fighting game" where:

Captain Capslock (An angry Boomer) fights Lil' Zoomer (A Gen-Z teen).

They argue in an infinite loop.

Sentiment Analysis determines who is "winning" (getting angrier).

🎥 The Demo
[https://youtu.be/-RBdUKZY9zA]

🛠️ How it Works
The project uses Python to orchestrate the chaos, but the "brains" are entirely powered by the GitHub Copilot CLI.

The "Persona Injection" I used the gh copilot explain command to generate the dialogue. By injecting a specific persona into the prompt, we can force Copilot to break character.

Python

The Secret Sauce

prompt = f"{persona} Your opponent said: '{last_response}'. Reply in one short, funny sentence."
cmd = ["gh", "copilot", "explain", "-p", prompt]

The Loop The script creates a feedback loop:

Fighter A generates a response using Copilot.

TextBlob analyzes the sentiment (Politeness = Weakness, Anger = Power).

Fighter B takes that response and generates a counter-argument.

Rich renders the ASCII faces and health bars in real-time.

🎨 The Tech Stack
GitHub CLI (gh): The AI engine.

Rich: For the beautiful terminal UI and layouts.

TextBlob: For the "Rage Meter" logic.

Python: To glue it all together.

🏆 The Outcome
Sometimes they argue about politics, sometimes about cereal. The CLI handles the roleplay surprisingly well. My favorite line so far?

"Milk-first people stay taking Ls fr fr, that's giving unhinged villain energy." — Lil' Zoomer

🔗 The Code
Check out the repository here to run it yourself! [https://github.com/BrewHubPHL/ai-debate.git]

How I Built an AI Barista using Square, Supabase, and ElevenLabs

BrewHubPHL — Fri, 06 Feb 2026 12:28:28 +0000

How I Built an AI Barista using Square, Supabase, and ElevenLabs

I run a tech-forward coffee hub in Philadelphia called BrewHubPHL. When we opened, I didn't just want a screen flashing "Order Ready"—I wanted the shop to speak.

Here is how I used Supabase Edge Functions to glue Square POS and ElevenLabs together, creating an automated announcer for our orders.

The Stack

Database & Auth: Supabase
Payments: Square (POS and Webhooks)
Voice AI: ElevenLabs (Turbo v2 model)
Compute: Netlify Functions

The Workflow

Square detects a payment (payment.updated).
Supabase receives the webhook and routes it.
ElevenLabs generates the audio file ("Order for John is ready!").
The frontend plays the audio automatically.

Step 1: Catching the Square Webhook

First, we need to know when an order is actually paid. We set up a serverless function to listen for Square's payment.updated event.


javascript
// square-webhook.js
exports.handler = async (event) => {
  const body = JSON.parse(event.body);

  if (body.type === 'payment.updated' && body.data.object.payment.status === 'COMPLETED') {
    const orderId = body.data.object.payment.reference_id;

    // Update Supabase
    await supabase.from('orders').update({ status: 'paid' }).eq('id', orderId);

    // Trigger the Announcer
    await triggerVoiceAnnouncement(orderId);
  }
};

## Step 2: Generating the Voice
This is where the magic happens. We don't want a robotic "text-to-speech" voice; we want personality. I used the ElevenLabs Turbo v2 model because it has low latency (essential for real-time retail).

We send the text to their API and get back an audio buffer.

// text-to-speech.js
const response = await fetch(`https://api.elevenlabs.io/v1/text-to-speech/${VOICE_ID}`, {
    method: 'POST',
    headers: {
        'xi-api-key': process.env.ELEVENLABS_API_KEY
    },
    body: JSON.stringify({
        text: "Order ready for specific_customer!",
        model_id: 'eleven_turbo_v2',
        voice_settings: { stability: 0.5, similarity_boost: 0.75 }
    })
});

Why build this?
It’s not just a gimmick. In a busy shop, customers tune out shouting baristas. A distinct, consistent AI voice cuts through the noise. Plus, by integrating it directly with Square and Supabase, we have zero manual work—the barista just taps "Charge," and the code does the rest.

For the developers, I've open-sourced the sync logic on GitHub: https://gist.github.com/BrewHubPHL/53937283c5eaa7cafedb9555e851c509