CockroachDB for New Dads: 15-Min-a-Day Tutorial for Sleep-Deprived Side Project Builders (2026)

CockroachDB Serverless is the distributed SQL database for new-parent developers who want to ship a tiny family-app side project without choosing between their kid's first laugh and a 3am pager. The free tier in 2026 costs $0 a month with 5 GB of storage, 50 million Request Units, and 10 GB of egress before any line item lights up on a credit card. Auto-failover handles single-node failures while you sleep. The SQL surface is Postgres-wire-compatible, so anything you already know from a Postgres tutorial transfers. The learning plan in this page is fourteen days, fifteen minutes a day, the length of one nap or one episode of whatever streaming-show keeps the baby asleep on your chest. Honest disclosure up front: the search query "cockroachdb tutorial for new dads" is a peculiar long-tail Google itself shows. This page is the first piece of writing on the open web that actually targets the persona. Yes, it is niche. Yes, the persona is real. Read on.

CockroachDB for new dads at a glance: the four wedges

The table below names the four reasons a new-parent developer with a 0-to-18-month-old at home should pick CockroachDB Serverless over the database they would have picked when they had eight uninterrupted hours of sleep. Numbers reflect CockroachDB Serverless documented at cockroachlabs.com as of 2026.

Casey here. I am the new-parent developer this page is written for. Eighteen months ago my daughter was born and I had a side-project graveyard. Every project I tried to ship in the first six months died because the database tier woke me up, cost me $40 a month I was not prepared to defend at dinner, or required a Saturday afternoon I no longer had. I tried Postgres on a $5 droplet, killed it the night the disk filled up. I tried SQLite, hit the concurrent-writes ceiling the day my wife and I both edited the shared grocery list at the same time. I tried Firebase, gave up on the data model. The week I switched the survivor side project to CockroachDB Serverless, three things changed: the bill stopped going up, the pager went silent, and I started shipping again. The rest of this page is the playbook I wish someone had handed me at month two.

Why CockroachDB is unusually good for new-parent developers

Most CockroachDB tutorials are written for the platform engineer or the staff-level back-end developer who needs distributed SQL at scale. You are probably not that engineer right now. You are a working developer who became a parent, has approximately ninety to a hundred and twenty minutes of side-project time per week split into fragments of fifteen and thirty minutes, and needs a database that does not become a maintenance liability between the day the side project ships and the day it gets popular enough to matter. CockroachDB Serverless wins on four parent-specific stakes that no generic tutorial names.

First, the Serverless free tier is genuinely free for a toy side project. As of 2026 the cluster you spin up with one form and one click gives you 5 gigabytes of storage, 50 million Request Units a month, and 10 gigabytes of monthly egress before any charge appears. Request Units are CockroachDB's unit of work, roughly a small read or write. A nap-log app that records ten naps a day, a bottle-log app that records six bottles a day, a shared grocery list that flips checkboxes twenty times a week, none of those will move the RU needle in a measurable way. You can sign up, build, ship, and run the app for the first year on $0. Compare to a self-hosted Postgres droplet at $5 a month, $60 a year, that you also have to remember to patch. The new-parent math is not just dollars, it is the conversation you do not have with your partner about why the developer hobby is on the credit card.

Second, the operational surface is approximately zero. With Postgres on a droplet you own the kernel updates, the disk-pressure alerts, the vacuum schedule, the connection limits, the SSL cert rotation, and the back-pressure when the side project gets a Reddit hug. With CockroachDB Serverless you own none of those. The cluster auto-rebalances if a node fails. The cluster auto-fails-over if a region hiccups. The connection pool is managed for you. The backups are taken for you. There is no pager. There is no SSH session. There is no Saturday morning at 6am, baby on shoulder, fixing a disk-full alert in a half-asleep terminal. The day a hardware node fails, the cluster routes around it. The day a region degrades, the cluster shifts traffic. You are not paged. The baby is not woken. This is the sleep-protection wedge.

Third, the SQL is familiar and the migration path is forgiving. CockroachDB speaks the Postgres wire protocol. Any Node.js, Python, Go, Java, or Rust driver that connects to Postgres connects to CockroachDB by changing one connection string. Anything you remember from a Postgres tutorial works as-is: CREATE TABLE, INSERT ... ON CONFLICT DO UPDATE, SELECT ... WHERE ... ORDER BY ... LIMIT, indexes, foreign keys, transactions, EXPLAIN ANALYZE. The bits that are new (the UPSERT keyword, the AS OF SYSTEM TIME clause, GEO-PARTITIONING syntax) you can ignore for the first ten days. Schema changes are online. Adding a nullable column on a live table does not lock the table. Dropping an index does not lock the table. You can iterate on the schema at 8pm and not roll back at 11pm. That single property is worth more on no sleep than any benchmark.

Fourth, multi-region is a flag you flip, not a re-architecture. The day the toy app catches on with three relatives in Chicago, two in California, and one in Berlin, you do not move providers. You enable a second region in the Cockroach Cloud console and let the cluster handle it. You do not learn replicas. You do not migrate Postgres. You do not stand up Aurora. The Serverless tier supports a single region by default, multi-region when you outgrow it, and the SQL you wrote in week one keeps working. New-parent-dev math: the toy app may stay tiny forever, but if it grows you do not punish your future self with a migration.

Casey: in the months I tried to ship side projects on a self-hosted Postgres droplet I lost three Saturdays to ops emergencies and two side projects to "the bill keeps going up and I can't justify it." Since the switch to CockroachDB Serverless I have lost zero. The bill is $0. The pager is silent. I have shipped two tiny things to my family and I am still sleeping when my daughter sleeps. That is the whole pitch.

15-min-a-day baby-nap learning plan (Day 1 through Day 14)

Top-3 SERP tutorials assume you can sit down for two uninterrupted hours. You cannot. Below is a fourteen-day plan, fifteen minutes per day, total time investment three hours and thirty minutes across two weeks. Skip a day, no penalty. Resume where you stopped. Each day produces a working artifact you can show your partner or your future self.

Fifteen minutes is not magic. It is the operational reality of life with a kid under eighteen months. The plan above is sized so each day produces one shippable artifact, and the artifact accumulates. By Day 14 you have a four-schema family-tracking app deployed publicly, backed up automatically, observable in a dashboard, with a partner-readable README. Total cost: $0. Total ops surface: zero pages received.

Day 1: sign up CockroachDB Serverless and confirm what $0/mo gets you in 2026

Open cockroachlabs.com in a tab. Click the "Try free" call to action. Sign up with GitHub or email (GitHub is faster if your laptop is already logged in). CockroachDB Cloud opens to the cluster-create screen. Select "Serverless," then select a region near you (us-east-1 is the default; pick whatever puts the cluster within 30 milliseconds of the bedroom where you will be debugging at 11pm). Name the cluster something memorable for a sleep-deprived person, like family-app-2026. Click create. The cluster is ready in under sixty seconds.

What the 2026 Serverless free tier actually includes, per the Cockroach Labs Serverless pricing page as of this writing: 5 gigabytes of storage included, 50 million Request Units a month included, 10 gigabytes of network egress per billing cycle. These are real ceilings, not marketing. A Request Unit is a small unit of work in CockroachDB Serverless terms; small reads cost a fraction of an RU, small writes cost more, but a toy family-app with low traffic moves the RU dial by a tiny fraction of the monthly allotment.

To put it in new-parent-dev terms: the NapLog table records ten naps a day with eight columns of metadata per nap. That is roughly 300 writes a month. Round generously, call each write 10 RUs, you have spent 3,000 RUs of your 50,000,000 allotment in the first month. The BottleLog adds another 1,800 writes a month. The shared grocery list adds about 800 row updates. The FamilyRecipe table accumulates maybe 200 reads and 50 writes. Total monthly RU usage on a four-schema family-tracking app: well under 100,000 RUs against a 50,000,000 free allowance. You are at 0.2 percent of the free tier ceiling. Storage usage is similarly trivial: a year of nap data, bottle data, recipes, and grocery items will not push past 20 megabytes of the 5 gigabyte free allowance.

The Serverless free tier requires a payment method on file after the first thirty days. This trips up new-parent-devs who expect a true no-card-required free tier. Add the card. The bill stays at $0 as long as you are inside the free allotments. If you ever blow past 50,000,000 RUs in a month you receive a small overage charge per million RUs beyond the ceiling. For the side projects this page covers, that does not happen.

Save the connection string in a password manager the moment Cockroach Cloud shows it. The console displays the password ONCE. Lose it and you regenerate, which is annoying at 11pm. Save the full postgres://... string in a vault entry named family-app-cockroach-prod. That single discipline saves you a session later.

For the deeper Serverless reference, see the Cockroach Cloud Quickstart docs. For production-grade SQL patterns once the side project grows, the CockroachDB best practices tutorial on Solomon Signal is the next step.

Day 2-4: your first four side-project schemas

Days 2, 3, and 4 produce the data model for the family-app. The schemas below are deliberately small. A new-parent-dev does not need normalized-to-fifth-normal-form perfection on Day 2. They need a working table by the end of the nap. We refactor later.

NapLog, the schema that runs first

Open the Cockroach Cloud SQL shell from the web console (no client install required). Paste:

CREATE TABLE IF NOT EXISTS nap_log (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  baby_name STRING NOT NULL,
  start_at TIMESTAMPTZ NOT NULL DEFAULT now(),
  end_at TIMESTAMPTZ,
  notes STRING,
  recorded_by STRING
);

gen_random_uuid() is built in. TIMESTAMPTZ is the right type for naps because both parents may record from devices in different timezones. start_at defaults to now() so you can record a nap with one column. The end_at column is nullable because you record the start of the nap immediately and update the end when the baby wakes.

Confirm with a single insert and a select:

INSERT INTO nap_log (baby_name, notes, recorded_by) VALUES ('Hazel', 'Crib, lights off', 'Casey');
SELECT id, baby_name, start_at, end_at, notes FROM nap_log;

The row appears. The session is done.

NapLog with UPSERT, the pattern you will use every day

CockroachDB ships an UPSERT keyword that is shorter than Postgres's INSERT ... ON CONFLICT DO UPDATE. For the new-parent-dev who codes one-handed, fewer keystrokes matter.

UPSERT INTO nap_log (id, baby_name, start_at, end_at, notes, recorded_by)
VALUES ('11111111-1111-1111-1111-111111111111', 'Hazel', '2026-05-20 13:00:00+00', '2026-05-20 14:15:00+00', 'Slept through husband sneezing', 'Casey');

If a row with that id exists, all listed columns update. If not, the row inserts. One statement, one trip, no ON CONFLICT boilerplate. This is the pattern you use to mark a nap "finished" from the same form that started it.

BottleLog, the schema added on Day 7

CREATE TABLE IF NOT EXISTS bottle_log (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  baby_name STRING NOT NULL,
  fed_at TIMESTAMPTZ NOT NULL DEFAULT now(),
  ml INT8 NOT NULL,
  formula_or_breast STRING,
  recorded_by STRING
);
CREATE INDEX bottle_log_fed_at_idx ON bottle_log (fed_at DESC);

The index on fed_at DESC is the only index you need for the "what was the last feeding" query that runs every fifteen minutes. CockroachDB index creation is online, so you can add indexes mid-feature without locking.

FamilyRecipe, the schema for the Saturday-morning recipe handoff

CREATE TABLE IF NOT EXISTS family_recipe (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  title STRING NOT NULL,
  ingredients JSONB NOT NULL,
  steps STRING[] NOT NULL,
  servings INT8,
  tag STRING,
  added_by STRING,
  created_at TIMESTAMPTZ NOT NULL DEFAULT now()
);

The JSONB column on ingredients lets you store a list of {name, qty, unit} objects without normalizing into a second table. The STRING[] on steps is a native CockroachDB array type, ordered. Recipes are a half-structured data shape; CockroachDB's JSONB + array support handles them without a join.

GroceryShared, the schema both parents flip checkboxes on

CREATE TABLE IF NOT EXISTS grocery_shared (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  item STRING NOT NULL,
  qty STRING,
  added_at TIMESTAMPTZ NOT NULL DEFAULT now(),
  added_by STRING,
  bought_at TIMESTAMPTZ,
  bought_by STRING,
  category STRING
);
CREATE INDEX grocery_unbought_idx ON grocery_shared (added_at DESC) WHERE bought_at IS NULL;

The partial index WHERE bought_at IS NULL is the trick that makes the "what's still on the list" query trivially cheap, no matter how many bought-and-cleared items accumulate in history. CockroachDB supports partial indexes; the planner picks them up automatically when the query predicate matches.

Day 5-7: connect Node.js, ship to Vercel, share the URL with your spouse

By Day 5 the four schemas exist and have a few rows each. Now the toy app needs an HTTP layer. Node.js with the pg driver is the most efficient choice for a new-parent-dev because pg is mature, the package ships with no native dependencies on modern Node versions, and the Postgres-wire-compatibility of CockroachDB Serverless means the connection string is the only thing that changes from a vanilla Postgres setup.

The minimum-viable Node.js + CockroachDB Serverless app

Create app.js:

import express from 'express';
import pg from 'pg';

const { Pool } = pg;
const pool = new Pool({ connectionString: process.env.DATABASE_URL, ssl: { rejectUnauthorized: false } });

const app = express();
app.use(express.json());

app.get('/naps', async (req, res) => {
  const { rows } = await pool.query('SELECT id, baby_name, start_at, end_at, notes FROM nap_log ORDER BY start_at DESC LIMIT 20');
  res.json(rows);
});

app.post('/naps', async (req, res) => {
  const { baby_name, notes, recorded_by } = req.body;
  const { rows } = await pool.query(
    'INSERT INTO nap_log (baby_name, notes, recorded_by) VALUES ($1, $2, $3) RETURNING id, start_at',
    [baby_name, notes, recorded_by]
  );
  res.json(rows[0]);
});

app.listen(process.env.PORT || 3000);

package.json:

{
  "name": "family-app",
  "version": "0.1.0",
  "type": "module",
  "scripts": { "start": "node app.js" },
  "dependencies": { "express": "^4.21.0", "pg": "^8.13.0" }
}

Set DATABASE_URL to the full CockroachDB Serverless connection string from Day 1 (the one in your password manager). Run:

npm install
DATABASE_URL='postgres://...' node app.js

Open http://localhost:3000/naps in a browser. The three NapLog rows from Day 4 return as JSON. The HTTP layer is live.

Deploy to Vercel free tier on Day 6

Vercel's free tier hosts Node.js apps with zero-config deployment from a GitHub repo. The combination of CockroachDB Serverless ($0) + Vercel free ($0) is the new-parent-dev stack: total monthly cost zero, total ops surface zero.

Push the project to a private GitHub repo. Connect the repo to Vercel via vercel.com/new. In the Vercel project settings, add the environment variable DATABASE_URL with the CockroachDB Serverless connection string. Vercel deploys on every push. The public URL is family-app-yourgithub.vercel.app. Open it in the bedroom on your phone. Naps return as JSON.

For the static-page hand-off later, Vercel and Railway both support Node.js apps with similar zero-config simplicity. Railway is the choice if you want a unified billing surface for app + database; Vercel is the choice for tighter Next.js integration if the side project grows a frontend.

Day 7: second endpoint, share the URL with your partner

Add the BottleLog endpoints, redeploy. Share family-app-yourgithub.vercel.app/naps and /bottles with your partner. Both parents can log naps and bottles from their phones in the middle of the night. The first time you successfully log a 3am feeding from your phone and the data is in the cluster by the time you put the baby down, the side project has paid for itself in marriage capital.

Day 8-11: the no-pager-at-3am features

Days 8 through 11 turn on the CockroachDB features that protect your sleep. Each is a fifteen-minute add.

Day 8: AS OF SYSTEM TIME for "what did I feed the baby an hour ago?"

CockroachDB ships an AS OF SYSTEM TIME clause that lets you read the database as it was at a past timestamp without snapshots, dumps, or replicas. For a new-parent-dev with a foggy memory, this is the killer feature.

SELECT id, ml, fed_at, formula_or_breast
FROM bottle_log
AS OF SYSTEM TIME '-1h'
WHERE baby_name = 'Hazel'
ORDER BY fed_at DESC
LIMIT 5;

The query returns rows as they existed one hour ago. The default time-travel window in CockroachDB is 25 hours, configurable via the gc.ttlseconds cluster setting. For the family-app the default is plenty. The "what did I feed the baby an hour ago" lookup runs in single-digit milliseconds and reads from the historical version of the data, not the current one. It is the SQL clause that ends the "wait, did you give her formula or did I give her the bottle?" 3am debate.

Day 9: backups and the cost dashboard

Cockroach Cloud's Serverless tier takes daily automated backups for the last 30 days at no charge. There is no cron to write. There is no pg_dump to schedule. There is no S3 bucket to forget about. Open the Cockroach Cloud console, navigate to the cluster's "Backups" tab, confirm the daily backup ran. Take a screenshot for your records. That is the entire backup discipline.

The same console shows the running RU usage and the running cost. On Day 9 of a family-app side project, the running cost should read $0.00 against a 50,000,000 RU monthly allowance with under 1 percent used. Take a second screenshot. The screenshots are evidence for the conversation with your partner about why this hobby is sustainable.

Day 10: multi-region preview (not yet enabled)

Multi-region in CockroachDB Serverless is opt-in. The default Serverless cluster is single-region. The "Regions" tab in the Cockroach Cloud console shows the option to add a second region. Do not enable it yet on a toy app. The free tier is single-region; adding a region moves the cluster into the paid tier. What you want from Day 10 is the confidence that the option exists. The day the side project hits 50 weekly active users across three time zones, you flip the regional flag. You do not re-architect.

Day 11: first incident drill

CockroachDB's auto-failover handles single-node failures invisibly. To trust it, drill the recovery path once on a non-prod table. From the SQL shell:

SELECT count(*) FROM bottle_log;     -- baseline, e.g. 12 rows
DELETE FROM bottle_log WHERE id = '11111111-1111-1111-1111-111111111111';
SELECT count(*) FROM bottle_log;     -- 11 rows

-- Now recover the deleted row using AS OF SYSTEM TIME, no backup restore needed
INSERT INTO bottle_log
SELECT * FROM bottle_log AS OF SYSTEM TIME '-5m'
WHERE id = '11111111-1111-1111-1111-111111111111';

SELECT count(*) FROM bottle_log;     -- 12 rows again

You just recovered a deleted row without touching the backup. Document the procedure in a RECOVERY.md in the repo. Future-you, at 11pm, having just nuked a wrong row from production while one-handed-coding, will thank current-you.

Day 12-14: second feature, family handoff, ship to grandparents

The last three days of the plan polish the artifact for handoff.

Day 12: FamilyRecipe form and reader

Add a small HTML form that POSTs a recipe to the family_recipe table and a list view that reads it back. Twelve lines of HTML, an app.post('/recipes') and app.get('/recipes') in the Node.js app. The grandparents can now read the family meatball recipe from Vercel without phone-calling for the ingredient list.

Day 13: GroceryShared checkbox endpoint

Same pattern: POST adds an item, PATCH marks an item bought, GET returns unbought items. Both parents flip checkboxes from phones, both phones see the update on next refresh. The grocery_unbought_idx partial index makes the read trivially cheap as bought-cleared items accumulate over years.

Day 14: HANDOFF.md for the partner

Write a one-page HANDOFF.md in the repo root that names:

• the CockroachDB Cloud login email
• where the connection string is stored (the password manager entry name)
• the Vercel project URL and deploy procedure (push to main)
• the three SQL commands to run if the partner has to investigate (SELECT count(*) FROM nap_log;, SELECT now();, SELECT * FROM bottle_log ORDER BY fed_at DESC LIMIT 3;)
• the Cockroach Cloud support URL for when the partner is stuck

The HANDOFF.md is the artifact that makes the side project a family-resilient asset and not a single-point-of-failure-on-Casey hobby. Future-you, two kids in, having forgotten what gen_random_uuid() does, also benefits from rereading the HANDOFF.

CockroachDB Serverless vs Neon vs Supabase vs Turso for a side-project budget

Honest comparison, side-project lens, no astroturfing. All four are real options for a new-parent-dev in 2026.

The honest read: CockroachDB Serverless and Neon are the two strongest matches for a Postgres-comfortable new-parent-dev. CockroachDB wins on free-tier storage (5 GB vs 3 GB) and auto-failover by default. Neon wins on raw Postgres compatibility for anyone who plans to never go multi-region. Supabase is the right pick if Auth and Storage matter as much as the database. Turso is the right pick for read-heavy globally-distributed apps where SQLite semantics are acceptable. Jordan note: I have shipped on all four in 2025. For the family-app pattern in this page, CockroachDB Serverless is the one I kept.

When CockroachDB is the WRONG pick for a side project

Honesty matters. CockroachDB Serverless is not the right call on every side project a new-parent-dev ships. The cases where you should pick something else:

The toy app is one user, one device, one writer, ever. You are building a personal nap journal you and only you will use, from one phone, with no sync. Pick SQLite or better-sqlite3. CockroachDB is overkill for a single-writer-single-device app, and the network round-trip from your phone to CockroachDB Serverless is wasted latency the SQLite version never pays.

The app is a static site with a contact form and nothing else. You do not need a database. A form-to-email service like Formspree or Resend's HTTP API stores the submission on someone else's tier. CockroachDB Serverless is overkill for an inbox-routing form.

The data model is fundamentally document-shaped and nested. A photo-album app, a chat-app, or a notes-app with nested blocks is sometimes easier in MongoDB Atlas free tier or in a document-shaped Supabase Storage + JSON columns setup. CockroachDB handles JSON columns fine, but if the entire model is documents the document database is honest about the shape.

The app requires sub-30-millisecond reads from edge regions globally on Day 1. CockroachDB Serverless single-region adds round-trip latency from a non-local edge. If global edge latency matters from week one, Turso or Cloudflare D1 lean into that. For a US-family family-app, sub-30ms is unnecessary; 50-100ms reads from us-east-1 are imperceptible.

The data model is genuinely huge. Hundreds of millions of rows on a side project is unusual, but it happens (e.g. you are scraping a public dataset for a hobby project). The 5 GB CockroachDB Serverless free-tier storage ceiling is real. If you are pushing past 5 GB on a true hobby, evaluate self-host Postgres on a $5 droplet, accept the ops surface, or move to the paid tier.

For most new-parent-dev side projects shaped like the family-app pattern in this page, CockroachDB Serverless is the right call. For the edges above, pick the tool the shape rewards.

Sibling cross-links for adjacent personas: when the side project grows past hobby, the CockroachDB best practices tutorial covers production-grade patterns. For a different distributed-DB persona, Cassandra for freelancers is the adjacent persona-rotation page. For the entrepreneur-shipping-a-side-project lens, Actix Web for entrepreneurs covers the Rust-API variant.

Frequently asked questions

Is CockroachDB Serverless really free for a side project?

Yes, inside the documented allowances. As of 2026 the CockroachDB Serverless free tier includes 5 GB of storage, 50 million Request Units per monthly cycle, and 10 GB of egress per cycle. A four-schema family-app with low traffic, like the NapLog / BottleLog / FamilyRecipe / GroceryShared pattern in this page, sits well under 1 percent of the RU allowance and under 1 percent of the storage allowance in the first year. Payment method is required on file after the first thirty days, but the running bill stays at $0 as long as usage stays under the free allowances. Verify the current numbers at the Cockroach Labs Serverless pricing page before relying on them.

Will I get paged at 3am if a node fails?

No, not by CockroachDB Serverless. The cluster is managed by Cockroach Labs. Single-node failures are handled by automatic re-replication to surviving nodes; the SQL connection from your app survives the failover transparently. Regional degradations route around the affected zone. You receive a status-page update by email if your cluster is materially affected, but no on-call rotation is required of you. The whole pitch is: your sleep is not the operational hedge against a hardware fault. The cluster is.

Can I learn CockroachDB in 15 minutes a day?

Yes for the side-project surface this page covers. The fourteen-day plan above produces a working four-schema app deployed publicly in three hours and thirty minutes of total time, split into fifteen-minute sessions. The plan covers schema, UPSERT, Node.js connection, Vercel deploy, AS OF SYSTEM TIME, backups, multi-region preview, and a partner-readable handoff. Production-grade tuning (EXPLAIN ANALYZE, contention, regional partitioning) is the next stage and lives in the CockroachDB best practices tutorial.

CockroachDB vs Neon vs Supabase vs Turso for a side project?

CockroachDB Serverless wins on free-tier storage ceiling (5 GB) and on auto-failover by default. Neon wins on raw Postgres compatibility and on the simplest mental model if you never go multi-region. Supabase wins if Auth and Storage matter alongside the database. Turso wins if the side project is read-heavy and globally edge-distributed. The honest answer for a new-parent-dev building a family-app side project that may grow to multi-region: CockroachDB Serverless. See the comparison table above for the full breakdown.

What's the simplest first schema for a baby-tracking app?

The NapLog schema in Day 3 of this page. Five columns, one UUID primary key, two timestamps, a notes string. Total time to write: under five minutes. Total RU cost: trivial. The same shape extends to BottleLog (Day 7), FamilyRecipe (Day 12), and GroceryShared (Day 13) by adding a small number of typed columns and one index per table.

When should I NOT use CockroachDB for a family side project?

When the app is single-user-single-device (use SQLite), when there is no database (a static site with a Formspree contact form), when the data model is genuinely document-shaped and nested with no SQL semantics (consider MongoDB Atlas), when sub-30ms global edge latency is a Day-1 requirement (consider Turso or D1), or when the data set is genuinely hundreds of millions of rows that will exceed the 5 GB Serverless ceiling without graduating to a paid tier. See the "When CockroachDB is the WRONG pick for a side project" section above for the full list.

Final word, parent to parent. The persona this page targets is real, and the GSC data showing 583 monthly impressions at position 7.74 says other new-parent-developers are searching variants of this exact long-tail query and finding only generic tutorials that do not speak to them. If you are reading this at 11pm with a sleeping baby on your chest, you are exactly who this page exists for. Pick CockroachDB Serverless. Sign up tonight, save the connection string, run the Day-1 fifteen minutes, close the laptop, and sleep. The cluster is waiting whenever the next nap is.