A custom member portal for the TSP Mastermind — four subsystems replacing CoachSimple, Calendly, and Google Calendar, while Keap, Vimeo, and Google Meet + Gemini stay exactly where they are. This proposal is built directly from your development brief, and this revision finalizes Google Cloud as the hosting environment.
Updated at your request — launch date moved to May 2027; Notes Pipeline and Scheduling re-sequenced from parallel to sequential to use the extra runway to de-risk rather than just to relaxWe know why you're replacing your current system — you've lived with the friction every day. Your development brief tells us precisely what should replace it: a custom portal built around four subsystems — training library search, core portal & member records, a coaching notes pipeline, and automated scheduling — sitting on top of Keap (staying, your system of record for status and billing), Vimeo (staying, your ~500 hours of training video), and Google Meet + Gemini (staying, your notetaker). CoachSimple, Calendly, and Google Calendar as a standalone scheduler are being retired.
Three of the four subsystems already have complete design specs, data schemas, and screen mockups — your team did real work before we ever got involved. That changes the shape of this proposal: this isn't a from-scratch discovery exercise, it's sequencing an already-designed build and validating the one genuinely open technical question, how Gemini's notes actually get into the system.
Your soft launch has since moved from the third week of December 2026 to May 2027. That roughly triples the runway — from about 14 weeks to about 36 — and we've put the extra time to use in two ways: Subsystems 3 and 4 (Notes Pipeline and Scheduling) now build sequentially instead of in a tight parallel sprint, giving the no-human-approval scheduling agent a dedicated hardening window instead of sharing one with the notes pipeline; and the five previously out-of-scope member-facing pieces — the 90-day visual tracker, onboarding dashboard, in-portal chat, event tickets, support tickets — now have a real option to be folded into this build instead of waiting for a second phase. We've left that as a decision for you to make in Section 11, not an assumption we've made on your behalf.
This revision also finalizes our hosting recommendation to Google Cloud — detailed in Section 04 — since every system this build touches outside of Keap is already Google Workspace, and adds Cloud Storage as the object-storage layer for transcription working files, notes-doc archives, and backups.
Every pain point you described to us and every problem named in your brief traces to one of four fixes. Laid out side by side, the scope stops looking like a wish list and starts looking like a punch list.
| Problem | Where it shows up | Fixed by |
|---|---|---|
| People are the wiring between systems. Booking one call takes ~15 minutes of re-keying the same five facts across four tools. | Wrong coach assigned, members double-booked — both are re-keying errors, matching what your team described: unscheduled requests sitting in a queue (the Javier example). | Subsystem 4 Automated Scheduling |
| Anything needing separate maintenance goes stale. "Hot Sheet" member profiles are built once at intake and never updated. | Coaches walk into calls blind. Echoes what you told us about the flat, unsortable revenue table and the fixed onboarding questionnaire. | Subsystem 2 Core Portal — records that update themselves from live inputs, not a form filled out once |
| Ten years of coaching content is unreachable. ~500 hours in Vimeo with no way to search it. | A direct match to your own words: "I couldn't actually tell you" what the most popular or most-viewed content is. | Subsystem 1 Training Library Search |
| Data is not extractable. Wins, revenue, action steps, and goals can't be downloaded for analysis. | Matches your own revenue-table complaint almost verbatim — "no way to sort things." | Subsystem 2 Core Portal — a reporting/export layer joinable against Keap data |
Your own tool inventory already answers this: CoachSimple, Calendly, and Google Calendar as a scheduling front end are being replaced; Keap, Vimeo, and Google Meet + Gemini are staying. We reviewed three platforms for context before recommending this direction — CoachSimple (your incumbent), Kajabi (the course-builder UX your team named as its bar), and Mighty Networks (the closest thing on the market to a mastermind-community platform).
| Platform | Strongest at | Why it's still not the answer |
|---|---|---|
| CoachSimple | Coaching-specific vocabulary out of the box; same backend runs RECoach.me for real-estate coaching franchises. | No content analytics, unsortable revenue, a dead scheduling tab, and — as your brief notes — no path to Gemini-based notes, Whisper-searchable video, or Keap-tag-driven access. |
| Kajabi | The drag-and-drop course builder your team named directly; bundled marketing and a branded app on Growth+. | Has no concept of a coach-matching scheduling agent, a Gemini notes pipeline, or Keap as an external system of record — your actual operating model would be bolted on with brittle automations, not built in. |
| Mighty Networks | Best-in-class community/engagement layer; native apps at its Pro tier. | Same gap as Kajabi, plus lighter course authoring — and neither platform can search ten years of Vimeo video the way Subsystem 1 is scoped to. |
None of the three run a Keap-tag access model, ingest Gemini notes, or offer hybrid search over an existing Vimeo library — which is exactly the ground your four subsystems are built to cover. Custom is the only path that makes your existing Keap/Vimeo/Meet investment work together instead of around each other.
One database, four subsystems, nine integrations, hosted end to end on Google Cloud. Keap stays the system of record for member status, billing, and access — everything else in the portal reads from it and writes structured data back out to it, never the reverse.
| # | Integration | What's needed | |
|---|---|---|---|
| 1 | Keap | Read contacts, read/write custom fields, webhooks on tag add/remove — the canonical member ID and the access-control mechanism. | non-trivial |
| 2 | Google Calendar | Create/modify/cancel events, read availability across every coach's calendar. | standard |
| 3 | Google Meet | Auto-generate meeting links via the Calendar API — mandatory, since Gemini only attaches to Meet. | standard |
| 4 | Gemini notes ingestion | Get note output into the system automatically — the biggest technical unknown. See Section 05. | non-trivial |
| 5 | Vimeo | List videos, pull files/titles/dates/play stats — one-time bulk pull, then ongoing for new uploads. | standard |
| 6 | Whisper (OpenAI) | Transcription with word-level timestamps — one-time bulk run. | standard |
| 7 | LLM API | Note extraction, accountability-email drafting, video tagging, booking-request interpretation. | standard |
| 8 | Transactional email | Accountability emails and booking confirmations — Postmark/SendGrid, or route through Helpscout. | standard |
| 9 | SMS | Booking confirmations by text — already part of the current SOP. | standard |
| Layer | Recommendation | Why |
|---|---|---|
| Database | PostgreSQL + pgvector, run as Cloud SQL for PostgreSQL — confirming the assumption in your brief | One database serves both structured records and transcript-passage vector search. A separate vector store would be an extra operational system for no real gain at this scale (~500 videos, ~150 members). Cloud SQL's pgvector support is a managed, officially supported extension — no separate vector database to run, patch, or secure. AlloyDB for PostgreSQL is the natural upgrade path if the training library or member base grows well past this scale, since its built-in ScaNN index outperforms pgvector's HNSW at larger vector counts — the same Postgres wire protocol either way, so it's a resize decision, not a rewrite. |
| Application | Node.js/TypeScript or Python, containerized, deployed on Cloud Run | Cloud Run services (always-on) host the API and the always-listening pieces (the Drive watch endpoint, the scheduling agent); Cloud Run Jobs handle bounded batch work (Vimeo bulk pull, Whisper transcription runs) with timeouts up to seven days — comfortably enough for the ~500-hour backlog without needing a separate VM or Kubernetes cluster to operate. |
| Object storage | Cloud Storage | Working audio/video during transcription, archival copies of Gemini notes docs pulled from Drive, encrypted backup exports, and member-uploaded revenue documentation — lifecycle-managed and CMEK-encrypted rather than living on local disk or a separate storage vendor. |
| Job queue / async | Cloud Tasks for retryable work, Pub/Sub for event fan-out | The Drive API can publish its push notifications straight to a Pub/Sub topic — the Section 05 watch channel becomes a native GCP subscription instead of a webhook endpoint the app has to defend on its own. Cloud Tasks handles retry/backoff for Keap reconciliation, accountability email sending, and SMS confirmations, each independently, so one fragile step never blocks a request. |
| Hosting | Google Cloud Platform, end to end | Every external dependency this build has outside its own code — Meet, Gemini, Calendar, and Drive — is already Google Workspace, and the Section 05 notes-ingestion fix already runs on a Google service-account identity. Hosting the app, the database, and that identity on GCP keeps them inside one IAM boundary instead of stitching a second cloud vendor's credentials into an already Google-native pipeline. See the table below for the full service mapping. |
This build's dependency graph already leans almost entirely on Google. Keap is the one system of record that doesn't; everything else — the video call, the notetaker, the calendars, the file that carries the notes — is Google Workspace. Hosting on GCP isn't a generic "pick a cloud" choice; it's a decision to stop crossing a vendor boundary for pipelines that never needed to cross one.
| Function | GCP service | Role in this build |
|---|---|---|
| Compute | Cloud Run (services + jobs) | API, coach/member web app, the always-on scheduling agent and Drive-watch listener, and bounded batch jobs (transcription, bulk Vimeo pull). |
| Database | Cloud SQL for PostgreSQL (pgvector) → AlloyDB if scale demands it | Member records, goals, revenue, notes, and transcript-passage vectors — one instance, automated backups and point-in-time recovery built in. |
| Object storage | Cloud Storage | Transcription working files, Gemini notes doc archive, backup exports, member-uploaded documentation. |
| Async / queue | Cloud Tasks, Pub/Sub | Retryable webhook and notification delivery; the Drive push-notification channel from Section 05 publishes here natively. |
| Identity backing Section 05 | IAM + a dedicated Workspace service account | The centralized Meet-organizer identity that makes the Gemini notes pipeline tractable is already a Google identity — GCP IAM governs it directly rather than through a second vendor's credential store. |
| Secrets & encryption | Secret Manager, Cloud KMS | Keap, OpenAI, and LLM-provider API keys held outside application config; CMEK-managed encryption keys for Cloud SQL and Cloud Storage. |
| Perimeter & access | Cloud Armor, Identity-Aware Proxy, VPC Service Controls | WAF/DDoS protection on the public app; the admin and coach interface gated behind the same Google Workspace SSO coaches already use for Meet and Gemini; database and storage traffic kept off the public internet. |
| CI/CD & observability | Cloud Build, Artifact Registry, Cloud Logging/Monitoring, Error Reporting | Container builds and deploys, and the logging/alerting layer that catches problems before they reach your members. |
This is the question your brief calls its largest unknown, and we want to answer it concretely rather than leave it open. Google's own documentation for "Take notes for me" confirms the constraint: when a Meet call ends, Gemini saves the recap as a Google Doc into the meeting organizer's Drive, in a "Google Meet" folder, attaches it to the Calendar event, and emails a link to whoever was granted access. There is no dedicated webhook or API built for this — which is exactly why it reads as an unknown.
The way through it is in how the calls get booked, not in how the notes get read. If Subsystem 4's scheduling agent creates every coaching-call event under one dedicated Workspace identity — a service calendar, not each coach's personal one — every Gemini notes doc for every coach lands in that single account's Drive. One Drive to watch instead of monitoring N coaches' personal accounts, which would otherwise require Workspace domain-wide delegation and admin consent per coach just to read their files.
Register a Drive API push-notification channel on that one service account's "Google Meet" folder. New file → webhook fires → pull the doc via the Docs API → hand off to the extraction layer. Fast, but watch channels expire and need scheduled renewal.
A worker polls that same folder every few minutes for files created since the last check. Catches anything a lapsed watch channel misses — cheap insurance on the pipeline's single biggest dependency.
If coaches must remain individual meeting organizers for calendar-ownership reasons, the same pattern still works via a Workspace service account with domain-wide delegation, reading each coach's Drive — more setup and an admin-consent step, but the same mechanism underneath.
Taking the questions from your brief in order — technical first, then commercial.
1 · How would you get Gemini meeting notes into the system automatically?
Covered in full in Section 05 — the short version is: centralize the Meet organizer identity and watch its Drive, with a polling fallback. We recommend validating this first, in Phase 0, since it gates the entire notes pipeline.
2 · Any concerns with Keap's API and webhook reliability at your volume?
Not at ~150 members — Keap's published limits (1,500 requests/minute on OAuth2 tokens, up to 10,000/minute per application instance) are far beyond what a portal this size generates. The real risk isn't volume, it's that webhook delivery on any platform is best-effort, not guaranteed. We recommend treating Keap webhooks as the fast path for tag-change access updates, backed by a nightly reconciliation job that polls Keap directly and corrects any drift — so a missed webhook never permanently locks a member out of, or leaves them in, a portal tier.
3 · Multi-coach availability across Google Calendars — how much complexity does that add?
Less than it sounds. Google's FreeBusy API accepts multiple calendar IDs in a single query, so pulling every coach's open slots isn't the hard part. The real complexity is app logic: matching a request to a coach by specialty and capacity, honoring the "one open booking per member, released on a timer" rule, and handling per-member time zones cleanly. That logic belongs in Subsystem 4's booking state machine, not in the calendar integration itself.
4 · Preference on hosting and stack? We've assumed Postgres + pgvector.
We agree, and cover it in full in Section 04 — Postgres + pgvector is the right call at this scale rather than running a separate vector database alongside it. On compute, this revision recommends Google Cloud specifically: Cloud SQL for PostgreSQL (pgvector-enabled), Cloud Run for the application and its background workers, and Cloud Storage for everything file-shaped. The reasoning is dependency-driven, not generic cloud preference — Keap aside, every other system this build touches (Meet, Gemini, Calendar, Drive) is already Google Workspace, and the Section 05 notes-ingestion fix already runs on a Google service-account identity. We'd like to confirm this with you in Phase 0 alongside the notes-ingestion validation.
5 · Can this be priced per subsystem so we can sequence the build?
Yes — and it should be, since three of the four subsystems already have complete designs, which lowers estimation risk on those specifically. The previously-deferred member-facing pieces (90-day tracker, onboarding dashboard, in-portal chat, event tickets, support tickets) are better scoped as their own line item once they have a design pass, whether that happens inside this build now or afterward.
6 · What would you recommend building first?
Training Library Search — it's independent of the other three, fully designed, and gives your team (and your membership) a fast, visible win before the harder integration work starts. Core Portal comes next, since Subsystems 3 and 4 both need member records and Keap-driven access to build against. With the launch date now in May 2027, Notes Pipeline and Scheduling can run sequentially rather than in parallel — see the roadmap in Section 11.
7 · What's your estimate for the training library search alone, as a contained first project?
Your own design-side estimate — 2–3 weeks and under $500 in one-time API cost — covers the transcription/embedding pipeline. Building the hybrid-search UI and timestamped playback on top of it is additional engineering time on the same order; a single engineer working through Vimeo pull → Whisper → chunk/embed → search → playback end to end is a reasonable scope for roughly 3–4 weeks. This is a rough order of magnitude, not a firm quote — we'll firm it up once we've scoped it against our actual rate and availability.
8 · Ongoing maintenance and support model?
We recommend a monthly retainer covering three things specifically: pass-through API costs (Whisper, LLM, embeddings), active monitoring of the two most fragile, most novel pieces in this system — the Gemini-notes ingestion pipeline and the scheduling agent — and a defined bug-fix SLA. Those two pipelines depend on external services with no formal API contract (Drive-based notes ingestion, LLM-driven interpretation), so they're the parts most likely to need attention after launch. We'll provide support and training on the app once it's launched, and we're positioned to support any updates after that — see Section 13 for the ongoing partnership model we're proposing.
9 · What do you need from us to give a firm number?
Everything already offered: the full ~7,000-word design spec, the annotated mockups for the five designed screens, the current-state SOPs, sample Gemini note outputs for extraction testing, and discovery access to Keap, Vimeo, and CoachSimple. Add one thing — a short technical discovery session to test-run the Section 05 notes-ingestion approach and confirm Keap webhook access — before firming a fixed number on Subsystems 3 and 4 specifically, since those carry the two non-trivial integrations.
Two constraints from your brief shape this more than anything generic: coaching notes are visible to every coach but never queryable across members (browsable per-member only, since only the training library is meant to be searchable), and nothing in the system is ever deleted — goals and commitments are marked done, in progress, or no longer relevant, and stay in the record permanently.
Members and coaches both need this on a phone — a coach checking a Hot Sheet before walking into a call, a member logging a monthly revenue number between meetings.
| Phase | Approach | What it delivers |
|---|---|---|
| At soft launch | Mobile-first responsive web app, installable as a PWA | Home-screen icon on both iOS and Android, an offline-capable shell, push notifications on Android — full mobile coverage with zero app-store review risk to the launch date. |
| Post-launch | Native wrapper (React Native/Expo or Capacitor) around the same codebase | App Store and Google Play listings, full iOS push notifications, native camera/file access for revenue documentation. With the extended runway, this could also move earlier — we've put that question to you in Section 14. |
Your brief calls the coach dashboard "the highest-stakes screen in the system" — the dense, at-a-glance member snapshot a coach reads in the sixty seconds before a call starts. It already has mockups; our job is to build it exactly as designed and not let scope creep dilute its density.
Per-member snapshot: current goal-cycle status, latest structured notes, revenue trend, open action items and dated commitments, upcoming session — the "walk in prepared" screen the current system can't provide.
Full history per member, browsable, never queryable across the roster — notes, revenue entries, intake form versions, goal history, all append-only.
Visibility into the booking agent's assignments with admin override for every rule it enforces — coach match, one-open-booking limit, timer release.
The one human-approval checkpoint in the system — drafts generated after each call, held for review before sending.
Wins, revenue, action steps, and goals, exportable and joinable against Keap data — the direct fix for "data is not extractable."
Coach-facing views are designed; member-facing views are not — this is the one piece of the "already-designed" subsystems that still needs a design pass before it's built.
Current goal-cycle status, next scheduled session, recent notes summary.
Hybrid search across ten years of Vimeo content, results linking straight into the video at the right timestamp.
Request a session; the scheduling agent matches a coach and confirms — no back-and-forth, one open booking at a time.
Monthly revenue entry, 90-day goal tracking against the member's own history.
Own coaching-call notes and action items — never another member's.
Your launch date has moved from the third week of December 2026 to May 2027 — the runway triples, from about 14 weeks to about 36. Rather than just stretch every phase proportionally, we've put the extra time to use in the two places it matters most: Subsystems 3 and 4 now run sequentially instead of in a shared parallel sprint, and the integration/hardening phase before launch is substantially longer, especially for the scheduling agent, which is the one subsystem shipping with no human approval step. The exact week is still to be finalized with you — the bars below assume the third week of May 2027, mirroring your original "third week" framing, but we'd like to confirm that with you (see Section 14).
Unchanged — no reason to delay this. Validate the Section 05 notes-ingestion pattern against one real call; confirm Keap API/webhook access and rate limits directly; audit the ~500-video Vimeo library for metadata quality; stand up the Cloud SQL/Cloud Run/Cloud Storage foundation from Section 04.
Vimeo bulk pull → Whisper transcription → chunk into passages with timestamps → embed → hybrid keyword + semantic search → results linking into the video at the right moment. Ships standalone — your own brief's "good first deliverable." A week more relaxed than the original estimate, not because the work grew, but because there's no reason to rush a phase this well-scoped.
Keap-tag-driven login and access; the coach dashboard from its existing mockups; the member dashboard, designed fresh in this phase; goal and 90-day cycle tracking with carry-forward; monthly revenue entry; versioned intake forms; the reporting/export layer joinable against Keap data. This is the natural point to decide on the previously-deferred member-facing pieces (90-day visual tracker, onboarding dashboard, chat, tickets) — if you want them in this build, their design pass belongs here, alongside the member dashboard's own design work.
The centralized-organizer ingestion pattern, the structured extraction layer (session focus, strategic direction, action items, dated commitments, flags), auto-publish to the member record, and the accountability-email approval queue. Now standalone rather than sharing a sprint with Scheduling, with slack built in for the holiday period.
The booking agent — request interpretation, coach matching by specialty and capacity, multi-calendar availability, the one-open-booking-at-a-time timer, Google Meet creation, email/SMS confirmations, and admin override for every rule. This is the one subsystem shipping with no human approval step, so it gets a dedicated window rather than sharing time with the notes pipeline — including real slack for adversarial testing, deliberately trying to trigger a double-book or a mismatched coach before real members can.
Full end-to-end testing across all four subsystems together, staff training on the coach dashboard and override tools, a phased internal pilot before the wider soft launch, and — given how much runway this phase now has — room to also harden the scheduling agent against edge cases a tighter timeline wouldn't have allowed time to find.
Released to a pilot group first, with the scheduling agent's admin override live and watched closely through the first bookings.
Expand to all ~150 members once the soft launch holds up under real use. Then, whatever wasn't folded into Phase 2: the native iOS/Android app wrapper, and any of the five previously-deferred member-facing pieces you chose to leave for later.
Six things we'd like to pin down with you: confirming the exact soft-launch week in May 2027, since this plan currently assumes the third week; confirming the Section 05 notes-ingestion pattern actually works end to end on a real call, since the entire notes pipeline depends on it; deciding whether coaches can operate under a centralized Meet-organizer identity or whether domain-wide delegation is required instead; sizing the nightly Keap reconciliation job against real tag-change volume; deciding whether the five previously-deferred member-facing pieces get folded into Phase 2's design pass now that the runway allows it, or stay out for Phase 6 — worth resolving early, since that decision changes Phase 2's scope; and, given Subsystem 4 ships with no human approval step, agreeing on what "ready" looks like for the scheduling agent specifically, since a mistake there reproduces the exact double-booking problem this whole build exists to fix. We've turned these into direct questions for you in Section 14.
Two commitments worth calling out on their own, separate from the build itself.
Before we lock this plan in, here's what we need your team to weigh in on — grouped by topic, not by how urgent each one is. The last six come directly from a second round of admin-tools footage your team shared with us.