Cooachly

A coaching platform with three roles — admin, professor, and student — built with Next.js (App Router), TypeScript, Prisma/PostgreSQL, and Stripe.

Features

• Role-based accounts — admin, professor, and student, each with their own dashboard and protected routes (enforced both in src/proxy.ts and in every server component via src/lib/dal.ts).
• Timezone-aware scheduling — professors set recurring weekly availability once (in their own timezone, choosing a session length of 45/60/75/90 minutes per window); students always see open slots converted to their own local timezone, priced proportionally to the slot's length.
• Booking & payments — students book sessions and pay via Stripe Checkout (one-off per session), or subscribe monthly to a professor for unlimited sessions. If Stripe isn't configured, bookings are auto-confirmed so you can develop without a Stripe account.
• Messaging — simple in-app messaging between students and professors.
• Video calls — every confirmed booking gets its own Daily.co video room automatically. If DAILY_API_KEY isn't set, professors can paste a manual meeting link (Zoom, Google Meet, etc.) instead.
• Optional live transcription + AI session summaries — set DAILY_ENABLE_TRANSCRIPTION="true" to transcribe sessions live (Daily + Deepgram, billed per participant-minute — no audio/video is stored, just text) and get them summarized (OpenAI GPT) automatically after each class, then emailed to both student and professor. Off by default to keep video calls free.
• Monthly student summaries — admins can generate a consolidated monthly progress recap per student/subject from that month's session summaries, from the Class Logs page.
• Admin class log — admins can browse every past session with its transcript and AI summary.
• Test files & answers — professors and admins can share a test file on a booking; students upload their answer back, both stored via Vercel Blob.
• Reminders — automatic email (Resend), WhatsApp, and SMS (Twilio) reminders 1 day, 1 hour, and 5 minutes before each session, sent by a scheduled job hitting /api/cron/reminders.
• Installable mobile app (PWA) — Cooachly and Cooachly Arts can each be installed to an iPhone or Android home screen from the browser, with their own icon and name, and send push notifications for session reminders and new messages. Turned on per device under Settings → Mobile app & notifications.
• Admin panel — manage user roles/access, extend or join any booking's video call, and see all bookings and revenue.
• About page at /about.

Tech stack

• Next.js 16 (App Router, Server Actions, Turbopack)
• TypeScript, Tailwind CSS
• Prisma + PostgreSQL
• Auth: custom email/password auth using signed, httpOnly JWT session cookies (jose + bcryptjs) — no third-party auth provider required
• Stripe for payments and subscriptions
• Daily.co for video rooms + live transcription
• OpenAI (GPT) for session and monthly AI summaries
• Resend for email, Twilio for WhatsApp + SMS reminders
• Vercel Blob for test-file and answer uploads

Every third-party integration above is optional at the code level — if its API key isn't set, that feature no-ops (logs to the console) instead of crashing, so you can run and demo the app without signing up for anything, then turn integrations on one at a time.

Local development

1. Install dependencies

npm install

2. Configure environment variables

Copy .env.example to .env and fill in the values:

cp .env.example .env

Variable	Description
DATABASE_URL	PostgreSQL connection string
SESSION_SECRET	Random secret used to sign session cookies. Generate with openssl rand -base64 32
NEXT_PUBLIC_APP_URL	Public URL of the app (http://localhost:3000 locally)
STRIPE_SECRET_KEY	Stripe secret key (optional in dev — see below)
NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY	Stripe publishable key
STRIPE_WEBHOOK_SECRET	Signing secret for the /api/stripe/webhook endpoint

If you leave the Stripe keys as placeholders, the app runs in test mode: bookings are auto-confirmed without collecting payment, so you can build and demo the whole flow without a Stripe account.

3. Set up the database

You need a PostgreSQL database. Locally you can use Docker:

docker run --name cooachly-db -e POSTGRES_PASSWORD=postgres -e POSTGRES_DB=cooachly -p 5432:5432 -d postgres:16

Then point DATABASE_URL at it (the default in .env.example already matches this setup), and run the migrations:

npm run db:migrate

4. Seed sample data (optional but recommended)

npm run db:seed

This creates three accounts you can log in with immediately:

Role	Email	Password
Admin	[email protected]	ChangeMe123!
Professor	[email protected]	ChangeMe123!
Student	[email protected]	ChangeMe123!

Change or remove these before going to production.

5. Run the dev server

npm run dev

Open http://localhost:3000.

Setting up Stripe (optional for local dev, required for real payments)

1. Create a free account at stripe.com.

2. Copy your test publishable and secret keys from dashboard.stripe.com/test/apikeys into .env.

3. To receive webhook events locally, install the Stripe CLI and run:

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

   Copy the whsec_... value it prints into STRIPE_WEBHOOK_SECRET.

4. In production, add a webhook endpoint in the Stripe dashboard pointing at https://your-domain.com/api/stripe/webhook, subscribed to at least: checkout.session.completed, customer.subscription.updated, customer.subscription.deleted.

Setting up reminders (email, WhatsApp, SMS)

1. Email — Resend: sign up at resend.com, verify a sending domain (or use their [email protected] test address to start), create an API key at resend.com/api-keys, and set RESEND_API_KEY + RESEND_FROM_EMAIL.

2. WhatsApp — Twilio: sign up at twilio.com, join Twilio's WhatsApp sandbox (or apply for a production WhatsApp sender), and set TWILIO_ACCOUNT_SID, TWILIO_AUTH_TOKEN, and TWILIO_WHATSAPP_FROM to the number Twilio gives you, e.g. whatsapp:+14155238886.

   Reminders, invites, and demo confirmations go out by both WhatsApp and SMS — a recipient who misses one channel (no WhatsApp installed, a silent WhatsApp-side rejection) still gets the other. SMS doesn't need a pre-approved Content Template the way WhatsApp does, but each country's SMS leg needs its own locally-registered sender number first (see US/Canada & India SMS below) — leave a country's sender unset to keep sending WhatsApp-only to that country until it's registered.

   Before going live, submit each WhatsApp message type below as its own template for Meta's approval in the Twilio console (Messaging → Content Editor). Meta requires an approved template for any business-initiated message sent outside a 24-hour customer-service window — which reminders, invites, and demo confirmations always are — so free-form messages are rejected once you're off the sandbox, with Twilio error 21654 "ContentSid Required".

   Submit templates that look like this (Category: Utility, so none need marketing opt-in):

   • Reminders — TWILIO_REMINDER_CONTENT_SID:

     Hi {{1}}, this is a reminder that your Cooachly session with {{2}} starts {{3}} ({{4}}).
     Join here: {{5}}
     

   • Account invites — TWILIO_INVITE_CONTENT_SID:

     Hi {{1}}, you've been invited to create your {{2}} account. Create your login here: {{3}}
     

   • Demo request confirmations — TWILIO_DEMO_CONTENT_SID:

     Thanks for requesting a free {{2}} demo for {{3}}, {{1}}! We'll reach out shortly to
     schedule a time.
     

Reminders only go out for confirmed bookings, and only once per threshold (tracked via reminder24hSentAt / reminder1hSentAt / reminder5mSentAt on each booking), so re-running the job frequently is safe. WhatsApp and SMS are both skipped for anyone without a phone number on file.

Setting up the mobile app & push notifications

The app ships a web app manifest per site (/manifest.webmanifest and /arts/manifest.webmanifest) and a service worker (public/sw.js), so on any HTTPS deployment it can be installed straight from the browser — no App Store or Play Store submission needed:

• Android (Chrome): browser menu → Install app, or the Install app button under Settings → Mobile app & notifications.
• iPhone/iPad (Safari): Share → Add to Home Screen. Push notifications on iOS need iOS 16.4+ and only work from the installed app, not a Safari tab.

Push notifications (session reminders at 1 day / 1 hour / 5 minutes, and new messages) need a VAPID key pair. Generate it once and add both values to your environment:

npx web-push generate-vapid-keys

Variable	Description
NEXT_PUBLIC_VAPID_PUBLIC_KEY	Public VAPID key (sent to browsers)
VAPID_PRIVATE_KEY	Private VAPID key (server only)
VAPID_SUBJECT	mailto: address push services can contact you at

Keep the same keys forever — rotating them silently breaks every existing device subscription. Without them, push is skipped and reminders still go out by email/WhatsApp. Each user then turns on notifications per device under Settings → Mobile app & notifications; the admin Send test notification button also sends a test push. The service worker never caches pages or data (so nobody sees stale bookings); it only shows an offline page when there's no connection.

Setting up video calls & AI summaries (Daily.co + OpenAI)

1. Sign up at daily.co and create an API key at dashboard.daily.co/developers. Set DAILY_API_KEY. Once set, every confirmed booking automatically gets a video room — no code changes needed. Without it, professors fall back to pasting a manual meeting link.
2. Attendance (join/leave) tracking — free, unlike transcription below, and independent of whether you turn transcription on. In the Daily.co dashboard, add a webhook pointing at https://your-domain.com/api/daily/webhook, subscribed to participant.joined and participant.left. Every "Join video call" link in the app already routes through /api/daily/join/[bookingId], which tags the join with the signed-in user's own account before sending them to the room, so each join/leave is correctly attributed to that student or professor — not just an anonymous Daily participant. The full join/leave history (count and every timestamp, per person) shows on that booking's row under Admin → Class logs.
3. Live transcription + AI summaries are opt-in, since Daily bills transcription per participant-minute. By default (DAILY_ENABLE_TRANSCRIPTION unset or false), video calls work but aren't transcribed, and no summary is generated. To turn transcription + summaries on:
   • In the Daily.co dashboard, go to Settings → Transcription and add a Deepgram API key (sign up free at deepgram.com — this is a separate prerequisite from DAILY_API_KEY and is required before transcription will work at all).
   • Set DAILY_ENABLE_TRANSCRIPTION="true".
   • In the Daily.co dashboard, add (or extend the one from step 2 with) a webhook pointing at https://your-domain.com/api/daily/webhook, subscribed to both the meeting.started event (starts transcription when a call begins) and the transcript.ready-to-download event (fetches the finished transcript). (Optional: enable webhook signing and set DAILY_WEBHOOK_SECRET to verify requests.)
   • Sign up at platform.openai.com, create an API key, and set OPENAI_API_KEY. This powers the GPT-generated summary that gets emailed to both parties after each session, and the monthly student recaps admins can generate from Class Logs.

No audio or video is ever stored with this approach — only the text transcript, which is both cheaper and more private than cloud recording.

If attendance tracking, transcription, and AI summaries all stop at once (not just one of them), the webhook has almost certainly tripped Daily's circuit breaker: by default, 3 non-2xx responses from your endpoint — across any event type — and Daily stops sending all future webhooks to it, silently, with no notice anywhere in your own app. Check for this first:

1. GET https://api.daily.co/v1/webhooks (with your DAILY_API_KEY as the bearer token) lists your webhook(s) — look at failedCount and whether it's still trying to deliver.
2. Fix whatever caused the failures (check Vercel's function logs for /api/daily/webhook around when it stopped, and confirm DAILY_WEBHOOK_SECRET in production still matches what Daily has on file for that webhook, if you set one — a mismatch after recreating/updating the webhook rejects every single delivery with 401 and trips the breaker almost immediately).
3. POST https://api.daily.co/v1/webhooks/<uuid> makes Daily retry once; a 200 from your endpoint closes the breaker and resumes normal delivery. There's no dashboard button for this — it's API-only.

Setting up file sharing (Vercel Blob)

Professors/admins can share a test file on a booking, and students can upload their answer back. This needs blob storage:

1. In your Vercel project, go to Storage → Create Database → Blob (free tier available).
2. Vercel automatically injects BLOB_READ_WRITE_TOKEN into your production environment once connected — no manual copying needed there. For local development, copy the token shown in the Blob store's dashboard into your .env.

Without this configured, upload attempts show a message asking an admin to set it up, rather than failing silently.

Deploying — hosting cooachly.com

You already own the domain; the pieces you need are (1) somewhere to run the Next.js app, and (2) a Postgres database, then (3) pointing the domain at the app. The easiest and cheapest path:

1. Push this repo to GitHub

If it isn't already, push this project to a GitHub repository — Vercel deploys straight from Git.

2. Create a Postgres database

Any of these work well and have a free tier:

• Neon (recommended — serverless Postgres, generous free tier)
• Supabase
• Vercel Postgres (powered by Neon, integrates directly)
• Railway

Create a database and copy its connection string — you'll use it as DATABASE_URL.

3. Deploy to Vercel

1. Go to vercel.com/new and import this GitHub repository.

2. Vercel auto-detects Next.js — no build settings to change.

3. Add the environment variables from your .env (DATABASE_URL, SESSION_SECRET, NEXT_PUBLIC_APP_URL, STRIPE_SECRET_KEY, NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY, STRIPE_WEBHOOK_SECRET) under Project Settings → Environment Variables.

   • Set NEXT_PUBLIC_APP_URL to https://cooachly.com (or the Vercel URL until your domain is connected).

4. Deploy. Vercel will run npm run build, which runs prisma generate automatically (see the postinstall/build scripts in package.json).

   No deployment showing up? Vercel only builds on new pushes made after the Git connection is created — it won't retroactively build a commit that already existed on main before you connected the repo. If Deployments is empty, push any new commit to main (or reconnect the repo under Project Settings → Git) to trigger the first build.

5. After the first deploy, run the database migration against your production database once (from your machine, with DATABASE_URL set to the production connection string):

   npm run db:migrate
   

   (Or use prisma migrate deploy in a CI step for subsequent deploys.)

4. Point cooachly.com at Vercel

1. In your Vercel project, go to Settings → Domains and add cooachly.com (and www.cooachly.com if you want both).
2. Vercel will show you DNS records to add. Go to wherever you bought the domain (registrar's DNS settings) and add them — typically:
   • Apex domain (cooachly.com): an A record pointing to 76.76.21.21 (Vercel will show the exact current value — use what it gives you).
   • www.cooachly.com: a CNAME record pointing to cname.vercel-dns.com.
3. DNS changes can take a few minutes to a few hours to propagate. Vercel automatically issues a free SSL certificate once it verifies the domain.
4. Decide whether cooachly.com or www.cooachly.com is canonical, and set up a redirect for the other in Vercel's domain settings (it offers a one-click "redirect to" option).

5. Configure the Stripe webhook for production

In the Stripe dashboard, add an endpoint at https://cooachly.com/api/stripe/webhook and copy its signing secret into Vercel's STRIPE_WEBHOOK_SECRET environment variable. Switch your Stripe API keys from test to live mode when you're ready to accept real payments.

That's it — cooachly.com will serve the app, backed by your Postgres database, with Stripe handling payments.

Project structure

prisma/schema.prisma        Database schema (User, ProfessorProfile, Availability, Booking, Message, Subscription, Attachment, MonthlySummary)
prisma/seed.ts              Seed script for sample admin/professor/student accounts
src/proxy.ts                Route protection (Next.js 16's replacement for middleware.ts)
src/lib/                    Session/auth, Prisma client, scheduling, Stripe, Daily.co, AI summary, blob storage, DAL helpers
src/lib/notifications/      Email (Resend) + WhatsApp/SMS (Twilio) senders
src/actions/                Server Actions (auth, bookings, availability, messages, billing, admin, profile, attachments, monthly-summary)
src/app/(admin|professor|student)/   Role-specific dashboards
src/app/admin/class-logs    Admin view of every past session's transcript/AI summary + monthly recaps
src/app/about               Public "About Cooachly" page
src/app/api/stripe/webhook  Stripe webhook handler
src/app/api/daily/webhook   Daily.co webhook → attendance events, transcription, summarize + email
src/app/api/daily/join      Tags a join with the signed-in user before sending them to the room
src/app/api/cron/reminders  Scheduled job: sends 24h/1h/5m reminders for upcoming sessions