PlanetScale for College Students (2026): The Honest Capstone-and-Class-Project Guide

PlanetScale stopped being free in March 2024 when the company sunset its Hobby tier, so if you landed here from a 2023 tutorial promising a no-credit-card MySQL database for your senior capstone, that path no longer exists. The cheapest legitimate way for a college student to use PlanetScale in 2026 is the 14-day Scaler trial that converts to Scaler Pro at $39 per month, and PlanetScale is not part of the GitHub Student Developer Pack. If your budget is genuinely zero, the better fit is Neon Free, Supabase Free, or Turso, each of which is either in the Student Pack or has a no-credit-card free tier that survives the whole semester. This guide walks the full honest decision tree, the actual capstone deploy, and the alternatives.

Fit check at a glance: PlanetScale for college students in 2026

The rest of this page unpacks each row, names every honest tradeoff, and gives you working code, schema, and deploy steps for the path most CS undergrads end up on, which is "I want to ship something portfolio-grade by demo day without going broke."

1. Is PlanetScale free for college students in 2026? The honest answer

No. PlanetScale removed its free Hobby plan on April 8, 2024, after announcing the change on March 6, 2024 in the "PlanetScale Forever" blog post by then-CEO Sam Lambert. Every account on the old free tier was either migrated to a paid Scaler plan or shut down. As of May 2026, there is no longer a free-forever PlanetScale tier of any kind. The lowest-cost path is:

• 14-day free trial of Scaler, which gives you full database functionality with no immediate charge. After 14 days the database moves to Scaler Pro at $39 per month base, plus row-read and storage overage.
• Scaler Pro at $39 per month, billed monthly, no annual lock-in. This is where 95% of small teams and student projects on PlanetScale live in 2026.
• Enterprise at custom pricing, irrelevant to student projects.

If a tutorial published before March 2024 tells you to "sign up for the free PlanetScale Hobby tier and you'll have 5GB storage for life," that tutorial is wrong now. Treat any "free PlanetScale" content older than 2024-04 as stale.

Why does this matter for a class project? Two reasons. First, the 14-day clock starts the moment you provision your database, not when you start using it for real. If you set up early in the semester and don't touch the project for three weeks, your trial converts and you owe $39 before your group has even agreed on the schema. Second, "free trial" plus "$39 after" is a fundamentally different deal from "free forever for hobby use." You need to budget the conversion or kill the database before it converts.

The professor-readiness implication: if your final project URL is a live PlanetScale database and you don't pay the $39 the month grading happens, the URL is dead during demo day. Plan accordingly or pick a free alternative.

2. Does the GitHub Student Developer Pack include PlanetScale? Also no

This is the single most common assumption college students bring to this question, and it is wrong. PlanetScale is not a Student Pack offer. They were never in the Pack. There is no student discount code, no academic email exception, no "register with your .edu address and unlock 12 months" path. We checked the Pack roster on education.github.com/pack as recently as this week. PlanetScale is not listed.

What IS in the GitHub Student Developer Pack as of 2026, in database and database-adjacent categories:

• MongoDB Atlas: extended free credits via Student Pack, on top of the always-free M0 cluster
• DigitalOcean: $200 credit good for 12 months, enough to run a managed Postgres droplet for the academic year
• Neon: Pro plan free for one year via Student Pack (Postgres, branching, generous compute and storage)
• Datastax Astra DB: Cassandra-as-a-service free credits, decent for non-relational projects
• Heroku: credit through GitHub Education (historical; check current status before relying)
• JetBrains All Products Pack: DataGrip free, which is honestly more useful than any single database voucher

If the Student Pack matters to you, the rational play is Neon (closest analog to PlanetScale in branching and developer experience, Postgres-only, free Pro for a year) or MongoDB Atlas (if your project is naturally document-shaped). DigitalOcean's $200 credit can also run a managed Postgres droplet for roughly $15 per month for 13 months without touching real money, which is a flexible alternative if you want full control of the box.

Telling you "use PlanetScale because it's in the Student Pack" is bad advice that propagates because students keep repeating what they read on Reddit threads from 2022. It's not in the Pack. It wasn't in the Pack. Plan around that fact.

3. When PlanetScale is still the right call for a college project

There are three real cases where paying $39 per month for Scaler Pro is worth it for a student, and you should know which one you're in before signing up.

Case A: Resume-portfolio capstone you'll cite at every job interview for the next two years. If your capstone goes on your GitHub portfolio, on your resume, and gets demoed in technical interviews from January through May of graduation year, the database backing it needs to stay alive that whole time. Twelve months of Scaler Pro is $468. Split across a four-person team, that's $117 per person for the year. For a portfolio piece that converts into a job offer at $80K+ base, that math is fine.

Case B: Team of four splitting the bill. Capstone teams are typically three to five students. A $39 monthly bill split four ways is $9.75 each per month, $39 each for a four-month semester. That is in the range of textbook rentals and is below what most students pay for streaming subscriptions. The bill is also predictable, which matters for a team running on a fixed lab budget.

Case C: Project that's actually shipping to real users (a friend's small business, a campus org, a side hustle). If the project will see real traffic past graduation, PlanetScale's schema branching, deploy requests, and Vitess scaling story map directly onto how production teams work. Re-platforming a live app off SQLite or Neon Free at month 18 because you're hitting connection limits is more expensive than starting on Scaler Pro from day one.

Outside those three cases, you should default to a free alternative. The five-most-common student justifications for PlanetScale specifically that are NOT in the above list:

• "Everyone in our class is using Postgres on Vercel and I want something different." Aesthetic. Don't pay $39/mo for aesthetics.
• "I read that PlanetScale is the fastest." For class-scale traffic (your professor opening the URL three times during grading), every option in this guide is fast enough.
• "I want experience with serverless." Neon, Supabase, and Turso are all serverless too.
• "The branching feature looks cool." It is cool. Neon also has branching, and Neon is in the Student Pack.
• "My professor mentioned PlanetScale once." That's not a requirement. Ask if they care about the specific platform or about the architectural patterns.

If you're in Case A, B, or C, the rest of this guide gets you shipped. Otherwise jump to section 6 for the alternative paths.

4. The full single-semester capstone walkthrough on PlanetScale

This section assumes you're shipping a Next.js application with Prisma ORM to Vercel, backed by PlanetScale, because that is the dominant 2026 capstone stack for CS undergrads on the West Coast and increasingly elsewhere. If your stack is different (Rails, Django, Spring Boot, FastAPI), the schema and connection-string concepts translate; the framework-specific files don't.

4.1 Pick your engine: MySQL or Postgres

PlanetScale offers two engines as of 2026: Vitess (MySQL-compatible, the original PlanetScale architecture) and PlanetScale Postgres (Postgres-compatible, GA since 2025). For a capstone:

• Choose MySQL on Vitess if your database systems course is MySQL-specific, if you want Vitess sharding stories on your resume, or if your team already knows MySQL.
• Choose Postgres if your team knows Postgres better, if any extension you need is Postgres-only (PostGIS, pgvector, full-text via tsvector), or if your professor will compare your project to other Postgres-on-Vercel submissions.

For a capstone with the typical "users, posts, comments, tags, audit log" shape, both engines work equivalently. We'll show MySQL syntax below; the Postgres equivalents are noted inline.

4.2 Provision the database

1. Sign up at planetscale.com with a real email (not your .edu if you plan to keep this past graduation, since some universities revoke email post-graduation and you'll lose access to the account).
2. From the dashboard, click "New database." Pick MySQL or Postgres.
3. Choose a region close to where Vercel deploys your app by default (us-east-1 if you're on the East Coast or default Vercel, us-west-2 if your team is on the West Coast).
4. Pick the Scaler trial. Note the trial expiration date in your team's shared calendar.

Within 60 seconds your database is provisioned. The cluster includes one primary plus two replicas across three availability zones. You will never need to touch the replicas for a class project; the architecture is there if you scale.

4.3 Capstone-scale schema (MySQL example)

This is a workable foundation for the "social-feed-with-tags" capstone that 40% of CS senior projects end up resembling. Adapt to your project's domain.

CREATE TABLE users (
  id BIGINT UNSIGNED PRIMARY KEY AUTO_INCREMENT,
  email VARCHAR(255) NOT NULL UNIQUE,
  display_name VARCHAR(100) NOT NULL,
  avatar_url VARCHAR(500) NULL,
  created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
  updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
  INDEX idx_users_email (email)
);

CREATE TABLE posts (
  id BIGINT UNSIGNED PRIMARY KEY AUTO_INCREMENT,
  author_id BIGINT UNSIGNED NOT NULL,
  title VARCHAR(255) NOT NULL,
  body TEXT NOT NULL,
  status ENUM('draft','published','archived') NOT NULL DEFAULT 'draft',
  created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
  updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
  INDEX idx_posts_author_status (author_id, status, created_at)
);

CREATE TABLE comments (
  id BIGINT UNSIGNED PRIMARY KEY AUTO_INCREMENT,
  post_id BIGINT UNSIGNED NOT NULL,
  author_id BIGINT UNSIGNED NOT NULL,
  body TEXT NOT NULL,
  created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
  INDEX idx_comments_post (post_id, created_at)
);

CREATE TABLE tags (
  id BIGINT UNSIGNED PRIMARY KEY AUTO_INCREMENT,
  slug VARCHAR(60) NOT NULL UNIQUE,
  label VARCHAR(80) NOT NULL,
  INDEX idx_tags_slug (slug)
);

CREATE TABLE post_tags (
  post_id BIGINT UNSIGNED NOT NULL,
  tag_id BIGINT UNSIGNED NOT NULL,
  PRIMARY KEY (post_id, tag_id),
  INDEX idx_post_tags_tag (tag_id)
);

CREATE TABLE audit_log (
  id BIGINT UNSIGNED PRIMARY KEY AUTO_INCREMENT,
  actor_id BIGINT UNSIGNED NOT NULL,
  action VARCHAR(50) NOT NULL,
  entity_type VARCHAR(50) NOT NULL,
  entity_id BIGINT UNSIGNED NOT NULL,
  metadata JSON NULL,
  created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
  INDEX idx_audit_actor (actor_id, created_at),
  INDEX idx_audit_entity (entity_type, entity_id, created_at)
);

Note three things your professor will check for:

• Every primary key is a real type (BIGINT UNSIGNED), not VARCHAR or INT. This matters at scale and demonstrates you know the difference.
• Indexes are explicit and named, and the most-queried compound paths (author + status + recency, post + recency, entity-lookup) are covered with composite indexes.
• The audit log uses a JSON column for flexible metadata. Vitess supports JSON; Postgres has the same with JSONB.

On Postgres, swap BIGINT UNSIGNED to BIGINT (Postgres has no unsigned ints), ENUM to a CREATE TYPE ... AS ENUM declaration or a VARCHAR ... CHECK constraint, and ON UPDATE CURRENT_TIMESTAMP becomes a trigger or an explicit updated_at = now() set in your app layer.

4.4 Get the connection string

In the PlanetScale dashboard, click your database, then "Connect." Pick "Prisma" from the framework dropdown. You get a connection string that looks like:

For Postgres, the format is:

Do not commit this string to your repo. Put it in .env.local for local dev and add the same key to Vercel's environment variables for production.

4.5 Wire up Prisma

In your Next.js project:

npm install prisma @prisma/client
npx prisma init

Edit prisma/schema.prisma:

generator client {
  provider = "prisma-client-js"
}

datasource db {
  provider     = "mysql"
  url          = env("DATABASE_URL")
  relationMode = "prisma"
}

model User {
  id           BigInt    @id @default(autoincrement())
  email        String    @unique
  displayName  String    @map("display_name")
  avatarUrl    String?   @map("avatar_url")
  createdAt    DateTime  @default(now()) @map("created_at")
  updatedAt    DateTime  @updatedAt @map("updated_at")
  posts        Post[]
  comments     Comment[]

  @@map("users")
}

model Post {
  id         BigInt    @id @default(autoincrement())
  authorId   BigInt    @map("author_id")
  title      String
  body       String    @db.Text
  status     PostStatus @default(draft)
  createdAt  DateTime  @default(now()) @map("created_at")
  updatedAt  DateTime  @updatedAt @map("updated_at")
  author     User      @relation(fields: [authorId], references: [id])
  comments   Comment[]
  postTags   PostTag[]

  @@index([authorId, status, createdAt])
  @@map("posts")
}

enum PostStatus {
  draft
  published
  archived
}

The critical setting is relationMode = "prisma", which tells Prisma to manage foreign-key relationships in application code rather than rely on database-level constraints. Vitess does not support foreign-key constraints natively, so this setting is required.

Run npx prisma generate to build the client, then npx prisma db push to sync the schema to PlanetScale. The first sync takes about 10 seconds.

4.6 Seed dummy data for demo day

Professors grade demo days. An empty database during a demo looks like an unfinished project. Seed it.

Create prisma/seed.ts:

import { PrismaClient } from '@prisma/client';
const db = new PrismaClient();

async function main() {
  const sarah = await db.user.create({
    data: { email: '[email protected]', displayName: 'Sarah Chen' }
  });
  const marcus = await db.user.create({
    data: { email: '[email protected]', displayName: 'Marcus Diaz' }
  });

  await db.post.create({
    data: {
      authorId: sarah.id,
      title: 'Capstone Update Week 4',
      body: 'Schema is live. Onboarding flow is next.',
      status: 'published',
    }
  });

  await db.post.create({
    data: {
      authorId: marcus.id,
      title: 'Pivot Notes',
      body: 'Switching from infinite scroll to paginated feed.',
      status: 'published',
    }
  });
}

main().finally(() => db.$disconnect());

Run npx tsx prisma/seed.ts. Your demo now has actual content for the screenshots.

4.7 Deploy to Vercel

1. Push your repo to GitHub.
2. Import the repo into Vercel (vercel.com/new).
3. Add DATABASE_URL to Vercel's environment variables, scoped to "Production, Preview, Development."
4. Deploy.

The deploy takes about 90 seconds. You'll get a vercel.app URL that connects to your PlanetScale database. Add that URL to your project README, your demo slides, and your final-report cover sheet.

4.8 Lock the schema before grading week

A week before demo day, branch your schema in PlanetScale ("main" to "demo-lock") and stop pushing schema changes to main. If anything breaks during grading week, you can revert to the demo-lock branch in one click. This is the same workflow real engineering teams use for release freezes. Your professor will recognize it if they've worked in industry.

5. PlanetScale Postgres vs MySQL for a college capstone

The engine choice depends on three things: what your course requires, what your team already knows, and which extensions you need.

Pick MySQL on Vitess if:

• Your database systems course is taught in MySQL and you'll get partial credit for matching course examples.
• You want to put "Vitess" on your resume (it's a noteworthy distributed-systems story).
• Your professor asks for sharding-aware design and you want to demo non-blocking schema changes.
• You're building something compatible with the broader MySQL ecosystem (WordPress, etc.).

Pick Postgres if:

• Your team already knows Postgres and switching would burn week 1 to relearn syntax.
• You need PostGIS for geospatial queries, pgvector for AI/ML capstones, tsvector for full-text search, or any extension MySQL lacks.
• Your professor compares your project to other Postgres-on-Vercel submissions and consistency matters.
• You plan to migrate to a free Postgres tier (Neon, Supabase) after graduation when the bill hits.

For 80% of CS capstones, the choice doesn't materially affect the grade. Pick one and stop debating it in week 2.

6. Free alternatives that survive an entire semester on $0

If you've read everything above and decided $39 per month is real money you don't have, here are the four free paths that actually work for a college project.

6.1 Neon (Postgres, in the GitHub Student Pack)

Neon offers a Postgres free tier with 0.5 GB storage and 191.9 compute hours per month, which is enough for a class project that sees light real traffic. With the GitHub Student Developer Pack, you get Neon Pro free for one year, which lifts storage to 50 GB and adds branching (the headline PlanetScale-style feature). Sign up at neon.tech with your GitHub Student-verified account.

Setup with Prisma is nearly identical to PlanetScale; swap the DATABASE_URL to your Neon connection string and set provider = "postgresql" in schema.prisma. The deploy-to-Vercel path is the same.

Why Neon for students: Postgres is more widely taught than MySQL in 2026 CS curricula, the Student Pack offer is real, and Neon's branching is genuinely useful for a four-person team running parallel features.

6.2 Supabase (Postgres, free tier)

Supabase's free tier gives 500 MB database, 2 GB storage for file uploads, 50,000 monthly active auth users, and 5 GB bandwidth. That is more than enough for a class project. Supabase also bundles row-level security policies, an auto-generated REST and GraphQL API, and a built-in auth UI, which means you can ship "users + sign-in + database" without writing custom auth code.

Why Supabase for students: if your capstone has a sign-in flow (most do), Supabase Auth saves you from rebuilding Clerk or NextAuth from scratch, and it's all free at student scale.

6.3 Turso (libSQL, generous free tier)

Turso is a hosted libSQL (SQLite fork) provider with a free tier that allows 9 GB total storage, 500 databases, 1 billion row reads per month, and 25 million row writes. For a class project, this is more than you'll use in three semesters combined.

Why Turso for students: SQLite syntax is the same SQL you already know, deploys are instant, and if your professor said "show me you understand a relational database" the Turso path is the lowest-friction way to demonstrate that without a credit card.

Setup with Prisma is supported in 2026 via the libSQL driver; check the Turso docs for the current Prisma adapter package.

6.4 MongoDB Atlas (document, Student Pack credits)

If your project is naturally document-shaped (a content management system, a notes app, anything where the schema is genuinely flexible), MongoDB Atlas's M0 cluster is free forever (512 MB, no time limit) and the Student Pack adds credits on top. Mongoose ORM has the same shape as Prisma for the developer.

Why MongoDB Atlas for students: free forever (not a trial), Student Pack adds extra credits, and document modeling is faster to iterate on for projects whose schema is still being defined in week 3.

Free-alternative comparison table

7. Professor-grade-ready demo-day checklist

Capstone projects are graded on the 30 minutes of demo and Q&A, not on the 400 hours of work behind it. The unsexy demo-day prep saves more projects than the technical depth.

One week before demo day:

• Branch your schema in PlanetScale (or pg_dump your Neon/Supabase database) to a labeled snapshot. Treat this as your release lock.
• Run your full test suite. If it fails, you have a week to fix it, not three hours.
• Verify your .env.production variables in Vercel are correct and the production URL serves the seeded data.
• Update your README with one-command setup (npm install && npm run db:push && npm run db:seed && npm run dev) so a fresh-clone evaluator can run your project locally if the cloud URL goes down.
• Pay the next month of PlanetScale Scaler Pro if your trial is converting during grading week. $39 is cheap insurance.

Day before demo:

• Record a 90-second Loom walkthrough of the deployed app showing the core happy path. If the live demo crashes during the actual presentation, you have a backup video.
• Take five high-resolution screenshots of the deployed app and put them in your final report. Visual evidence matters when the URL is dead.
• Test the deployed URL from a network you didn't develop on (a coffee shop, a friend's WiFi). Catches "works on my machine" issues with environment variable scoping.
• Have your team's connection strings backed up somewhere shared and access-controlled (1Password free tier, Bitwarden free tier).

Demo day morning:

• Verify the production URL is live one hour before the demo slot.
• Verify the database is accepting writes by submitting one test record through the deployed app.
• Have your Loom recording open in a browser tab as a fallback.
• Bring a phone hotspot in case venue WiFi fails. CS capstone presentations crash on venue WiFi roughly 15% of the time.

Post-demo, before grading is finalized:

• Keep the database paid for the full week of grading. Professors sometimes return to a URL three days after the presentation for the second look that determines the final letter grade. A dead URL during that second look has dropped projects from A- to B+ in real cases we've seen.
• Push a final README update with "as-shipped" architecture diagram and known limitations. Self-aware self-critique reads as professional maturity.

8. After graduation: from class project to production

If your capstone matters past graduation, the handoff from "class project" to "production system" is its own short list.

• Migrate your DNS off vercel.app and onto a real domain ($10 per year on Namecheap or Cloudflare Registrar at cost).
• Set up basic monitoring. Vercel Analytics free tier shows page views; UptimeRobot free tier pings your site every 5 minutes; Sentry free tier catches errors. Together this is $0 per month and tells you when something is broken.
• Stop seeding from a script and start using deploy requests on PlanetScale, which is the company's name for what other teams call "pull-request-driven schema migrations." Every schema change goes through review before it touches production.
• Set up backups beyond what your provider does automatically. PlanetScale backs up Scaler Pro daily; you should also mysqldump weekly to S3 or local for the case where your provider goes offline.
• Document the runbook for the most-likely breakage (DB connection limit hit, deploy fails, env var rotated by mistake). Your future self will thank you at 2 AM after a friend signs up and breaks something.

The patterns you learn doing this on a small project translate directly into your first engineering job. Internal candidates who shipped a real running service in college walk into senior-junior interviews with a meaningful edge. If you want the deeper version of what production PlanetScale looks like, our PlanetScale best practices guide covers the production-engineering side of the same stack.

Frequently asked questions

Is PlanetScale still free for students in 2026?

No. PlanetScale removed its free Hobby tier on April 8, 2024, after announcing the change on March 6, 2024. As of 2026 the cheapest plan is a 14-day Scaler trial that converts to Scaler Pro at $39 per month. There is no academic discount, no special student tier, and no .edu email path. If you genuinely cannot pay, the working free paths for college students are Neon (Postgres, in the GitHub Student Developer Pack with Pro free for one year), Supabase (Postgres with auth and storage included, generous always-free tier), Turso (libSQL with 9 GB and 1 billion row reads per month), and MongoDB Atlas (free-forever M0 cluster plus Student Pack credits).

Does the GitHub Student Developer Pack include PlanetScale?

No. PlanetScale has never been part of the GitHub Student Developer Pack. The databases in the Pack as of 2026 are Neon (Pro plan free for one year), MongoDB Atlas (extended credits on top of free M0), DigitalOcean ($200 credit good for 12 months, enough to self-host Postgres for the academic year), and Datastax Astra DB (Cassandra credits). If you specifically want a PlanetScale-style developer experience for free as a student, Neon is the closest analog and is in the Pack.

What database should I use for my CS senior capstone?

If your team knows Postgres, use Neon Free or Supabase Free, both of which are in or near the GitHub Student Developer Pack and survive an entire semester on $0. If your course is MySQL-specific, use PlanetScale's 14-day Scaler trial and either pay $39/mo split across the team for the rest of the semester or migrate to a self-hosted MySQL container on Render's free tier. If your project is naturally document-shaped, MongoDB Atlas M0 is free forever and adds Student Pack credits on top. The provider matters less than picking one in week 2 and not switching after week 5.

Can I use PlanetScale Postgres or do I have to use MySQL?

Both engines are available as of 2026. PlanetScale Postgres went GA in 2025 and runs on the same infrastructure as Vitess (locally-attached NVMe, three-AZ replication, automated failover). Pick MySQL on Vitess if your database course is MySQL-specific or you want a Vitess story on your resume. Pick Postgres if your team knows Postgres better or you need a Postgres-only extension like PostGIS, pgvector, or full-text via tsvector.

How do I connect PlanetScale to Vercel for my college project?

Three steps. First, grab the Prisma-formatted connection string from PlanetScale's "Connect" panel (it starts with mysql:// for Vitess or postgresql:// for Postgres). Second, add it to Vercel's environment variables as DATABASE_URL, scoped to Production, Preview, and Development. Third, set relationMode = "prisma" in your schema.prisma so Prisma manages foreign keys in application code rather than at the database level (Vitess doesn't support FK constraints natively). Deploy, and your Vercel app talks to PlanetScale.

Is $39 per month worth it for a class project that ends in May?

Usually no, unless you're splitting the bill across a team or the project is genuinely going past graduation. A four-person capstone team paying $39/mo split four ways is $9.75 each per month, which is below most streaming subscriptions, and gets you a production-grade database with branching and deploy requests. If you're solo and the project ends at the final, use Neon Free or Supabase Free instead. The 14-day trial covers the demo-day week if you time the signup right.

What's the cheapest PlanetScale plan in 2026?

Scaler Pro at $39 per month base, plus row-read and storage overages if you exceed the included usage. The 14-day Scaler trial is technically the cheapest starting point at $0 for two weeks. There is no longer a free Hobby tier. Enterprise pricing exists but is irrelevant to student projects. If $39 is too much, the rational choice is to migrate to a free alternative; the most direct PlanetScale analog for students is Neon Pro free for one year through the GitHub Student Developer Pack.

Can I migrate from PlanetScale to a free alternative if I run out of money?

Yes, and the migration path is well-trodden. For MySQL on Vitess to a self-hosted MySQL or to PlanetScale-compatible alternatives, use mysqldump to export and standard MySQL import to load. For PlanetScale Postgres to Neon or Supabase, use pg_dump and pg_restore. Most ORM layers (Prisma, Drizzle, SQLAlchemy) abstract the connection string, so the application code change is one environment variable. Budget half a day for the migration if you've already shipped the app, longer if your schema uses provider-specific features like Vitess sharding hints. Plan the migration before your bill arrives, not after.

Where to go next

If you've decided PlanetScale is worth the $39/mo for your team, the PlanetScale best practices guide covers the production-engineering patterns you'll handoff to once your capstone goes live. If you want the cheapest DIY learning path before you commit a dollar, learn PlanetScale free walks the trial-plus-local-Vitess route. If a non-engineering teammate is on your capstone (designer, business co-major), our PlanetScale for office workers guide shows the Retool and Glide patterns that let them contribute without writing SQL. For the broader use-cases tree, the use-cases hub lists every persona-specific path we cover.

External authority for the disclosures in this guide: PlanetScale's official "PlanetScale Forever" sunset post (2024-03-06) for the Hobby-tier removal primary source, and the GitHub Student Developer Pack roster for the current list of database vendors offering student discounts. Verify both pages before signup; cloud provider economics shift constantly and what was true at publish may not be true the week your capstone is due.

One last reality check before you sign up

If you remember three things from this guide, make them these. First, the PlanetScale free tier is gone and has been gone since April 2024; do not trust any tutorial that promises otherwise. Second, PlanetScale is not in the GitHub Student Developer Pack and never was; if you specifically want the Pack benefit, use Neon, MongoDB Atlas, or DigitalOcean's credit. Third, the engine and provider matter far less than picking one in week two of the semester and shipping the project. Most failed capstones are not failed because the team chose the wrong database; they are failed because the team spent six weeks comparing databases and never built the application. Pick a path from the comparison table above, follow the seven-step walkthrough in section four, run the demo-day checklist in section seven, and ship. Your professor will grade what is on the screen on demo day. Make sure something is on the screen.