Skip to content

Instantly share code, notes, and snippets.

@SumonMSelim
Last active August 30, 2026 13:48
Show Gist options
  • Select an option

  • Save SumonMSelim/7418072feb7aabd5943a4e485f86e157 to your computer and use it in GitHub Desktop.

Select an option

Save SumonMSelim/7418072feb7aabd5943a4e485f86e157 to your computer and use it in GitHub Desktop.

Build "YOUR_IDEA_NAME": PUT YOUR APP IDEA HERE. Output: WRITE DOWN YOUR APP BEHAVIOUR OR FEATURE OR WHAT DO YOU WANT THE APP TO DO.

Requirements:

  • WRITE DOWN YOUR APP REQUIREMENTS/FEATURES.
  • Use the relevant services from Stripe Projects (projects.dev) catalog.
  • Choose Stack based on that.
  • Guide me on how to create and configure the necessary accounts/credentials.
  • Integrate all the necessary services to build the app as per requirements
@awoladhossain

Copy link
Copy Markdown

🎙️ MemoMind — Voice-First Knowledge Capture System

Stripe Projects Hackathon Submission | Full-Stack AI Voice Knowledge Engine

MemoMind is a voice-first knowledge capture system. Record voice memos directly from your browser → AI transcribes and extracts structured metadata → store permanently in Neon Postgres & Cloudflare R2 → search your ideas by meaning.


✨ Features

  • 🎙️ Web Audio Studio: Browser-based audio recording using Web Audio API with a live animated frequency visualizer canvas and recording timer.
  • 🤖 OpenRouter AI Pipeline: Automatic Whisper audio transcription and GPT-4o smart analysis generating:
    • Concise Executive Title
    • 2-3 sentence Summary
    • Relevant #tags
    • Interactive Action Items Task Checklist
    • Sentiment Mood Analysis (positive, neutral, negative)
  • 💳 Stripe Payment System: Integrated Stripe Checkout Sessions (/api/checkout/create-session) and Webhooks (/api/webhooks/stripe) for upgrading users to MemoMind Pro.
  • 🗄️ Neon Postgres Database: Serverless Postgres table with indexed user queries.
  • ☁️ Cloudflare R2 Storage: S3-compatible audio storage with zero egress download fees.
  • 🔒 Auth & Rate Limiting: Anonymous guest tier (3 free memos) + Clerk authentication & Upstash Redis sliding-window rate limiting.
  • 🔍 Hybrid Semantic & Full-Text Search: Filter memos by keyword search, dynamic tag chips, sentiment mood pills, or view action items.

🛠️ Tech Stack & Stripe Projects Provider List

Provider Service Purpose Cost Tier
Stripe Checkout & Webhooks Payment processing & Pro Plan upgrade Pay-as-you-go
Vercel Hobby / Project Next.js 16 App Router hosting & edge functions Free
Clerk Project Magic links, social login & JWT authentication Free
Neon Project Serverless Postgres database for memo metadata Free
OpenRouter API Whisper audio transcription & GPT-4o LLM analysis Free / API
Cloudflare R2 Bucket Audio file storage with zero egress fees Free (10GB/mo)
Upstash Redis API sliding-window rate limiting Free

@0xCaptainFahim

Copy link
Copy Markdown

🛡️ NexusGuard AI

Next-Generation Secure Code Analysis


💡 The Idea: What is NexusGuard AI?

NexusGuard AI is an intelligent code security dashboard designed to bring enterprise-grade vulnerability scanning to individual developers and small teams. It acts as an automated, AI-driven security reviewer.

How it works:

  1. Input: Paste your codebase or specific functions directly into the interactive browser studio.
  2. Analysis: The AI engine instantly analyzes your logic, detects vulnerabilities, and evaluates best practices.
  3. Report: It generates a real-time Security Score, highlights critical/warning-level issues, and provides secure, drop-in replacement code.
  4. Scale: Users can securely upgrade their account via Stripe to unlock unlimited deep repository-wide scans and long-term audit history tracking.

✨ Core Features & Requirements

🖥️ Interactive Code Security Studio

  • Glassmorphism UI: A stunning, premium frontend built with Next.js App Router and Tailwind CSS v4, featuring radial gradients and custom micro-animations.
  • Real-Time Editor: Browser-based code input with built-in syntax formatting and dynamic state management.

🤖 OpenRouter AI Pipeline

  • Deep Analysis: Automatic GPT-4o evaluation generating interactive reports.
  • Dynamic Scoring: A visual Security Score (0-100) with custom CSS spinning indicators.
  • AI Suggested Fixes: Simulated fix block outputting clean, secure replacement code that developers can copy instantly.

💳 Stripe Payment System

  • Pro Tier Upgrade: Integrated Stripe Checkout Sessions (/api/checkout/create-session) for seamless payment processing.
  • Secure Webhooks: Stripe webhooks (/api/webhooks/stripe) automatically update user database records to reflect their active subscription status.

🗄️ MySQL Database

  • Code Audit Storage: A local or hosted MySQL database tracks historical code audits.
  • Score Progression: Allows users to track how their code security improves over time using lightweight relational queries.

🔒 Auth & Rate Limiting

  • NextAuth.js Authentication: Robust user management supporting email/password and social logins without relying on third-party SaaS providers.
  • Abuse Prevention: Basic in-memory IP rate-limiting to prevent API abuse while keeping infrastructure simple.

🛠️ Tech Stack List

We prioritized simple, free, and accessible technologies to keep the project lightweight:

Provider/Tool Service Purpose Cost Tier
Next.js 16 Frontend & API App Router hosting, Edge functions & UI rendering Free / Open Source
Stripe Checkout & Webhooks Payment processing & Pro Plan upgrade Pay-as-you-go
NextAuth.js Authentication Seamless login management & JWT sessions Free / Open Source
MySQL Database Reliable relational database for user data and code review history Free / Open Source
Prisma ORM Type-safe database queries for MySQL Free / Open Source
OpenRouter API GPT-4o LLM analysis for vulnerability detection Free / API

🚀 How to Run Locally (Configuration Guide)

Follow these steps to configure the necessary accounts and credentials:

1. Project Setup

  • Ensure you have Node.js and npm installed.
  • Clone the repository and run npm install.

2. Database (MySQL)

  • Install MySQL locally (via XAMPP, Docker, or native installer).
  • Create a new database named nexusguard_ai.
  • Add your MySQL connection string to .env.local as DATABASE_URL="mysql://USER:PASSWORD@localhost:3306/nexusguard_ai".
  • Run npx prisma db push to generate the required tables.

3. Authentication (NextAuth.js)

  • Generate a secret key by running openssl rand -base64 32 in your terminal.
  • Save it as NEXTAUTH_SECRET in your .env.local file.
  • Add NEXTAUTH_URL="http://localhost:3000" to .env.local.

4. Payments (Stripe)

  • Create an account at Stripe and enable "Test Mode".
  • Obtain your STRIPE_SECRET_KEY and NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY.
  • Set up a Product (NexusGuard Pro) and get the PRICE_ID.
  • Configure a local webhook listener using the Stripe CLI and save the STRIPE_WEBHOOK_SECRET in .env.local.

5. AI API (OpenRouter/OpenAI)

  • Generate an API key on OpenRouter or OpenAI.
  • Save it as OPENAI_API_KEY (or OPENROUTER_API_KEY) in .env.local.

Start the App

Run the following command to start the development server:

npm run dev

Visit http://localhost:3000 to interact with the NexusGuard AI dashboard!

@Emas15

Emas15 commented Aug 29, 2026

Copy link
Copy Markdown

Build "Split the Bill": An app that lets a group split a shared expense
(dinner, trip, event) and collect payment from each person individually
through Stripe, instead of one person fronting the money and chasing
everyone else down afterward. The organizer enters the total bill amount,
the number of people, and their names — the app calculates each person's
exact share and generates a unique payment link for each of them. Each
person opens their own link and pays their share directly via Stripe
Checkout. The app tracks who has paid in real time and shows a live
progress bar ("X of Y paid"). Past splits are saved locally so the
organizer can review previous bills.

Requirements:

  • Input form: total bill amount, number of people, and each person's name
  • Automatic equal-split calculation of the bill across all people
  • A unique, shareable payment link generated per person (encodes their
    name and amount)
  • Stripe Checkout integration for each individual payment (test mode)
  • A dedicated success/confirmation page after payment, which redirects
    back to the main bill view
  • Live tracking of who has paid, with a progress bar and "Paid ✅" badges
  • Split history saved locally (previous bills, with a delete option)
  • Deployed as a live, publicly accessible web app (no login required to
    view or pay)
  • Use the relevant services from Stripe Projects (projects.dev) catalog
    — attempted to provision hosting via stripe projects add vercel/project;
    hit persistent network connectivity issues during the event
    (repeated "connection reset by peer" errors on plugin install), so the
    app is deployed and hosted directly on Vercel instead, with Stripe used
    for the core payment flow via the standard Checkout API.
  • Stack chosen based on the above: Next.js 14 (App Router), React,
    TypeScript, Tailwind CSS for the frontend; Stripe Checkout Sessions
    for payments; Vercel for hosting and deployment.
  • Credentials/accounts configured: Stripe account (test mode, API keys
    stored as environment variables), Vercel account (connected to GitHub
    repo for auto-deploy), GitHub repo for version control.
  • Integrated all necessary services: Stripe Checkout Sessions created
    per-person via a Next.js API route, dynamic base URL handling for
    local/production environments, environment variables synced to Vercel
    for the live deployment.

Live app: https://split-the-bill-steel.vercel.app
Repository: https://github.com/Emas15/split-the-bill

@CodeWithPritom

Copy link
Copy Markdown

Project Idea & Overview

Build "GitQuest": An Interactive Gamified GitHub Learning Platform ("Duolingo for GitHub").

Output / App Behavior

GitQuest turns learning Git and GitHub from intimidating documentation into a playful, hands-on, quest-based game.
Instead of watching tutorials, learners:

  • Progress through 14 interactive stages (from creating accounts to branch DAGs, PRs, and GitHub Actions).
  • Run simulated Git CLI commands in a safe in-browser deterministic terminal with real-time visual DAG branch animations.
  • Complete real-world scenario missions with live task checklists.
  • Open, review, and squash-merge Pull Requests with interactive file diffs.
  • Get instant, step-by-step contextual hints from the 24/7 AI Mentor (powered by Groq Cloud LLM).
  • Earn XP, level up (Levels 1–8), unlock 12 badges, maintain streaks, and generate an official printable Graduation Certificate.

Core Requirements & Features

  1. Interactive Quest Roadmap: 14 beginner-to-intermediate stages with real-world developer scenarios.
  2. Deterministic In-Browser Git CLI: Safe virtual execution of git init, status, add, commit, log, branch, switch, merge, remote, push, pull.
  3. Interactive Visual State Machine: Real-time DAG visualizer synchronizing Working Tree, Staging Box, Commits, and Remote Cloud.
  4. Pull Request Simulator: Side-by-side file diffs, automated bot comments, and squash-merge celebration.
  5. GitQuest AI Mentor (Groq Cloud): Context-aware senior engineer teaching beginners on demand.
  6. Stripe Projects Monetization: Stripe Checkout simulation for GitQuest Premium entitlement.
  7. Strict No-Database Architecture: Zero SQL/NoSQL DB dependency; uses modular static JSON curriculum + client localStorage with JSON Export/Import.
  8. Judge 1-Click Demo Mode: Single-click full unlock toolbar for hackathon evaluators.
  9. Live Public GitHub Profile Inspector: Official GitHub API tool to inspect any user profile and repos.

Stripe Projects (projects.dev) Catalog Services Used

  1. Stripe (Payments & Billing):
    • Why selected: Handles monetization and subscription checkout to unlock GitQuest Premium (AI Mentor access).
    • Environment variables: STRIPE_SECRET_KEY, STRIPE_PUBLISHABLE_KEY, STRIPE_PRICE_ID.
  2. Groq Cloud (AI & LLM Services):
    • Why selected: Powers the sub-300ms ultra-fast contextual AI Mentor using llama-3.3-70b-versatile.
    • Environment variables: GROQ_API_KEY, GROQ_MODEL.
  3. GitHub API (Developer Ecosystem):
    • Why selected: Inspects public GitHub profiles, repos, and follower metrics.

Technology Stack

  • Frontend: HTML5, Tailwind CSS, Modern Vanilla JavaScript (Zero build fatigue, ultra-fast load time).
  • Icons & Typography: FontAwesome 6, Devicon, Plus Jakarta Sans, JetBrains Mono.
  • AI Backend / Integration: Groq Cloud API (llama-3.3-70b-versatile).
  • Billing / Payments: Stripe Projects Checkout & Session Verification.
  • Data & State: Static JSON Curriculum + Client State with JSON Export/Import.

How to Create & Configure Necessary Accounts & Credentials

  1. Groq AI Account:

    • Go to https://console.groq.com.
    • Sign up for a free account.
    • Navigate to API Keys -> Create Key.
    • Add your key to js/services/groq-ai.js or in .env as GROQ_API_KEY=gsk_....
  2. Stripe Account (Optional / Test Mode):

    • Go to https://dashboard.stripe.com/register.
    • Switch to Test Mode.
    • Copy pk_test_... and sk_test_... from Developers -> API Keys.
    • (Note: GitQuest already includes a built-in Stripe Checkout simulator + 1-Click Judge Unlock for frictionless evaluation).
  3. Running the App Locally:

    python3 -m http.server 8000

@Taskintamim

Copy link
Copy Markdown

FounderScope

Validate a startup idea before writing code. Next.js 15 (App Router), TypeScript, Tailwind, OpenAI, and Stripe Checkout.
Stop building bad startups.

Setup

Paste an idea. Get a Build, Caution, or Kill verdict before you write a line of code.
Live demo: https://founder-scope-mu.vercel.app
GitHub: https://github.com/Taskintamim/Founder-Scope

The problem

Founders spend months — sometimes a year — shipping a product nobody wants. The expensive mistake is not writing bad code. It is building the wrong company.
FounderScope is an AI analyst that stress-tests the idea first: market, competition, revenue, risk, and a 90-day MVP plan. Then it tells you whether to build or walk away.

What it does

  1. Describe the startup in one paragraph (problem, buyer, product).
  2. Six specialist analyses run in parallel and get reconciled into one report.
  3. You get a Build / Caution / Kill verdict with scores you can actually act on.
  4. On Pro, turn that report into an investor pitch deck and export a PDF.
    No credit card is required to try it. One free analysis is included.

Features

Feature What you get
Market analysis TAM, SAM, SOM and demand signals
Competition Incumbents, substitutes, and whitespace
Revenue potential Pricing, conversion, and three-year scenarios
Risk assessment Regulatory, technical, and go-to-market risk
MVP roadmap A sequenced 90-day plan
Investor pitch Problem, wedge, model, and ask (Pro)
PDF export Print-ready report and deck (Pro)
History Reopen past analyses in this browser

Pricing

Plan Price Includes
Free $0 1 analysis, full verdict, saved locally
Pro $5 / month Unlimited analyses, investor pitch generator, PDF export
Checkout is Stripe Checkout (subscription). The success page verifies the session with Stripe before unlocking Pro. Query parameters are never trusted on their own.

Stack

  • Next.js 15 (App Router) + TypeScript
  • Tailwind CSS + ShadCN
  • Framer Motion
  • OpenAI (gpt-4o-mini) with a local demo fallback if no API key is set
  • Stripe Checkout for Pro subscriptions
  • Vercel for hosting

Try it

  1. Open the live app.
  2. Paste a real idea (problem, who it is for, what you want to build).
  3. Run the analysis. Leave the OpenAI key blank to use demo mode.
  4. Open Pricing if you want Pro (pitch + unlimited analyses + PDF).
    Stripe test card (when test keys are configured): 4242 4242 4242 4242, any future expiry, any CVC.

Local setup

git clone https://github.com/Taskintamim/Founder-Scope.git
cd Founder-Scope
npm install
cp .env.example .env.local
npm run dev

[1 line collapsed]

Open [http://localhost:3000](http://localhost:3000).
The app runs without API keys: analyses and pitches fall back to local demo mode. Stripe Checkout is skipped until `STRIPE_SECRET_KEY` is set (you can still unlock Pro in this browser from the pricing page).
The app runs without keys: analyses fall back to local demo reports. Stripe Checkout stays off until `STRIPE_SECRET_KEY` is set.
## Environment variables
### Environment variables
Copy `.env.example` to `.env.local`. Never commit secrets.
| Variable | Required | Purpose |
| --- | --- | --- |
| `OPENAI_API_KEY` | No | Live analyses. If missing, FounderScope uses local demo reports. |
| `OPENAI_API_KEY` | No | Live analyses. Missing → local demo. |
| `OPENAI_MODEL` | No | Defaults to `gpt-4o-mini`. |
| `NEXT_PUBLIC_APP_URL` | Production yes | Canonical origin for Stripe `success_url` / `cancel_url`. Example: `http://localhost:3000` or `https://your-domain.com`. |
| `STRIPE_SECRET_KEY` | For paid checkout | Server-only. Use `sk_test_…` locally. Never expose to the client. |
| `NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY` | No | Optional (`pk_test_…` / `pk_live_…`). Checkout is created on the server; this is documented for Stripe dashboard pairing. |
| `STRIPE_WEBHOOK_SECRET` | For webhooks | `whsec_…` from Stripe CLI or the Dashboard webhook endpoint. |
| `STRIPE_PRO_PRICE_ID` | No | Recurring Price ID (`price_…`) for Pro at $5/month. If omitted, Checkout creates an inline `price_data` subscription for $5 USD / month. |
| `NEXT_PUBLIC_APP_URL` | Production yes | Origin for Stripe success/cancel URLs. Use `https://founder-scope-mu.vercel.app` in production. |
| `STRIPE_SECRET_KEY` | For paid checkout | Server-only (`sk_test_…` / `sk_live_…`). |
| `NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY` | No | Dashboard pairing (`pk_test_…` / `pk_live_…`). Checkout is created on the server. |
| `STRIPE_WEBHOOK_SECRET` | For webhooks | `whsec_…` from Stripe CLI or the Dashboard. |
| `STRIPE_PRO_PRICE_ID` | No | Recurring Price ID. If omitted, Checkout bills **$5 USD / month** inline. |
## Stripe
### Stripe (production)
Plans:
- **Free** — 1 analysis
- **Pro ($5/month)** — unlimited analyses, investor pitch generator, PDF export
### Dashboard
1. Create a product **FounderScope Pro**, recurring **$5.00 / month**.
2. Copy the Price ID into `STRIPE_PRO_PRICE_ID` (optional but recommended in production).
3. Add `STRIPE_SECRET_KEY` and `NEXT_PUBLIC_APP_URL`.
4. Webhook endpoint: `POST /api/stripe/webhook`  
1. Create product **FounderScope Pro**, recurring **$5.00 / month**.
2. Set `STRIPE_SECRET_KEY`, `NEXT_PUBLIC_APP_URL`, and optionally `STRIPE_PRO_PRICE_ID`.
3. Webhook: `POST /api/stripe/webhook`  
   Events: `checkout.session.completed`, `customer.subscription.updated`, `customer.subscription.deleted`, `invoice.paid`, `invoice.payment_failed`.
Local forwarding:

[2 lines collapsed]

stripe listen --forward-to localhost:3000/api/stripe/webhook

Paste the CLI signing secret into STRIPE_WEBHOOK_SECRET.
Test card: 4242 4242 4242 4242, any future expiry, any CVC.
Checkout is created only on the server (POST /api/stripe/checkout). The success page verifies the session with Stripe (GET /api/stripe/session?session_id=) before unlocking Pro. Query parameters are not trusted on their own.

Scripts

[3 lines collapsed]

npm run lint     # ESLint

Routes

Author

Path Description
/ Marketing + analyze
/pricing Pricing
/checkout/success Stripe success (verifies session)
/checkout/cancel Stripe cancel
/dashboard Workspace
/dashboard/new New analysis (Free: 1)
/dashboard/history Saved analyses
/api/analyze OpenAI analysis
/api/pitch OpenAI pitch
/api/stripe/checkout Create Checkout Session
/api/stripe/session Verify Checkout Session
/api/stripe/webhook Signed Stripe webhooks
Built by Taskin Billah Tamim.
All copyright reserved to Taskin Billah Tamim.

@tash-9

tash-9 commented Aug 29, 2026

Copy link
Copy Markdown

MicroMentor

1. APP REQUIREMENTS / FEATURES

MicroMentor is a marketplace where users can book short, paid consultation sessions with experts.

Customer features:

  • Sign up / login
  • Search and filter experts by category, skill, price, rating, and availability
  • View expert profiles, experience, skills, ratings, and reviews
  • Choose 15, 30, or 45-minute consultation sessions
  • Select an available time slot
  • Pay securely online
  • Receive booking confirmation and meeting details
  • View upcoming and previous bookings
  • Cancel bookings according to the cancellation policy
  • Leave reviews after completed sessions

Expert features:

  • Create and manage an expert profile
  • Add skills, categories, experience, bio, and profile photo
  • Create consultation session types and set prices
  • Set weekly availability and timezone
  • Connect a Stripe account and complete onboarding
  • Receive and manage bookings
  • View earnings and payouts
  • Manage profile and availability
  • Receive booking notifications

Admin features:

  • Manage customers and experts
  • Moderate expert profiles and reviews
  • View bookings and payments
  • Manage refunds/cancellations
  • Suspend users or experts
  • View platform revenue and marketplace statistics

Payment model:

  • Customers pay per consultation.
  • MicroMentor takes a configurable platform commission, initially 15%.
  • Experts receive the remaining amount through Stripe Connect.

The core user flow is:

Find Expert → Select Session → Choose Time → Pay → Confirm Booking → Attend Session → Review


2. RELEVANT SERVICES FROM STRIPE PROJECTS (projects.dev)

Use the current Stripe Projects catalog as the source of truth and select the services required for the application.

Required services/integrations:

  • Stripe Checkout — secure customer payments
  • Stripe Connect — expert onboarding and payouts
  • Stripe Webhooks — payment and account event processing
  • PostgreSQL — application database
  • Hosting — deploy the Next.js application
  • Authentication — user authentication and account management
  • Email service — booking confirmations and reminders
  • Monitoring — production error monitoring
  • Analytics — product usage analytics

Before provisioning, inspect the current catalog with:

stripe projects catalog

Use only currently available providers/services from the catalog.


3. CHOOSE STACK BASED ON REQUIREMENTS

Frontend:

  • Next.js
  • React
  • TypeScript
  • Tailwind CSS

Backend:

  • Next.js App Router
  • Route Handlers / Server Actions

Database:

  • PostgreSQL
  • Prisma ORM

Authentication:

  • Clerk or the appropriate authentication service available through the current Projects catalog

Payments:

  • Stripe Checkout
  • Stripe Connect
  • Stripe Webhooks

Email:

  • Resend or an appropriate transactional email service

Hosting:

  • Vercel or the appropriate hosting provider available through Stripe Projects

Monitoring:

  • Sentry or an available monitoring service

Analytics:

  • PostHog or an available analytics service

The architecture should be scalable, secure, mobile-responsive, and suitable for a production marketplace.


4. CREATE AND CONFIGURE NECESSARY ACCOUNTS / CREDENTIALS

Create and configure:

  1. Stripe account

    • Create the MicroMentor Stripe platform account.
    • Enable/configure Stripe Connect.
    • Configure platform branding and business information.
    • Configure payment methods and payout settings.
    • Use Stripe Test Mode during development.
  2. Stripe Projects

    npm install -g @stripe/cli@latest
    stripe plugin install projects
    stripe projects init
    stripe projects catalog

    Provision required infrastructure using the services available in the current catalog.

  3. Authentication provider

    • Create the authentication project.
    • Configure sign-up/sign-in.
    • Configure production domain.
    • Obtain required public and secret credentials.
  4. Database

    • Provision PostgreSQL.
    • Obtain DATABASE_URL.
    • Configure Prisma migrations.
  5. Email provider

    • Create an account.
    • Verify the sending domain.
    • Create an API key.
    • Configure transactional emails.
  6. Hosting

    • Connect the Git repository.
    • Configure production environment variables.
    • Configure the production domain.
  7. Monitoring and analytics

    • Create projects.
    • Configure required DSN/API keys.
    • Add them to environment variables.

5. INTEGRATE ALL SERVICES

Build the complete MicroMentor application and integrate all required services.

Authentication

  • Implement customer, expert, and admin roles.
  • Protect authenticated routes.
  • Enforce authorization server-side.

Database

  • Create models for users, experts, skills, categories, sessions, availability, bookings, payments, reviews, notifications, and webhook events.
  • Use PostgreSQL transactions and constraints to prevent double bookings.

Stripe Connect

  • Create connected accounts for experts.
  • Use Stripe-hosted onboarding.
  • Store connected account IDs.
  • Prevent experts from accepting paid bookings until required onboarding is complete.

Stripe Checkout

  • Create Checkout Sessions server-side.
  • Calculate prices and platform fees server-side.
  • Never trust prices supplied by the browser.
  • Use Stripe Connect destination charges/application fees where appropriate.

Stripe Webhooks

  • Create a secure webhook endpoint.
  • Verify webhook signatures.
  • Process payment, refund, and Connect events.
  • Make webhook processing idempotent.
  • Confirm bookings only after verified Stripe events.

Booking system

  • Check expert availability server-side.

  • Prevent overlapping bookings.

  • Handle booking states such as:

    • Pending payment
    • Confirmed
    • Completed
    • Cancelled
    • Refunded
    • Payment failed

Email

  • Send booking confirmations, expert notifications, cancellations, reminders, and review requests.

Monitoring

  • Track application and payment-related errors without logging sensitive credentials.

Analytics

  • Track non-sensitive events such as expert profile views, booking starts, checkout starts, confirmed bookings, completed sessions, and reviews.

Final integration flow:

Customer
   ↓
Browse Experts
   ↓
Select Expert
   ↓
Select Session
   ↓
Select Available Time
   ↓
Create Pending Booking
   ↓
Stripe Checkout
   ↓
Payment
   ↓
Stripe Webhook
   ↓
Verify Payment
   ↓
Confirm Booking
   ↓
Send Email + Meeting Details
   ↓
Consultation
   ↓
Complete Booking
   ↓
Customer Review
   ↓
Expert Payout

@SyedRumanFahim

Copy link
Copy Markdown

Mim, Smart AI Receptionist — project summary

Mim is a live AI receptionist for Shahin Air Care, a one-stop AC service in Mirpur, Dhaka. A judge opens a browser “phone,” talks to Mim in English, gets a rate-card quote, receives an in-app SMS with a payment link, pays in a Stripe-style sandbox (no real money), and sees the owner dashboard update in real time.

This is a real conversation + booking + test payment demo. In production Mim would sit on a real shop phone number (Twilio Voice + SMS). Twilio is not free (so we simulates it in-browser phone instead of phone number calling)


The story

Shahin owns a small AC shop. When he is on a job, the shop phone rings and he loses the booking. Mim, our smart ai receptionist answers calls, she understands the problem, checks if the area is served, quotes only from the rate card, holds a slot, and collects an advance so the slot is real.

Nusrat is the caller. She lives in Dhanmondi. Her AC is not cooling. She wants general servicing, a time tomorrow, and she is willing to pay an advance on her phone.

Judges play Nusrat on the call page and Shahin on the dashboard. They can haggle, refuse the link, or invent an emergency ,Mim will stay in character.


User stories

Who Want So that
Nusrat (caller) Speak or type in English and get a clear quote and slot( i tried bangla but free models are horrible in bengali) She can book without waiting for Shahin
Nusrat Pay a small advance on her phone The technician actually comes
Shahin (owner) See live calls, revenue, transcript, and a owner SMS He knows what happened while he was out
Shahin Reset the demo The next judge starts clean
Judge Use dummy login and a test card They can try the full loop with no real account or money

What happens on a good call

  1. Judge taps Call. Mim greets in English (Jenny voice).
  2. Caller says they are in a served area and need a listed job (e.g. general servicing in Dhanmondi).
  3. Mim quotes the card price in spoken English (e.g. 800 taka, advance 500 taka).
  4. Caller picks a slot: 10am / 12pm / 3pm / 5pm, today or tomorrow.
  5. Mim confirms the mobile number and sends an in-app SMS with a checkout link.
  6. Judge opens the link, pays with the Stripe test card. No money moves.
  7. Mim, still on the line, confirms the slot. The dashboard Revenue rescued counter ticks. Status shows STRIPE TEST MODE.

Slots are only held for 10 minutes until the advance is paid.


Rate card (enforced — Mim cannot invent prices)

Service Price Advance
AC general servicing ৳800 ৳500
AC deep cleaning ৳1,500 ৳500
Gas refill (after inspection) ৳3,000 ৳1,000
New installation Site visit only —

Areas served: Mirpur, Dhanmondi, Mohammadpur, Uttara, Bashundhara.
Out of area (polite no): Narayanganj, Gazipur, Savar, Chittagong, etc.


Tools we used

Layer Tool Why
App server Python FastAPI + WebSockets Live call + dashboard, not a static site
UI React + Vite Call page, owner dashboard, checkout
Database SQLite Calls, bookings, payments, transcripts
Speech in (STT) Groq Whisper (whisper-large-v3-turbo, English) Free, fast transcription
Brain Google Gemini 3.6 Flash (AI Studio, free) Natural English receptionist
Brain fallback Groq qwen/qwen3.6-27b If Gemini is down
Speech out (TTS) Microsoft Edge TTS en-US-JennyNeural Natural English voice, no paid TTS key
Checkout UI Stripe-style sandbox on our server BD cannot open a live Stripe account; look and flow match Checkout
Confirm pay Test card 4242…4242 → backend PIN 1234 No Stripe charge, no bKash
HTTPS / mic Cloudflare quick tunnel Phones need HTTPS for the microphone
Host Oracle Always Free Ubuntu ARM VM Long-running Python + WebSockets

Not used (and why): live Twilio Voice/SMS (numbers and minutes are paid), live Stripe (accounts not available from Bangladesh), Vercel / Hugging Face free hosting (no 24/7 WebSocket Python process).


Where it is deployed

Item Value
Cloud Oracle Cloud Always Free · instance blog-server
OS Ubuntu 24.04 ARM (VM.Standard.A1.Flex)
Live URL https://nuclear-stickers-visits-graphic.trycloudflare.com

How to test (judges)

Use two tabs or two devices: phone = caller, laptop = owner. Allow the microphone when asked.

Links

Owner login (dummy)

  • Username: shahin
  • Password: air123

Golden path (about 2 minutes)

  1. Open the dashboard, sign in, leave it visible.
  2. Open the call page. Name can stay Nusrat, number 01712345678. Tap Call.
  3. Wait for the greeting, then Hold to talk (or press Space) and say, in English:

Hi, this is Nusrat. I'm in Dhanmondi. My AC isn't cooling. I need general servicing.

  1. When she offers times, say:

Tomorrow at 5pm.

  1. An SMS sheet appears. Open Open advance payment.
  2. Pay with:
  • Card: 4242 4242 4242 4242
  • Expiry / CVC can stay as shown
  • This is not a real charge
  1. Go back to the call. Mim should confirm the slot. On the dashboard, revenue should move from ৳0 and the call card should update.
  2. Say goodbye, or tap End.

You can talk over Mim — hold Hold to talk while she is speaking and she will stop, like a real call. You can also type in the box if the room is noisy.

Other things to try

What you say What Mim should do
“Can you do it for 500 taka?” Hold ৳800. No discount. If you push, she offers that Shahin will call.
“I won't pay on the link, cash when the tech comes.” Soft-book. No argument.
“There's a burning smell / sparking / a baby can't sleep in this heat.” Treat as emergency. Owner is notified on the dashboard.
“I'm in Narayanganj.” Politely decline. No booking.
“Deep cleaning — what's the rate?” ৳1,500, advance ৳500.
“New AC installation.” No invented price. Site visit / Shahin will call.

Between runs, use Demo reset on the dashboard.


Screens

Page Role
/ In-browser phone: mic, hold-to-talk, captions, in-app SMS
/dashboard Shahin’s desk: live feed, ৳ revenue, transcripts, owner SMS, reset
/pay/:token Stripe-looking Checkout for the advance (sandbox)

Honest limits (say this if asked)

  • English call is the live path (Whisper + Gemini + Jenny). Bangla STT was too unreliable on a free stack for a judge demo.
  • Payment is a self-hosted sandbox that looks like Stripe Checkout. Live Stripe can be swapped in when a supported account exists. Bangladesh cannot open Stripe today.
  • Cloudflare quick tunnel URL can change if the tunnel process restarts. The Oracle VM and Mim process stay up.
  • Grok 4.6 is not in the runtime. Cursor uses it for building the project; the phone brain is Gemini 3.6 Flash (free) with Groq as backup.

Local run (optional)

cd backend
python -m venv .venv
.\.venv\Scripts\Activate.ps1
pip install -r requirements.txt
uvicorn app.main:app --reload --host 0.0.0.0 --port 8000

cd frontend
npm install
npm run dev

Caller: http://localhost:5173 · Dashboard: http://localhost:5173/dashboard
Copy .env.example to .env and add Groq + Gemini keys.

@afuadahmed

Copy link
Copy Markdown

SOC Copilot — Intelligent Security Incident Triage

Build "SOC Copilot": an intelligent Security Operations Center dashboard for analyzing and triaging security incidents.

Output / App Behavior

SOC Copilot provides a security analyst-focused interface for investigating suspicious activity. Analysts can select simulated attack scenarios, review realistic security events and logs, run an automated triage process, and receive a structured assessment containing severity, confidence, MITRE ATT&CK mapping, and recommended response actions.

The application is designed as a lightweight SOC demonstration that allows judges to experience the complete incident-triage workflow without requiring access to a live SIEM or production infrastructure.

Core Requirements & Features

  1. SOC Dashboard: Overview of incidents, severity distribution, average confidence, and recent security events.
  2. Incident Analyzer: Select simulated attacks such as SSH brute force, SQL injection, port scanning/reconnaissance, and suspicious PowerShell activity.
  3. Automated Incident Triage: Analyze security events and determine severity, confidence, attack classification, and recommended actions.
  4. MITRE ATT&CK Mapping: Map detected attack behavior to relevant MITRE ATT&CK techniques.
  5. Security Event Log Console: Display realistic event and log information to help analysts understand the underlying activity.
  6. Incident History: Store previously analyzed incidents locally and allow analysts to review historical investigations.
  7. Recommended Response: Provide actionable containment and investigation recommendations based on the detected threat.
  8. Analyst View / Demo Mode: A simplified interface designed to make the complete workflow easy for hackathon judges to evaluate.
  9. No Live Infrastructure Required: The current implementation uses simulated security events so the application can demonstrate the complete triage workflow safely without connecting to production systems.

AI / Security Analysis

  • OpenRouter API is integrated as the AI analysis provider.
  • The application can use a configurable model through OPENROUTER_MODEL.
  • OPENROUTER_API_KEY is stored as a server-side environment variable and is not exposed to the client.
  • The analysis pipeline is designed to transform raw security-event information into a structured incident assessment.

Technology Stack

  • Frontend / Application: Next.js, React, TypeScript
  • Styling: Tailwind CSS
  • AI Analysis: OpenRouter API
  • Hosting / Deployment: Vercel
  • Version Control: GitHub
  • Data / Demo State: Local browser storage and simulated security-event data

How to Run Locally

  1. Clone the repository.
  2. Install the dependencies:
npm install
  1. Create a .env.local file and configure:
OPENROUTER_API_KEY=your_api_key
OPENROUTER_MODEL=your_model
  1. Start the development server:
npm run dev
  1. Open the application at:
http://localhost:3000

Live Demo

[SOC Copilot — Live Demo](https://soc-copilot-sable.vercel.app)

Repository

[SOC Copilot — GitHub Repository](https://github.com/afuadahmed/soc-copilot)

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment