Coscholars

Auth, payments, and real-time in one codebase — the heaviest thing I've shipped.

Problem

Tutoring marketplaces break at the seams between their parts. The lesson happens in one tool, the payment in another, the progress record in a third, and nobody's numbers agree. The product had to hold all three at once: a tutor listing a course, a student buying it, the lesson itself, and a record that survived both parties closing the tab.

Constraints

• Two user types, one codebase. Students and tutors needed genuinely different dashboards, not the same page with things hidden.
• Real money. Payments meant tutor payouts, which meant a marketplace payment flow rather than a checkout button — the compliance and failure modes of one are not the other's.
• Internship timeline. A fixed, short window. Scope had to be cut somewhere, and it couldn't be payments.

Approach

One Express application with a role-partitioned interface: separate student and tutor dashboards over a shared session and data layer.

Course creation and purchase flows connect through Stripe Connect, which handles the marketplace half — the platform takes a payment from a student and pays out to a tutor as two sides of one transaction, without the platform ever holding funds it isn't licensed to hold.

1. 1

   Tutor creates a course

   Content, pricing, and availability, stored against the tutor's Connect account.
2. 2

   Student purchases

   Stripe handles the charge; the platform records entitlement, not card data.
3. 3

   Lesson happens in-app

   Chat and video calling, so the lesson never has to move to another tool.
4. 4

   Progress is recorded

   Tracked per student per course, which is what makes a second purchase likely.

Tradeoffs

• In-app video over linking out to Zoom. Keeping the lesson inside the product made the experience whole and made the build significantly heavier. Linking out would have taken an afternoon.
• Stripe Connect over a simple checkout. Far more setup — onboarding flows, account states, payout schedules — bought a marketplace that could actually pay people. A plain checkout would have meant paying tutors by hand.
• EJS and server rendering. Consistent with the team's existing stack and quick to move in, at the cost of a heavier client experience than a React front-end would have given the dashboards.

Outcome

The platform shipped with all four pillars working together: auth, payments, real-time, and progress. It remains the largest surface area I've owned inside a single application, and the first time I built something where a bug had a direct financial cost.

Decisions

• Stripe Connect over holding funds ourselves. Chosen to keep the platform out of the money-handling business entirely. Against it: a much longer integration, and onboarding states that have to be surfaced in the UI rather than hidden.
• One application over splitting student and tutor apps. Chosen for a shared session, shared models, and one deploy. Against it: the codebase carries both roles' logic everywhere, and the routing has to be careful about what each side can reach.
• Building chat and video in-app over integrating a third-party classroom. Chosen because the handoff to an external tool is where marketplaces lose the transaction. Against it: it was the single biggest consumer of the timeline.