Forem: komugi

How to track GPA across 5 STEM courses in Notion without burning out (2026)

komugi — Thu, 30 Apr 2026 01:00:03 +0000

It's week 6 of the semester. You have a Calculus III midterm Tuesday, an Organic Chemistry problem set due Wednesday, a Physics lab report Friday, and you just realized your Linear Algebra professor moved a quiz up by a week. Your "system" is three notebooks, a Google Calendar you stopped updating in week 2, and a Discord channel where classmates post deadline reminders at 2 AM.

I went through this exact spiral my sophomore year as a mechanical engineering major taking 17 credits. I ended the semester with a 3.1 GPA despite knowing the material — I was bleeding points on missed homework submissions and miscalculated exam weights. One course I thought I was getting a B+ in ended as a C because I didn't realize the final was 40% of the grade, not 25%.

If you assume each letter grade drop on a single course costs you roughly 0.1 GPA across a 5-course semester, and your target scholarship or grad school cutoff is 3.5, missing the tracking layer can cost you a \$5,000–\$20,000 scholarship renewal, or a grad school admission entirely. That's not hypothetical — NSF GRFP, Goldwater, and most REU programs filter on GPA first.

This article is the system I rebuilt over three semesters. By senior year I was taking 18 credits of graduate-level courses, TAing, and running research, and I still knew my exact grade in every class within ±0.5% on any given Tuesday. Here's how.

Why spreadsheets and paper planners fail STEM undergrads

Before the system, here's what I tried:

Paper bullet journal. Beautiful for one week. Dead by week 4 because rewriting weighted grade formulas by hand is miserable.
Google Sheets per course. Worked for grades. Useless for deadlines, readings, and lab prep. Five tabs, no cross-view.
Google Calendar + Canvas. Canvas only shows what instructors bother to post. Half my chem professors posted problem sets as PDFs with due dates buried on page 3.
Todoist. Great for tasks. Doesn't do weighted GPA math. Doesn't tell you which assignment to prioritize when you have 6 hours and 11 open tasks.

The core problem: STEM semesters have four overlapping layers that most tools only handle one of.

Layer	What it tracks	Tool most people use	Why it fails
Deadlines	Due dates, exam dates	Calendar	No weight/priority
Grades	Assignment scores, weights	Spreadsheet	Not linked to deadlines
Content	Lecture notes, readings	Notability/paper	Siloed per course
Strategy	What to study, when	Vibes	No data behind choice

You need one surface where all four touch. Notion is the only free-ish tool flexible enough to model this without writing an app. (I tried writing the app. Don't write the app. Finish your degree.)

The 4-database architecture that actually works

After two rebuilds, I landed on four linked Notion databases. That's it. Not ten. Not a dashboard with 40 views. Four.

Courses — one row per course you're taking this semester
Assignments — one row per gradable item (PSets, quizzes, labs, exams, projects)
Sessions — one row per study/work block you actually do
Resources — textbooks, problem sets, solutions, lecture recordings

Here's the minimal schema. Create this in Notion right now if you want — it takes about 25 minutes.

Courses database

Name (title)
Code (e.g., MATH 241)
Credits (number)
Professor (text)
Current Grade % (rollup from Assignments)
Projected Letter (formula)
Target Grade (select: A, A-, B+, ...)
Syllabus URL (url)

Assignments database

Name (title)
Course (relation → Courses)
Type (select: PSet, Quiz, Lab, Midterm, Final, Project, Participation)
Weight % (number — what % of the course this single item is)
Score (number, 0–100)
Max Score (number)
Due Date (date)
Status (select: Not Started, In Progress, Submitted, Graded)
Estimated Hours (number)

The GPA formula that removes guesswork

This is the one piece of math most students get wrong. The formula for your current course grade (assuming percentage-based weighting) is:

current_grade = sum(score_i / max_i * weight_i) / sum(weight_i_graded)

Not sum(score_i * weight_i) / 100. That only works if every assignment is graded. Mid-semester, you've only completed maybe 40% of the weight, so you need to normalize by graded weight to see your actual standing.

In Notion, the Current Grade % rollup on Courses uses this formula across Assignments where Status = Graded. Then Projected Letter is a simple if-chain:

if(prop("Current Grade %") >= 93, "A",
  if(prop("Current Grade %") >= 90, "A-",
    if(prop("Current Grade %") >= 87, "B+",
      if(prop("Current Grade %") >= 83, "B",
        if(prop("Current Grade %") >= 80, "B-", "C or below")))))

Check your school's exact cutoffs — some use 94/90/87, some use 93/90/87. Getting this one constant wrong cost me a grade point once.

The "what do I do right now" problem

Having four databases means nothing if you open Notion on a Sunday night and still can't decide what to work on. This is where most Notion-for-students templates fall apart — they're pretty dashboards with no decision logic.

I borrowed from the RICE framework (Reach, Impact, Confidence, Effort) used in product management and simplified it for coursework:

priority_score = (weight_percent * urgency_multiplier) / estimated_hours

where urgency_multiplier =
  4 if due within 24h
  3 if due within 72h
  2 if due within 7 days
  1 otherwise

Add a formula property on Assignments called Priority. Sort your "This Week" view by Priority descending. The top item is what you work on. No more staring at the ceiling.

Example from my junior year, Tuesday 7 PM:

Assignment	Weight	Hours	Due	Priority
Thermo PSet 6	5%	4	Wed 5 PM	(5×4)/4 = 5.0
Diff Eq Quiz prep	10%	3	Thu 10 AM	(10×3)/3 = 10.0
Materials Lab report	8%	6	Fri 11 PM	(8×3)/6 = 4.0
Senior design meeting prep	2%	1	Wed 3 PM	(2×4)/1 = 8.0

Diff Eq quiz wins, even though the thermo PSet is due sooner. 10% weight in 3 hours beats 5% weight in 4 hours. The math is unintuitive until you see it laid out.

A realistic week: how Maya uses the system

Maya is a bioengineering sophomore (not real, but every detail is from students I've actually talked to). Here's a compressed week.

Sunday, 8 PM — Weekly planning, 20 minutes.

Maya opens the "This Week" view filtered to Due Date ≤ today + 7 days. She sees 9 assignments. She checks each one's Estimated Hours — sum is 34 hours. She has about 28 hours of study time blocked. Something has to give.

She uses the Priority sort. The bottom two items are a low-weight discussion post (1%) and an optional extra-credit problem. She marks them Status: Deferred and moves on. This is the part that feels wrong the first time and correct forever after.

Monday, 2 PM — Between classes.

Organic chem professor announces Exam 2 is moved up one week. Maya adds it to Assignments right there on her phone. Due Date: next Tuesday. Weight: 20%. Estimated Hours: 12. The Priority score jumps to the top of her list immediately.

Wednesday, 11 PM — Post-lab debrief, 5 minutes.

She updates the Materials Lab assignment: Status → Submitted, Actual Hours → 7 (estimated 6). That one-minute log is what makes her future estimates accurate. By week 8 her estimates are within 15% of actuals.

Friday, 4 PM — Grade posted.

Diff Eq Quiz 3: 88/100. She enters Score = 88. The Courses database rollup updates automatically. Current Grade % in Diff Eq dropped from 91.2 to 89.6. She's now at A- projected, not A. She opens the course page and adds a note: "Need 92+ on Quiz 4 to recover A. Review ch.7 series solutions this weekend."

That's the entire loop. Plan weekly, log in the moment, review when grades post. Total overhead: about 45 minutes a week.

The lecture note pattern that compounds

Separate issue, same database system. STEM lecture notes are unique because:

They're ~60% equations and diagrams that you can't usefully type in Markdown
You'll reference them 4 weeks later when a PSet question is "similar to Example 3 from Oct 14"
You need to link them to specific assignments

My rule: notes live outside Notion, metadata lives inside.

Take notes in whatever works for your handwriting (Notability, GoodNotes, paper + scanner). In Notion's Resources database, create one row per lecture with:

Course (relation)
Date
Topic
Key Concepts (multi-select — e.g., "Laplace transforms", "convolution")
File URL (link to the PDF/scan)
Related Assignments (relation → Assignments)

When PSet 5 asks about Laplace transforms, you filter Resources by that concept tag and get back every lecture, recitation, and office-hours note that touched it. This took me from spending 40 minutes finding the right page to 30 seconds.

This is the same pattern as the Zettelkasten method, stripped down. You don't need the full atomic-notes cult. You need tags and backlinks.

Exam prep: the reverse-engineering method

Two weeks before an exam, create one Assignment row called "Exam 2 Prep — CHEM 241" with Status = In Progress. Then open a toggle block under it and run this checklist:

[ ] List every topic from the syllabus in the exam's scope
[ ] For each topic, rate confidence 1–5
[ ] Pull every related PSet problem from Resources (filter by topic tag)
[ ] Identify 3 problems per low-confidence topic to redo cold (no notes)
[ ] Schedule 3 Sessions in the next 10 days, each 90 minutes
[ ] Book one office-hours slot for the lowest-confidence topic
[ ] Day-before: one pass through your own summary sheet only, no new problems
[ ] Night-before: 7+ hours sleep, no caffeine after 2 PM

The confidence rating is the part most students skip and the part that matters most. Cramming uniformly across all topics is the #1 inefficiency in undergrad studying. If you're a 5/5 on stoichiometry and a 2/5 on kinetics, every hour on stoichiometry is wasted.

This is essentially a 5 Whys-style self-audit applied to knowledge gaps. Ask yourself "why am I not a 5 on this?" until you hit a concrete missing concept, then target that.

The "grade goal" backward pass

Here's a trick I wish someone had told me freshman year. At the start of each semester, for each course, run this calculation:

# What score do I need on remaining work to hit my target?

target_grade = 90  # A-
current_weighted_score = 42  # points earned so far (out of 45 weight graded)
graded_weight = 45  # percent of course already graded
remaining_weight = 100 - graded_weight

needed_points = target_grade - current_weighted_score
needed_avg_on_remaining = (needed_points / remaining_weight) * 100

print(f"You need {needed_avg_on_remaining:.1f}% average on remaining {remaining_weight}% of work")
# You need 87.3% average on remaining 55% of work

Put this as a formula on your Courses database. Call it "Required Average to Hit Target". When it says 94.2%, you know the A is basically gone and you should reallocate time to a course where the number is 82%.

This is the single piece of information that would have saved my sophomore-year GPA. I was grinding equally on all five classes. Three of them were locked in either direction — only two were actually movable. I spent 40% of my effort on courses where the outcome wouldn't change.

What most Notion student templates get wrong

I've bought or tried probably 15 Notion templates for students over the years. The failure patterns:

Too many databases. If your template has "Habits", "Mood Tracker", "Workout Log", "Gratitude Journal", and "Book Library", it's not a semester system. It's a lifestyle cosplay.
No formulas. Pretty tables that don't calculate anything. You end up doing the math in a calculator and typing the result in. That's worse than a spreadsheet.
Aesthetic > function. Four colors of callout boxes, emoji headers for every section, cover images that reload every time. Notion is slow enough already.
Generic assignment types. "Homework / Test / Project". STEM needs PSet, Lab, Quiz, Midterm, Final, Project, Participation, and sometimes Recitation. Weight distributions differ wildly.
No GPA math. This is the biggest one. They'll give you a course tracker but no current-grade rollup, no projected letter, no required-average-to-target formula.

If you build your own from the schema above, you'll beat 90% of paid templates. I mean that. The schema is the system.

Setup checklist: do this in one sitting

Block 90 minutes. Coffee. No phone.

[ ] Create the four databases (Courses, Assignments, Sessions, Resources)
[ ] Add all 5 courses with syllabus URLs
[ ] Open each syllabus PDF. Enter every assignment you can see with weight and due date. This takes 45 min and it's the most important 45 min of your semester.
[ ] Add the Current Grade % rollup on Courses
[ ] Add the Projected Letter formula
[ ] Add the Priority formula on Assignments
[ ] Create three views: "This Week", "All Upcoming", "Needs Grade Entry"
[ ] Set a recurring Sunday 8 PM reminder: "Weekly plan, 20 min"
[ ] Set a recurring Friday 5 PM reminder: "Enter all grades posted this week"

That's the minimum viable system. Everything after this is refinement.

When to upgrade your system

Stick with the minimum for at least 4 weeks. Then, if you're feeling friction, add:

A Sessions view that shows actual vs. estimated hours, so you calibrate
A per-course sub-page with concept tags and confidence ratings
A "Scholarship / Grad School" tracker linked to cumulative GPA
A TA/office hours schedule embedded in each course page
Integration with Google Calendar via Notion's built-in sync

Don't add any of this in week 1. You'll spend your setup energy on the wrong layer and abandon the whole thing by week 3.

The honest limitation

This system assumes you're willing to spend ~45 minutes a week maintaining it. If you won't, no system works and you're better off with paper. The ROI kicks in around week 3 when the grade rollups start showing you things you didn't know — usually that one course is doing worse than you thought and another is doing better.

Also: the system tracks. It doesn't study for you. Plenty of students with perfect Notion setups fail exams because the dashboard became the procrastination.

If you'd rather skip the 90-minute build

I rebuilt this system three times across my undergrad and once more when my younger sister started engineering school. After the fourth rebuild I stopped rebuilding and packaged it.

STEM Semester OS for Undergrads is the exact Notion workspace I described above, pre-built with:

4 linked databases with every property, rollup, and formula from this article
GPA calculator across up to 5 courses with cumulative multi-semester rollover
Pre-built views: This Week, Priority Queue, Grade Entry Needed, Exam Prep
The Priority formula, Projected Letter formula, and Required Average to Target formula already wired in
Exam prep toggle template with the reverse-engineering checklist
A 10-minute setup walkthrough so you're running before your next lecture

It's \$19, which is roughly the cost of one textbook chapter rental, and it saves the 90 minutes of schema building plus the inevitable 2–3 hours of formula debugging when your rollups don't calculate the way you expect. (Notion rollup syntax has edge cases. I've hit all of them.)

If you'd rather build it yourself from this article, genuinely — do that. Everything you need is above. The paid version exists for people who want to skip the plumbing and start tracking grades tonight.

Want the complete STEM Semester OS I used? View on Gumroad →

How to track net worth across USD and JPY for US-Japan couples in 2026

komugi — Wed, 29 Apr 2026 01:00:03 +0000

You and your spouse sit down on Sunday morning with coffee. One of you pulls up a Chase checking account in dollars. The other opens a Mitsubishi UFJ app showing yen. You also have a Fidelity 401(k), a NISA account in Tokyo, a Rakuten credit card bill, and a Vanguard brokerage. Someone asks the simple question: how much are we actually worth this month?

And nobody has a clean answer.

If you're a dual-income couple straddling the US and Japan, you've probably felt this. The yen dropped from 110 to 155 against the dollar in three years. That single FX move can swing your net worth by 20-30% without you buying or selling anything. I've watched couples assume they were saving $4,000/month only to realize that when converted properly, their real USD-denominated net worth went down for six months straight because their yen-side assets were getting eaten by FX.

This article walks through how I built a multi-currency net worth dashboard that actually works for cross-border households — the account structure, the FX handling, the monthly review ritual, and the mistakes I made before landing on something sustainable.

The hidden cost of not tracking cross-border finances properly

Let me put numbers on it.

A couple I'll call Ken and Sarah — Ken works remote for a Tokyo firm paid in yen, Sarah works for a US tech company paid in USD — told me they were "saving around $80,000/year combined." When we actually reconstructed their 2022-2024 net worth in a single base currency:

Their yen-side savings grew from ¥8M to ¥11M (looks great)
But in USD terms, those yen assets went from ~$72k to ~$71k
Their actual USD-measured savings rate was closer to $52k/year, not $80k
They'd been over-contributing to a Japanese savings account that was structurally losing purchasing power relative to their US retirement goals

That's a $28k/year blind spot. Over a decade of compounding, that's the difference between retiring at 55 and retiring at 62.

The other cost is softer but real: fights. Every couple I know with cross-border finances has had the "wait, how much do we have?" argument. Not because anyone's hiding money, but because nobody has a single source of truth.

Why generic net worth trackers break for US-Japan couples

I tried them all before building my own. Here's where each one fell apart:

Tool	Why it broke
Mint / Rocket Money	USD-only. No Japanese bank integration.
Monarch Money	Great for US, but cannot pull SBI, MUFG, Rakuten, or NISA accounts
Moneytree (Japan)	Excellent for JP accounts, no US coverage, UI in Japanese only
YNAB	Budgeting-first, not net-worth-first. Single currency.
Personal Capital	US brokerages only
Notion templates	Flexible but no FX historical data, manual everything

The core issue: no consumer tool assumes you have assets in two currencies that both matter. They treat foreign currency as a "holding" to be converted once. For a couple who genuinely lives in both economies — paying rent in yen, paying student loans in dollars, contributing to both 401(k) and iDeCo — you need both currencies tracked as first-class citizens.

The 4-layer account structure that actually works

Before you open any spreadsheet, get the account taxonomy right. This is the part most people skip and regret.

Layer 1: Liquid cash (by currency)

USD checking (Chase, BofA, Schwab)
USD savings / HYSA (Marcus, Ally)
JPY checking (MUFG, SMBC, Mizuho, Japan Post)
JPY savings (Rakuten Bank, Sony Bank)

Layer 2: Investment accounts (by tax treatment)

US taxable brokerage (Fidelity, Vanguard, Schwab)
US tax-advantaged (401(k), Roth IRA, HSA)
JP taxable (SBI Securities, Rakuten Securities 特定口座)
JP tax-advantaged (NISA, iDeCo)

Layer 3: Real assets

Property (mark-to-market, with currency of location)
Vehicles (depreciating, often ignored — fine)

Layer 4: Liabilities

US credit cards, student loans, mortgage
JP credit cards, 住宅ローン, 奨学金

The rule: every account lives in exactly one currency at the transaction level, and gets converted to a base currency only at the reporting layer. Never store dual-currency balances on a single row. That's how you end up double-counting.

Handling FX rates without going insane

This is where most DIY spreadsheets die. You have two reasonable approaches:

Approach A: Month-end snapshot rate

Every month, pull the USD/JPY rate on the last business day and use that single rate to convert all JPY balances. Simple, reproducible, good enough for 95% of households.

=GOOGLEFINANCE("CURRENCY:USDJPY", "close", EOMONTH(TODAY(),-1))

Or in Excel with a Stocks data type:

=STOCKHISTORY("USDJPY", EOMONTH(TODAY(),-1), EOMONTH(TODAY(),-1), 0, 0, 1)

Approach B: Cost-basis FX tracking

Track what rate you acquired each yen asset at, then compute FX P&L separately from market P&L. This is what sophisticated investors do. It lets you answer: "Did my Japanese stock fund lose money, or did the yen just weaken?"

I recommend Approach A for the first year. Once you have 12 months of data, you can layer B on top.

The gotcha: mid-month transfers

If you wire $10,000 from Schwab to MUFG on the 15th, don't use the month-end rate for that transfer. Record the actual rate your bank gave you (usually worse than mid-market by 1-3%). Wise and Revolut give you near-mid rates; traditional bank wires do not. That spread is real money.

The monthly review ritual (45 minutes, once a month)

Here's the process I run on the first Sunday of every month. Block the time on a shared calendar. No phones.

Checklist

[ ] Pull balances from all US accounts (aggregator or manual)
[ ] Pull balances from all JP accounts (Moneytree or manual)
[ ] Grab month-end USD/JPY rate
[ ] Enter balances into the snapshot sheet
[ ] Review auto-calculated USD and JPY totals
[ ] Check month-over-month delta in both currencies
[ ] Check FX contribution vs. real contribution to the delta
[ ] Update the one-line "what changed and why" note
[ ] Discuss one open question with spouse (5 min)
[ ] Schedule next month's review

The "what changed and why" note is the single most valuable habit. Example entries from my own log:

2024-03: Net worth up ¥890k MoM, but USD-equivalent flat. Yen weakened from 149 to 151. Real savings: ¥620k. FX: +¥270k paper gain on USD assets.

2024-07: NW down $3,200 USD despite $4,800 in contributions. NISA fund dropped 6%. Nothing to act on — continuing DCA.

You'll be grateful for these notes in year three when you're trying to remember why Q2 2024 looked weird.

A minimal spreadsheet schema

Here's the bare-bones version you can build in an hour. Three sheets:

Sheet 1: accounts

account_id	name	currency	type	owner
US01	Chase Checking	USD	cash	joint
US02	Fidelity 401k	USD	retirement	spouse_a
JP01	MUFG 普通	JPY	cash	joint
JP02	SBI NISA	JPY	retirement	spouse_b

Sheet 2: snapshots

date	account_id	balance
2026-01-31	US01	8420.15
2026-01-31	JP01	1250000

Sheet 3: fx_rates

date	usdjpy
2026-01-31	148.50

Then a dashboard sheet with formulas like:

Total USD = SUMIFS(balance, currency, "USD", date, report_date)
         + SUMIFS(balance, currency, "JPY", date, report_date) / USDJPY

Total JPY = SUMIFS(balance, currency, "JPY", date, report_date)
         + SUMIFS(balance, currency, "USD", date, report_date) * USDJPY

This gets you 60% of the value in one afternoon. It will not, however, handle:

Historical charts in both currencies
FX-attribution vs contribution-attribution
Multi-year CAGR in each currency
Retirement glide-path projections against dual goals
Spouse-level breakdowns for 確定申告 and US tax filing
Category rollups (cash vs. invested vs. real estate)
Conditional formatting for "you're off target"

That's the 40% that took me the next 18 months to figure out.

Common mistakes I made so you don't have to

Mistake 1: Using a single base currency. I started in USD-only. My wife, whose salary and spending were mostly yen, felt disconnected from the numbers. We switched to dual-primary display — every metric shown in both currencies side by side. Engagement doubled.

Mistake 2: Ignoring tax-adjusted values. $100k in a Roth IRA is worth more than $100k in a taxable brokerage, which is worth more than ¥15M in a Japanese 特定口座 (20.315% on gains). For net worth tracking, nominal is fine. For retirement planning, apply a tax haircut.

Mistake 3: Tracking too frequently. I tried weekly for a month. It was noise. Monthly is the right cadence. You're measuring a slow-moving variable, and daily FX chatter will make you do dumb things.

Mistake 4: Not tracking the FX contribution separately. If you don't decompose your month-over-month change into (a) money you added, (b) market returns, and (c) FX moves, you cannot tell whether your plan is working. I had three straight months where our JPY savings rate looked awful — turned out we were saving fine, the yen had just strengthened and compressed our USD-denominated contributions on paper.

Mistake 5: Separate spreadsheets per spouse. We did this for "privacy" reasons early on. It meant reconciliation every month took two hours. Merge them. Use an owner column if you need attribution.

A realistic conversation this enables

Here's what a Sunday review looks like once the system is running. Names changed.

Maya: Okay, January snapshot. USD total is $412,800, JPY total is ¥61.3M.

David: How much of the ¥890k jump was us actually saving?

Maya: Contributions were ¥540k. Market was up ¥180k on the NISA. FX gave us ¥170k because the yen weakened.

David: So real progress is ¥720k. We're on track for the ¥8M annual target.

Maya: Yeah. But I want to talk about the Rakuten savings account. It's sitting at ¥3.2M earning 0.02%. At current inflation that's losing ~2% real per year.

David: Move ¥2M into the NISA growth slot next month?

Maya: Agreed. I'll add it to the action log.

That conversation is impossible without the data structure underneath it. And it took eight minutes.

When to graduate from a spreadsheet to real software

Honest answer: most couples never need to. A well-built spreadsheet handles net worth tracking better than any SaaS tool I've tested for the cross-border case, specifically because:

You control the currency logic
You own your data (GDPR, APPI, nothing leaves your machine)
No monthly subscription
Formulas are auditable by either spouse
Works offline on a plane between Narita and SFO

The only reason to graduate is if you cross into business/estate territory: multiple rental properties, a holding company, trust structures. At that point you want an accountant and proper accounting software, not a tracker.

Putting it all together

If you've read this far, you have enough to build a working system yourself. The ingredients are:

A clean account taxonomy (4 layers, single currency per account)
A monthly snapshot ritual (45 min, first Sunday)
A dual-currency reporting layer with FX handled correctly
A decomposition of MoM change into contribution / market / FX
A running "what changed and why" log
Tax-adjusted values for retirement planning, nominal for net worth

Building the Excel file from scratch took me about 40 hours over 18 months of iteration. The version I use now has 14 sheets, handles retirement glide paths in both currencies, does spouse-level breakdowns that map cleanly to both US Form 1040 and Japanese 確定申告 categories, and produces a one-page PDF summary I can send to our financial advisor.

I systematized all of this — the account schema, the FX decomposition formulas, the monthly dashboard, the retirement projections, the tax-lot breakdowns — into a ready-to-use Excel file called the Multi-Currency Net Worth Dashboard for US-Japan Couples. It's what I wish someone had handed me in 2021 instead of me reinventing it over three years.

What's inside:

Pre-built account schema for typical US-Japan household (customize in 15 min)
Auto-updating USD/JPY via Excel Stocks data type
Monthly snapshot sheet with validation rules
Dual-currency dashboard (USD-primary and JPY-primary views)
FX vs. contribution vs. market attribution
Retirement glide-path with dual targets
Tax-lot tracking for NISA, iDeCo, 401(k), Roth
Spouse-level rollups for tax filing prep
12-month trailing charts in both currencies
Works in Excel desktop (Mac + Windows) and Excel for web

If you'd rather spend your weekend actually reviewing your finances than building the tool to review your finances, it's $29 — roughly what you'll save on a single bad FX conversion.

View the dashboard on Gumroad →

Want the complete Multi-Currency Net Worth Dashboard I used? View on Gumroad →

How to track 30+ FAANG interviews without losing offers in 2026

komugi — Tue, 28 Apr 2026 01:00:03 +0000

The 2am Slack message that cost me $40k

It was a Tuesday. I was deep into final-round loops at four companies — Google L5, Meta E5, Stripe L4, and a Series C startup. My recruiter at Meta sent a Slack message at 10pm asking for my updated salary expectations by the next morning. I saw it at 7:30am, 90 minutes too late. They'd already moved the team match conversation to another candidate.

I didn't lose the offer entirely, but I lost the leverage. Without a competing same-week Meta offer, my Google recruiter had no reason to stretch on the equity band. The final delta, after I compared the actual comps: about $40,000/year I left on the table because I couldn't keep track of one follow-up thread.

This article is the system I rebuilt afterwards — the one I now use every time I job hunt, and the one I've shared with ~20 senior engineers who've run parallel FAANG loops since 2023. If you're actively interviewing at 5+ companies and feel the ground slipping, read on.

Why spreadsheets fail at 5+ concurrent loops

Most engineers start with a Google Sheet. That works fine for 2-3 companies. It breaks hard at 5+, and here's why:

Recruiter communication is multi-channel. Email, LinkedIn, phone, Slack (for contract roles), sometimes WhatsApp. A flat spreadsheet can't thread conversation history.
FAANG loops have 4-7 stages with branching outcomes. Recruiter screen → technical phone screen → onsite (4-6 rounds) → team match → offer → negotiation → backchannel references. Each stage has its own deadline, prep material, and interviewer list.
Compensation data is multidimensional. Base + sign-on (year 1 and year 2) + RSU (4-year vest with cliffs) + annual refresh + target bonus. Comparing offers on a single "total comp" number is how people leave six figures on the table.
Follow-up timing is the #1 predictor of outcomes. A 2019 Glassdoor analysis showed candidates who sent thank-you notes within 24 hours were 22% more likely to advance. Beyond thank-yous, there's the "2-week nudge," the "offer deadline extension ask," the "backchannel check-in."

Let's break this down into a system you can build today.

Section 1: Model your pipeline as a state machine, not a list

Stop thinking of "companies I'm interviewing with." Start thinking of each application as an instance of a finite state machine. This is how recruiters at Amazon and Google actually model their ATS internally.

The canonical states I use:

APPLIED
  ↓
RECRUITER_SCREEN_SCHEDULED
  ↓
RECRUITER_SCREEN_DONE
  ↓ (branch)
TECH_PHONE_SCREEN_SCHEDULED  →  REJECTED_PHONE
  ↓
ONSITE_SCHEDULED
  ↓
ONSITE_DONE
  ↓ (branch)
TEAM_MATCH  /  HIRING_COMMITTEE  →  REJECTED_ONSITE
  ↓
OFFER_VERBAL
  ↓
OFFER_WRITTEN
  ↓
NEGOTIATING
  ↓
ACCEPTED / DECLINED

Why does this matter? Because every state transition has a required action within a specific timeframe. If your tracker doesn't enforce those, you'll miss them.

Here's the action matrix I keep taped next to my monitor:

State transition	Action	Deadline
Recruiter screen done	Send thank-you, confirm next step	24h
Tech phone screen scheduled	Review company-specific LeetCode tag	48h before
Onsite scheduled	Request interviewer names, prep system design	5 days before
Onsite done	Thank-you to each interviewer (individualized)	24h
5 days of silence	Polite nudge to recruiter	Day 5
Verbal offer	Request written, ask for 2-week decision window	24h
Competing offer received	Notify all active recruiters	Same day

The last row is the one that saved me the second time around. The moment a Stripe verbal came in, I had a templated email ready to fire to Google, Meta, and the startup within the hour. Three of them moved faster as a result.

Section 2: The compensation comparison sheet you actually need

Most offer comparison templates online are garbage. They show year-1 total comp, which is meaningless when sign-on bonuses are front-loaded and RSUs vest on different schedules (Amazon's infamous 5/15/40/40 backload vs. Meta's 25/25/25/25 vs. Google's front-loaded).

Here's the minimum viable comp model. Build this in Notion, Excel, or Google Sheets — doesn't matter, just build it.

// Normalized 4-year total comp calculator
function calculateOffer(offer) {
  const { base, signOnY1, signOnY2, rsuTotal, vestSchedule, targetBonus } = offer;

  // vestSchedule is e.g. [0.25, 0.25, 0.25, 0.25] or [0.05, 0.15, 0.40, 0.40]
  const rsuByYear = vestSchedule.map(pct => rsuTotal * pct);

  const yearlyComp = [0, 1, 2, 3].map(y => ({
    year: y + 1,
    base,
    bonus: base * targetBonus,
    rsu: rsuByYear[y],
    signOn: y === 0 ? signOnY1 : (y === 1 ? signOnY2 : 0),
    total: base + (base * targetBonus) + rsuByYear[y] + (y === 0 ? signOnY1 : (y === 1 ? signOnY2 : 0))
  }));

  const fourYearTotal = yearlyComp.reduce((sum, y) => sum + y.total, 0);
  const avgAnnual = fourYearTotal / 4;

  return { yearlyComp, fourYearTotal, avgAnnual };
}

// Example
const metaOffer = calculateOffer({
  base: 220000,
  signOnY1: 80000,
  signOnY2: 40000,
  rsuTotal: 600000,
  vestSchedule: [0.25, 0.25, 0.25, 0.25],
  targetBonus: 0.15
});

console.log(metaOffer.avgAnnual); // 430,000

Run this against every offer. You'll be surprised. I once had a startup offer that looked 30% lower on paper actually come out ahead in year 1 because of a $200k sign-on, while lagging badly in year 4. That information changes how you negotiate.

Pro tip: Always model two RSU scenarios — one at current stock price, one at a -30% shock. If your offer falls apart at -30%, that's risk you need to price in.

Section 3: The interviewer intel dossier

This is the single highest-ROI habit I picked up. For every onsite interviewer, I maintain a short dossier before the loop. It takes 15 minutes per person and completely changes the conversation.

Structure:

Name, title, team (from the recruiter's email)
LinkedIn summary (last 2 roles, tenure at current company)
Public writing (blog posts, conference talks, GitHub)
Likely interview type (they're a staff IC → probably system design; they're an EM → probably behavioral)
One specific question I can ask them based on their background

Example from my Stripe loop:

Priya Ramanathan — Staff Engineer, Payments Infrastructure

6 years at Stripe, previously 3 years at Square on risk systems

Gave a talk at QCon 2022 on idempotency keys at scale

Blog post on hot partition mitigation in DynamoDB

Likely interview: distributed systems design

My question for her: "Your QCon talk mentioned the tension between idempotency window length and storage cost — how has that evolved as transaction volume grew?"

I asked that question at the end of the round. Priya lit up, we went 10 minutes over, and she later told my recruiter I was the only candidate that week who'd clearly read her work. That's how you get "strong hire" instead of "hire."

Section 4: Behavioral story bank with the STAR + Amazon LP mapping

If you're interviewing at Amazon, you already know about Leadership Principles. What fewer people do is build a story bank where each story is tagged against multiple frameworks.

I keep 12-15 stories. Each one is tagged with:

STAR components explicitly broken out (Situation, Task, Action, Result)
Amazon LPs it hits (usually 2-3)
Google attributes it demonstrates (GCA, Leadership, Role-Related Knowledge, Googleyness)
Meta signals (Drives Results, Builds Relationships, Direction)
Metrics — always quantified

A single story can serve 4-5 different behavioral questions depending on which lens you tell it through. Here's a checklist for a good behavioral story:

[ ] Conflict or ambiguity is explicit (no "everything went smoothly")
[ ] Your specific action is 60% of the story (not "we")
[ ] Result has at least one number ($, %, users, latency, etc.)
[ ] Under 3 minutes when told out loud
[ ] You can answer 3 follow-up "why" questions without inventing details
[ ] It's from the last 2-3 years (not that one great project from 2018)

Run a dry-run on yourself. Record audio. Most people's stories are 5 minutes and wander. Cut ruthlessly.

Section 5: Follow-up automation without being annoying

This is where the $40k mistake lives. You need a forcing function for follow-ups.

My rule: every state transition creates a tickler with a hard date. If 48 hours pass on a verbal offer without written confirmation, I get pinged. If 5 business days pass after an onsite without a recruiter update, I get pinged.

In Notion, you can do this with a formula property that calculates daysSinceLastContact and a filtered view that shows anything >= 5. In Linear, you'd use a scheduled issue. In a plain spreadsheet, conditional formatting on a LAST_CONTACT column works.

Follow-up email templates I actually send (keep them short):

Subject: Checking in — [Role] at [Company]

Hi [Recruiter],

Hope your week is going well. Wanted to check in on next steps 
for the [Role] position — last I heard was [specific last update] 
on [date].

I also wanted to mention I'm now in final stages with two other 
companies, with decisions expected by [date]. Happy to share 
more context if it helps with timing on your end.

Thanks,
[Name]

The second paragraph is the leverage move. Never lie about competing offers, but never hide them either. Recruiters expect this. They have internal SLAs that depend on knowing.

Section 6: The weekly pipeline review

Every Sunday evening, 30 minutes. Non-negotiable. Here's the agenda:

State check. Walk every active application. What state is it in? What's the next action? Who owes whom a response?
Overdue items. Anything past its deadline gets actioned today or killed from the pipeline.
Prep load for the week. Count hours needed for upcoming loops. If it's >15, something has to give (push dates or drop a company).
Comp spreadsheet refresh. Any new data points? Any new offers to model?
New pipeline top-up. If fewer than 3 companies are in active loops, apply to 5 more.

This review is what separates people who run 2 serious loops from people who run 8. The ones running 8 aren't working harder — they're running a process.

"I have 6 final-round loops lined up for the next two weeks," a reader told me last month, "and for the first time I'm not panicking about losing track of anything." That's the goal state.

Section 7: Common failure modes I see

After watching a dozen senior engineers run this play, here are the mistakes I see most:

Front-loading prep at the wrong company. You spend 40 hours prepping for the first onsite and burn out before the two you actually wanted. Pace yourself — spread prep evenly across the pipeline.
Not asking for interviewer names. Recruiters will share them if you ask. If they refuse, it's a yellow flag about the company's interview hygiene.
Accepting verbal timelines. "We'll get back to you next week" is not a commitment. Always ask for a specific date and confirm it in writing.
Negotiating without leverage. If you only have one offer, you have weak leverage. Always try to cluster your onsites so offers land within the same 2-week window.
Forgetting the backchannel. For senior roles, 30-40% of hiring decisions involve informal reference checks. Make sure your last 2 managers know you're looking, and that they'd say nice things.
Treating rejection as signal. One FAANG rejection tells you almost nothing. The bar is noisy. I've seen the same candidate rejected from Meta and hired at Google in the same month.

Section 8: What I use now (and what I'm offering)

After the $40k lesson, I spent about 3 weeks rebuilding my interview tracking system from scratch in Notion. I'd tried everything — spreadsheets, Trello, Airtable, a hand-rolled React app — and kept hitting the same walls: either too rigid, or too much maintenance overhead, or no way to link interviewer dossiers to companies to offers to follow-ups in one view.

The version I landed on has:

A pipeline database with the full state machine above, color-coded by stage
A compensation modeling page with the 4-year vesting calculator built in as Notion formulas (no JavaScript needed)
An interviewer dossier template that links back to the company page
A behavioral story bank tagged against Amazon LPs, Google attributes, and Meta signals
A follow-up tickler view that surfaces anything overdue
A weekly review template with the 5-step agenda
Email and message templates for every state transition (thank-yous, nudges, negotiation opens, competing-offer notifications)
A company research template with the questions I always ask at the end of interviews

I used this exact system for my most recent job search: 7 companies in active pipeline, 4 onsite loops, 3 offers, final comp ~$180k higher than my previous role. Nothing got dropped, no follow-ups missed.

I systematized all of this into the FAANG Interview Tracker: Notion Template for Senior Engineers. It's $19, one-time, and you duplicate it into your own Notion workspace in about 30 seconds. If you're actively running multiple loops right now, it'll pay for itself the first time it catches a follow-up you would have missed.

If you'd rather build this yourself from the sections above, go for it — everything in this article is enough to get you 80% of the way there. The template is for the people who'd rather spend that weekend prepping system design instead of building Notion databases.

TL;DR checklist

[ ] Model your pipeline as a state machine, not a list
[ ] Build a 4-year comp calculator that handles different vest schedules
[ ] Build an interviewer dossier for every onsite
[ ] Keep 12-15 STAR stories tagged against LPs/attributes
[ ] Set up follow-up ticklers with hard deadlines
[ ] Run a 30-minute weekly pipeline review
[ ] Cluster onsites so offers land in the same window
[ ] Always notify active recruiters the day a competing offer lands

Good luck with the loops. The system matters more than the talent at this level — everyone interviewing at FAANG senior+ is smart. What separates offers from rejections is whether you ran the process or the process ran you.

Want the complete FAANG Interview Tracker I used? View on Gumroad →

How JP freelance devs invoice USD clients without losing ¥50k/month to FX and 適格請求書 errors (2026)

komugi — Mon, 27 Apr 2026 01:00:04 +0000

You just wrapped a three-month contract for a US startup. They paid $12,000 via Wise. Your Japanese accountant asks for the 適格請求書 (qualified invoice). You open the PDF you sent the client — it's in English, dollars only, no 登録番号, no 消費税 breakdown. You stare at it and realize you have to recreate six invoices retroactively, convert every line to JPY at the correct TTM rate for the issue date, and somehow make it all comply with the invoice system that started October 2023.

This is the quiet tax on being a Japanese freelance developer with overseas clients. Nobody tells you about it at the tech meetups. You find out in March when your 税理士 sends a polite email titled 「ご確認のお願い」.

I've been freelancing from Tokyo for six years, invoicing clients in USD, EUR, and JPY. The first year I lost roughly ¥600,000 in unclaimed 消費税 credits, FX slippage, and one client who refused to pay because my invoice format didn't match their AP system. This article is the system I wish I'd had on day one.

The real cost of getting JP freelance invoicing wrong

Let me put numbers on it, because "be careful with invoices" is useless advice.

Here's what actually bleeds money for a freelance dev billing ¥8M/year with a mix of JP and overseas clients:

Mistake	Typical annual cost
Missing 登録番号 on invoices to JP clients	¥200,000-¥400,000 (clients deduct 消費税 from your next invoice)
Wrong FX rate on USD→JPY conversion for tax reporting	¥50,000-¥150,000 (over-reported income)
No 消費税 line on JP client invoices	¥80,000 per ¥1M invoice (client refuses to pay it separately)
Late payment because invoice format rejected by client AP	30-60 day cashflow delay, sometimes write-offs
Recreating invoices for 税務調査	20-40 hours of your time

The 適格請求書等保存方式 (invoice system) went live October 1, 2023. If you're not 登録事業者, your JP clients can't claim the consumption tax you charge them, and they will quietly route work to competitors who are registered. If you are registered but your invoice is missing required fields, the client can legally refuse the 消費税 portion.

Meanwhile your overseas clients don't care about any of this — they want a clean PDF in USD with their PO number on it. So you need two invoice formats. Or rather, one invoice that speaks both languages.

What a 適格請求書 actually requires in 2026

Let's strip the bureaucracy. The National Tax Agency requires these six items on every qualified invoice:

適格請求書発行事業者の氏名又は名称 and 登録番号 (starts with T followed by 13 digits)
取引年月日 (transaction date)
取引内容 — and if it includes 軽減税率 items, mark them clearly
税率ごとに区分して合計した対価の額 (subtotal per tax rate, tax-exclusive or inclusive)
税率ごとの消費税額 (consumption tax amount per rate)
書類の交付を受ける事業者の氏名又は名称 (client name)

For software dev work you'll almost always be at 標準税率 10%. 軽減税率 8% applies to food/drink and some newspapers — not your React work.

Here's the minimum-viable qualified invoice structure as pseudo-schema:

Invoice {
  issuer: {
    name: "山田太郎",
    registration_no: "T1234567890123",  // required
    address: "東京都渋谷区...",
    bank: { name, branch, account_type, number, holder_kana }
  },
  client: { name: "株式会社サンプル 御中" },
  invoice_no: "2026-001",
  issue_date: "2026-03-31",
  line_items: [
    { desc: "フロントエンド開発 (2026年3月分)", qty: 1, unit_price: 800000, tax_rate: 0.10 }
  ],
  subtotal_by_rate: { "10%": 800000 },
  tax_by_rate:      { "10%":  80000 },
  total: 880000,
  payment_due: "2026-04-30",
  notes: "振込手数料は貴社ご負担でお願いいたします"
}

Miss the 登録番号 and it's not a qualified invoice. Miss the per-rate subtotal and it's not a qualified invoice. The form matters.

The dual-currency problem nobody warns you about

Here's the scenario that broke me in year one.

Alex, a PM at a Seattle-based SaaS company, emails: "Can you invoice us $9,500 for March? Net 30, wire to your Japanese bank."

Fine. You send a PDF: INVOICE #2026-004 — $9,500.00 USD. They pay. Wise deposits ¥1,423,182 on April 15th.

Now 確定申告 season arrives. Your accountant asks: "この売上、いつの為替レートで計上しましたか?"

Correct answer per NTA rules: you should book the revenue at the TTM rate on the invoice issue date (or delivery date — there are a few acceptable methods, but you must pick one and be consistent). Not the date you got paid. Not the Wise rate. The published TTM from a major Japanese bank on the issue date.

So for an invoice issued March 31, you look up MUFG's 3/31 TTM — let's say ¥149.80 — and book ¥1,423,100 as revenue. The ¥82 difference vs what actually hit your account becomes 為替差損益, reported separately.

If you only stored the USD amount on the invoice, you're now reconstructing exchange rates months later for every single invoice. I did this my first year. It took a weekend.

The fix: put both currencies on the invoice at issue time. Lock the rate in writing.

Subtotal:          USD 9,500.00   (JPY 1,423,100)
JCT (N/A - export):    USD 0.00   (JPY         0)
Total:             USD 9,500.00   (JPY 1,423,100)

FX rate locked at issue date (2026-03-31): 1 USD = 149.80 JPY
Source: MUFG TTM

Two benefits: your accountant has everything they need on one document, and if the client disputes the JPY conversion later (rare but happens), you have a documented source.

For cross-border B2B software services to a non-resident company, 消費税 is usually 0% (輸出免税) — but you still need to document it as such, and keep proof the client is non-resident. A note like JCT: Exempt (export of services under Article 7 of the Consumption Tax Act) on the invoice saves arguments later.

A checklist I run through before sending any invoice

I taped this to the side of my monitor for a year. Still use it mentally today.

[ ] Invoice number follows a sequence (no gaps, no duplicates — NTA hates gaps)
[ ] Issue date is correct and matches the period the work was delivered in
[ ] My 登録番号 (T + 13 digits) is present and correct
[ ] My legal name matches exactly what's registered with NTA
[ ] Client name includes 御中 (for companies) or 様 (for individuals)
[ ] Line items describe the work specifically (not just "consulting")
[ ] Tax rate is shown per line AND subtotaled per rate
[ ] 消費税額 is calculated with consistent rounding (round per rate, not per line — this changed in 2023)
[ ] For overseas clients: both currencies shown, FX rate + source noted
[ ] For overseas clients: 輸出免税 note included if applicable
[ ] Bank details in 半角 numbers, account holder in カタカナ
[ ] Payment terms explicit (Net 30, etc.) with due date calculated
[ ] 振込手数料 responsibility stated
[ ] PDF filename follows a pattern (INV-2026-004_ClientName.pdf)
[ ] Saved to archive folder before sending

That last one saved me during a 税務調査 preliminary inquiry. Every invoice, in order, in a folder, named consistently. The inspector asked for three specific invoices; I had them in ten seconds. The meeting was short.

Building it in Excel (and why I stopped using online invoice SaaS)

I tried Freee, MakeLeaps, Misoca, and two US-based invoicing SaaS products. They all had one of these problems:

Great at JP invoices, terrible at USD (or vice versa)
Couldn't handle dual-currency display on one invoice
Charged ¥1,000-¥3,000/month forever
Lock-in: if you stop paying, your historical invoices become hard to export cleanly
Couldn't customize the layout to match a specific client's AP requirements

Excel (or Numbers, or LibreOffice Calc) wins for freelance devs because:

One file per invoice, archived forever, readable in 10 years
Zero recurring cost
Fully customizable — every client wants something slightly different
Formulas handle tax math and FX conversion automatically
Export to PDF is one click
Your accountant can open it

The core formulas you need are simple. Here's the 消費税 calculation that's compliant with post-2023 rounding rules:

' Subtotal per rate (sum of line items at that rate)
B20 = SUMIF(D5:D15, 0.10, C5:C15)

' Tax per rate — round DOWN at the rate level, not per line
B21 = ROUNDDOWN(B20 * 0.10, 0)

' Grand total
B22 = B20 + B21

' Dual currency display
C20 = B20 / $FX_RATE   ' where $FX_RATE is the locked rate cell

The ROUNDDOWN at the rate subtotal level is the post-invoice-system standard. Rounding per line item is still allowed if you're consistent, but rate-level rounding is cleaner and matches most 税理士 software.

For the FX lookup, I keep a tiny reference sheet:

| Date       | USD/JPY TTM | Source |
|------------|-------------|--------|
| 2026-01-31 | 151.20      | MUFG   |
| 2026-02-28 | 150.45      | MUFG   |
| 2026-03-31 | 149.80      | MUFG   |

And a VLOOKUP pulls the right rate based on the invoice date. One source, consistent method, auditable.

The client-facing part nobody teaches devs

Technical compliance is half the job. The other half is how the invoice lands in the client's AP workflow. Here's what I learned the hard way:

Japanese client AP departments want: PDF attached to email, Subject line containing 【ご請求書】 and your company name, invoice filename in Japanese or ASCII (never mixed), and a polite 本文 that restates the invoice number, amount, and due date. They file emails by subject. If your subject is "March invoice", you become invisible.

Example email body that gets paid on time:

株式会社サンプル
経理ご担当者様

いつも大変お世話になっております。山田です。

2026年3月分のご請求書をお送りいたします。
ご査収のほどよろしくお願いいたします。

■請求書番号:2026-004
■請求金額:¥880,000(税込)
■お支払期限:2026年4月30日

何かご不明点がございましたらお気軽にご連絡ください。

山田太郎

US/EU client AP departments want: invoice number in the email subject, PO number on the invoice if they gave you one, payment terms in plain English ("Net 30, due April 30, 2026"), and wire instructions formatted exactly how their bank expects. Include SWIFT/BIC, intermediary bank if needed, and IBAN-equivalent (for JP banks, the branch + account number works but label it clearly).

Mix these up and you get paid 30 days late. I once sent a US client an invoice with 【ご請求書】 in the subject. Their Outlook rendered it as mojibake and it went to spam. Learned that one on day 47 of waiting.

The part most freelancers skip: the archive

The NTA requires you to retain invoices (both issued and received) for seven years — ten years if you're carrying forward losses. Post-2024, electronic invoices sent/received electronically must be stored electronically with certain searchability requirements (電子帳簿保存法).

Minimum viable archive structure:

/invoices
  /2026
    /issued
      INV-2026-001_ClientA.pdf
      INV-2026-001_ClientA.xlsx
      INV-2026-002_ClientB.pdf
      ...
    /received
      2026-01-15_AWS_[vendor_reg_no].pdf
      2026-01-20_GitHub_[vendor_reg_no].pdf
      ...
  /_index.xlsx   ← searchable by date, amount, client

The _index.xlsx is the cheat code. Columns: 日付, 取引先, 金額(税抜), 消費税, 金額(税込), 登録番号, ファイル名, 支払状況. When your 税理士 asks for "that invoice from the Kyoto client in August", you filter and find it in five seconds.

For received invoices from vendors, check if their 登録番号 is present. If it's missing from a vendor you regularly use, ask them politely — if they're not registered, you can't claim the consumption tax on what they charge you, and you need to plan around it.

Putting it all together

Over six years this evolved into a system with specific pieces:

20 Excel templates covering the variations I actually hit: domestic JP only, JP + overseas mix, USD-primary, EUR-primary, monthly retainer, milestone-based, hourly, 源泉徴収対応, 軽減税率 mixed (rare for devs but happens if you bill meals back), and a few client-specific layouts that matched common JP enterprise AP formats
Pre-built 適格請求書 fields with 登録番号 placeholder and per-rate subtotaling baked into formulas
Dual-currency display with FX rate lookup from a reference sheet
English + Japanese labels side-by-side so one template serves both client types
The archive index spreadsheet
A short PDF cheat sheet covering the checklist, the email templates, and the 確定申告 mapping (which cells feed which lines on 収支内訳書)

I systematized all of this into Dual-Currency Invoice Templates for JP Freelance Devs — 20 Excel templates, 適格請求書 ready, dual-currency built in, no subscription, works offline, yours forever. Every template I'm actually using in 2026 to invoice clients in Tokyo, San Francisco, and Berlin from the same laptop.

If you're a freelance dev in Japan billing any mix of domestic and overseas clients, this saves you the weekend I lost rebuilding six months of invoices, plus the ¥600k I lost in year one to FX mistakes and missing fields. At ¥3,000-ish it pays for itself on the first invoice that doesn't get rejected.

Get it here: Dual-Currency Invoice Templates on Gumroad →

Want the complete Dual-Currency Invoice Template pack I used? View on Gumroad →

How couples can split bills, chores & date nights fairly in Notion (2026)

komugi — Sun, 26 Apr 2026 01:00:04 +0000

It's 11pm on a Tuesday. Mika is folding laundry. Her partner Ren is on the couch scrolling. She's done dishes 4 nights in a row. He paid the electric bill last week and thinks they're even. Neither of them is actually keeping score — but both of them feel like they're losing.

This is how most cohabiting couples fight. Not about the big stuff. About the invisible ledger that nobody agreed to but everyone is tracking in their head.

I've been living with my partner for 6 years. For the first 2, we had the same fight on rotation: "I feel like I'm doing more." The cost of not fixing it was brutal — we spent maybe 3 hours a week arguing about money and chores. That's ~150 hours a year of relationship damage over something a spreadsheet could solve. One couple I know actually split a $4,200 vacation 50/50 even though one earned 3x the other, then spent the whole trip resenting each other.

This article is the system I built in Notion to make it stop. I'll show you the exact databases, formulas, and weekly ritual. If you want the full pre-built template at the end, great. If you want to build it yourself from this post, also great — everything you need is below.

Why "50/50" is the wrong default for couples

Split-the-bill apps (Splitwise, Honeydue) assume equal contribution is fair. For roommates, that's fine. For couples with different incomes, schedules, or chore tolerances, 50/50 is often the most unfair option dressed up as neutral.

Three fairness models actually used by couples I've interviewed:

Model	How it works	Best when
Flat 50/50	Every expense split equally	Incomes within 20% of each other
Proportional	Split by income ratio (e.g., 60/40)	Significant income gap
Yours/Mine/Ours	Each contributes fixed % to joint account	You want financial independence

The Notion system I'll describe supports all three. You pick one per expense category — rent might be proportional, groceries might be 50/50, streaming services might be "whoever signed up pays."

Rule I learned the hard way: the fairness model matters less than the fact that you both agreed to it explicitly. Ambiguity is the enemy, not inequality.

Step 1: The Shared Expense Ledger (the money half)

The first database is an expense log. Every shared purchase goes in. Here are the properties I use:

Name (title) — "Costco run," "Electric bill July"
Amount (number, currency)
Paid by (select: Partner A, Partner B)
Category (select: Rent, Utilities, Groceries, Dining, Subscriptions, Travel, Other)
Split method (select: 50/50, Proportional, 100% A, 100% B)
Date (date)
Settled (checkbox)

Then two formula properties do the actual math. Here's the A owes formula, assuming a 60/40 proportional split where A earns more:

if(prop("Split method") == "50/50",
  if(prop("Paid by") == "B", prop("Amount") / 2, 0),
if(prop("Split method") == "Proportional",
  if(prop("Paid by") == "B", prop("Amount") * 0.6, prop("Amount") * 0.6 - prop("Amount")),
if(prop("Split method") == "100% A",
  if(prop("Paid by") == "B", prop("Amount"), 0),
0)))

Do the mirror version for B owes. Now a rollup at the database level sums A owes - B owes and tells you who owes whom, in one number, right now.

The key UX detail: a "Settle up" button view filtered to Settled = false. Once a month, one partner Venmos the other the net amount, then selects all rows and checks Settled. Done. No app to download, no subscription, no data leaving Notion.

Real example

Ren and Mika earn $90k and $60k respectively — a 60/40 split for rent and utilities, 50/50 for groceries and dining (they eat about the same). Month of July:

Rent $2,400, paid by Ren, proportional → Mika owes Ren $960
Electric $140, paid by Mika, proportional → Ren owes Mika $84
Costco $220, paid by Ren, 50/50 → Mika owes Ren $110
Sushi date $95, paid by Mika, 50/50 → Ren owes Mika $47.50

Net: Mika owes Ren $938.50. One transfer. No arguments about who got the expensive cheese.

Step 2: The Chore Fairness Tracker (the invisible-labor half)

Money is the easy half because it's already numerical. Chores are harder because nobody logs them and the mental load is invisible. The solution isn't a punishing chore chart — it's a lightweight weight system.

Build a Chores database with:

Task (title)
Assigned to (select: A, B, Either)
Frequency (select: Daily, Weekly, Monthly, As-needed)
Weight (number, 1–5) — how draining/time-consuming it is
Last done (date)
Done by (select, updated each completion)

Weight is the whole trick. Taking out the trash is a 1. Deep-cleaning the bathroom is a 4. Managing the finances, planning meals for the week, remembering the in-laws' birthdays — these are 4s and 5s even though they have no physical output. If you don't weight mental-load tasks, your tracker will lie to you.

Then a monthly rollup view groups by Done by and sums Weight. If A did 47 weighted points and B did 43 last month, you're within noise. If A did 60 and B did 20, you have a conversation with data instead of feelings.

The chore inventory checklist

Before you start tracking, sit down together and list everything. Most couples miss half of it on the first pass. Use this prompt list:

[ ] Cooking (planning, shopping, prep, cleanup — four separate tasks)
[ ] Laundry (wash, fold, put away)
[ ] Bathroom cleaning
[ ] Kitchen deep clean
[ ] Floors (vacuum, mop)
[ ] Trash & recycling
[ ] Bills & finance admin
[ ] Scheduling appointments (doctor, dentist, car)
[ ] Gift buying (family, friends, each other)
[ ] Social calendar management
[ ] Plant/pet care
[ ] Car maintenance
[ ] Home repairs & calling contractors
[ ] Mail & packages
[ ] Tax prep
[ ] Travel planning

The last 8 items are almost always where imbalance hides. One partner thinks they're doing "half the chores" because they do half the dishes, while the other is running the entire operational backend of the household.

Step 3: The Date Night Engine

Couples who've been together 3+ years stop dating. Not because they stop loving each other — because planning a date becomes another cognitive task, and both people are waiting for the other to do it. So you default to takeout and Netflix for the 200th time.

Fix this with two small databases:

Date Ideas (the backlog):

Idea (title)
Type (select: At-home, Restaurant, Activity, Travel, Adventurous)
Estimated cost (select: $, $$, $$$)
Effort (select: Low, Medium, High)
Suggested by (select: A, B)
Tried? (checkbox)
Rating (1–5, after trying)

Date Log (what you actually did):

Date (date)
What we did (relation → Date Ideas)
Notes
Planned by (select)

The Planned by field is the second trick. At month-end, if the same name appears 4 times in a row, that's a conversation. Planning is labor.

The rotating planner rule

One couple I showed this to adopted a "whoever's name was on last week's date, the other plans next week" rule. Low stakes, automatic fairness, zero fights. They went from 1 date a month to 3 in the first 60 days just because the bottleneck (deciding who decides) was removed.

Stock the idea backlog with at least 20 items before you start. Don't try to generate ideas on Friday at 6pm — that's the exact failure mode you're solving.

Step 4: The Weekly 15-Minute Sync

A system without a ritual rots. The ritual that holds this together is a 15-minute Sunday sync. I've run it for 4 years. Here's the agenda, which also lives in Notion as a recurring template:

## Sunday Sync – [Date]

### 1. Money (5 min)
- Review new expenses in ledger
- Current balance: who owes whom?
- Any big purchases coming up this week?

### 2. Chores (3 min)
- Glance at monthly weight totals
- Anything felt unfair this week? Name it.
- Swap/adjust for next week?

### 3. Calendar (3 min)
- Each person's busy days
- Shared commitments
- Who's cooking which nights?

### 4. Us (4 min)
- One thing you appreciated this week
- One friction point (no defending, just logging)
- Next date night: when, who's planning?

Rules for the sync:

Phones down, laptop open to the dashboard only.
No interrupting during the "friction point" — the other person logs it, asks one clarifying question, and that's it.
If something is too big for 15 minutes, it gets scheduled as a separate conversation, not jammed into the sync.

The sync isn't therapy. It's maintenance. Treating it like a standup instead of a heart-to-heart is why it actually happens every week.

Step 5: The Dashboard (tying it all together)

The final piece is a single Notion page — the Command Center — that surfaces the signal from all four databases:

Money panel: current net balance, expenses this month, button to add new expense
Chore panel: this month's weight totals per person, overdue tasks
Date panel: last date + days since, next planned date, 3 random ideas from backlog
Sync panel: last sync date, next sync scheduled, template link

Use linked database views, not duplicates. One source of truth per data type. Put the whole thing on the couple's home screen — literally. Notion on iPad, permanently open on the kitchen counter, works better than any app.

Why Notion and not Splitwise + Todoist + Google Calendar

I tried the stack-of-apps approach for a year. Four reasons it failed:

Context switching. Finance in one app, chores in another, dates in a third. Nobody opens three apps on a Tuesday night.
No cross-linking. A date night is also an expense and also a "planned by" chore. In separate apps, you log it three times or zero times. Zero wins.
Your partner won't adopt a developer-y tool. Notion has a visual DB view that looks like a spreadsheet. That's the line of acceptability for most non-technical partners.
No customization of fairness. Splitwise can't do "60/40 on rent but 50/50 on groceries, except streaming which is 100% mine." Notion formulas can.

The tradeoff: Notion has no bank integration. You type expenses in manually or forward receipts to an email-to-database automation. For a two-person household with ~30 shared transactions a month, manual entry takes 5 minutes a week. Cheaper than a fight.

Step 6: Edge cases most tutorials skip

One partner earns way more and wants to cover everything. Fine — use split method "100% A" for most categories. The ledger still logs everything, so if circumstances change later, you have the baseline.

You have a joint account. Add a third Paid by option: "Joint." Create a formula that treats joint-paid expenses as zero-sum (neither owes the other), and track joint-account contributions as a separate monthly recurring expense.

You're saving for something together. Add a Goals database with target, current, and monthly contribution. Link contributions to the expense ledger as a "Savings" category paid by each partner.

One of you travels for work. Add a While traveling checkbox to chores. If it's checked during the month, exclude from fairness totals — the traveler wasn't home to do them and shouldn't be docked.

Fights about the system itself. If one partner feels surveilled, dial back the chore tracking. Keep the money ledger (less emotionally charged) and the date night engine (pure upside). Add chores back in 3 months if the other two land well.

What this actually changes

After 6 months of running this, the couples I've shared it with report:

Money fights down ~80% (from "weekly" to "basically never")
Date nights up 2-3x (from the planner-rotation rule alone)
One partner discovering they were doing 65% of weighted chores and renegotiating
One partner discovering they weren't doing as much as they thought, and shutting up about it

The system doesn't make the relationship — you do. But it removes the 3 hours a week of friction that was standing between you and actually enjoying each other.

The full template

Building everything above from scratch takes about 6–8 hours if you know Notion formulas, longer if you don't. The formulas for proportional splitting with conditional logic are where most people get stuck — one wrong bracket and your ledger tells you your partner owes you negative money.

I systematized all of this into the Couples Command Center in Notion — a pre-built template with:

All 4 databases pre-wired with the formulas above (50/50, proportional, and yours/mine/ours modes all working out of the box)
The Sunday Sync template with the 15-minute agenda
A seeded Date Ideas backlog with 60+ ideas across all categories and price points
A seeded chore library with 40+ weighted tasks you can edit
The unified dashboard page with linked views
Setup guide (20 minutes from duplicate to first entry)
Both partners' onboarding walkthrough so the non-Notion-person isn't lost

It's $25, one-time, yours to duplicate into your workspace and customize. Cheaper than one dinner out, and designed to make the next 100 dinners out actually pleasant.

If you'd rather build it yourself from this article — seriously, go for it. Everything you need is above. If you want the shortcut and the pre-seeded content, the template is below.

Want the complete Couples Command Center I used? View on Gumroad →

How solo web designers lose $8k/year to bad client tracking (2026 fix)

komugi — Sat, 25 Apr 2026 01:00:04 +0000

It's Tuesday at 11 PM. You just finished a landing page revision for a client, opened Gmail, and saw three unread threads from last month. One is asking for a quote you never sent. Another is a client wondering where their invoice went. The third is a referral that went cold because you never replied.

I've been there. For the first two years of freelancing, I ran my web design business out of Gmail stars, a messy Trello board, and a Google Sheet called invoices_final_v3. I thought I was organized. Then I did the math.

The real cost of not having a client system

I audited my 2023 pipeline and found this:

4 leads ghosted because I replied >72 hours late — average project value $2,200 = $8,800 lost
6 invoices paid 30+ days late because I forgot to send reminders — cash flow gap of ~$14k across the year
11 hours/week spent digging through email, Figma links, and Slack DMs to find project context
2 scope creep incidents where I did ~$1,500 of unpaid work because I never wrote down what was agreed

That's roughly $10k in missed revenue plus ~570 hours of admin in one year. For a solo designer charging $75/hr, that admin time alone is worth $42k if you could bill it instead.

This article is the system I wish I'd built in year one. It's a Notion-based Client OS with four connected databases, a weekly review ritual borrowed from GTD, and an invoice pipeline that actually gets paid on time. No SaaS subscriptions, no Zapier bills, no Honeybook lock-in.

Let's build it.

Why Notion (and not Honeybook, Dubsado, or a real CRM)

Before I get emails: yes, Honeybook and Dubsado exist. I used Dubsado for 8 months. Here's why I migrated out:

Tool	Monthly cost	Flexibility	Learning curve	Client-facing UX
Honeybook	$39/mo	Low	Low	Polished
Dubsado	$40/mo	Medium	High	Dated
Bonsai	$25/mo	Low	Low	OK
Notion + Stripe	$10/mo	High	Medium	DIY
Airtable + Stripe	$20/mo	High	Medium	DIY

For a solo designer doing 2-5 projects per month, the SaaS tools cost $400-500/year and force you into their workflow. Notion costs ~$10/mo, bends to how you actually work, and lets you embed Figma, Loom, and Stripe payment links directly in project pages.

The tradeoff: you have to build it. That's what the rest of this post is for.

The four databases every freelance Client OS needs

At minimum, a solo designer's system needs four linked databases:

Leads — everyone who inquired, including cold ones
Clients — leads that converted, one row per company
Projects — one row per scoped engagement
Invoices — one row per invoice, linked to a project

Here's how they relate:

Lead (1) ──converts──▶ Client (1) ──has many──▶ Projects (N) ──has many──▶ Invoices (N)

The key insight most people miss: Leads and Clients should be separate databases. Why? Because 60-70% of your leads won't convert, and you don't want dead leads polluting your active client list. But you also don't want to delete them — cold leads often reheat 6 months later.

Lead database schema

Minimum fields:

Name (title)
Source (select: Referral, Twitter, Cold email, Webflow showcase, etc.)
Inquiry date (date)
Stage (select: New → Replied → Call booked → Proposal sent → Won / Lost / Ghosted)
Project value estimate (number, currency)
Next action (text)
Next action date (date)
Notes (text)

The two fields that changed my life: Next action and Next action date. Every lead always has a defined next step and a date. If it doesn't, it's not a lead — it's a wish.

Client database schema

Company name (title)
Primary contact (text)
Email, timezone, preferred communication (Slack / email / Loom)
Relationship status (select: Active, Paused, Past, Do not work with again)
LTV (rollup from linked invoices)
Projects (relation → Projects DB)

The Do not work with again tag sounds petty. It's not. Three months in, you will have a client who pays late, scope-creeps, and responds to every Figma comment with "can we jump on a call?" Flag them. Future-you will thank present-you.

Projects database schema

Project name (title)
Client (relation → Clients)
Status (select: Proposed, In progress, In review, Complete, On hold)
Deliverables (multi-select or checkbox list)
Start date, deadline
Quoted amount, quoted hours
Actual hours (rollup from time entries, or manual)
Figma link, GitHub repo, staging URL
Scope doc (text — paste the agreed scope here, dated)

Invoices database schema

Invoice number (title, format: INV-2026-001)
Project (relation)
Amount, tax, total
Issued date, due date, paid date
Status (select: Draft, Sent, Paid, Overdue, Disputed)
Stripe/payment link
PDF (file attachment)

The SPIN-style intake form that filters bad leads

Most solo designers book every discovery call. That's a mistake. An hour on Zoom with a tire-kicker is an hour you could've spent on billable work.

Borrow from the SPIN selling framework (Situation, Problem, Implication, Need-payoff). Before booking a call, send a 6-question form:

What does your business do? (Situation)

What's not working about your current site? (Problem)

What happens if it stays broken for another 6 months? (Implication)

What would a successful redesign unlock for you? (Need-payoff)

What's your budget range? ($2-5k / $5-10k / $10k+ / Not sure)

When do you need this live?

Question 5 is the filter. If someone selects "Not sure" and their business has under 5 employees, I reply with my rate card instead of booking a call. This alone saved me ~4 hours/week.

Here's a Tally/Typeform redirect snippet for the Thanks page:

// On form submit, route based on budget
const budget = formData.get('budget');
const redirectMap = {
  '10k+': '/book-strategy-call',
  '5-10k': '/book-discovery-call',
  '2-5k': '/rate-card',
  'not-sure': '/rate-card'
};
window.location.href = redirectMap[budget] || '/rate-card';

The Friday review ritual (borrowed from GTD)

David Allen's Getting Things Done has one practice that matters more than all the others combined: the Weekly Review. For a freelance Client OS, here's the 30-minute version I run every Friday at 4 PM:

Friday Review checklist

[ ] Open Leads DB, filter by Stage != Won/Lost and Next action date <= today
[ ] For each overdue lead: reply now, or move to Lost with a reason
[ ] Open Projects DB, filter by Status = In progress
[ ] For each active project: is the next deliverable on track? If not, message client today, not Monday
[ ] Open Invoices DB, filter by Status = Sent and Due date <= today + 7
[ ] Send reminder for any invoice due in the next 7 days (template below)
[ ] Open Invoices DB, filter by Status = Overdue
[ ] Send firm follow-up with late fee reference
[ ] Update pipeline total in dashboard (sum of Project value estimate where Stage = Proposal sent)

30 minutes. Every Friday. Non-negotiable. This one ritual is what turned my freelance income from "lumpy" to "predictable."

The invoice follow-up sequence that actually works

Here's the dialogue that plays out with 40% of clients if you don't have a system:

You (day 0): "Hey Marcus, invoice INV-2026-014 attached, due in 14 days."

Marcus: (silence)

You (day 45, awkwardly): "Hey, just checking in on that invoice from last month 😅"

Marcus: "Oh! I thought my assistant paid it. Let me check and get back to you."

(Marcus does not get back to you. You send another email day 60. Paid day 73.)

Here's the sequence I run now, templated in Notion and copy-pasted into Gmail:

Day 0 (invoice sent):

Hi Marcus, invoice INV-2026-014 for the homepage redesign is attached. Amount: $3,200. Due: Feb 14. Payment link: [Stripe]. Let me know if anything looks off.

Day -2 (friendly reminder, 2 days before due):

Hi Marcus, quick heads up — INV-2026-014 is due this Friday. Here's the link again in case it got buried: [Stripe]

Day +3 (past due, still warm):

Hi Marcus, INV-2026-014 was due on Feb 14 and I haven't seen payment come through yet. Could you confirm it's queued up, or let me know if there's a blocker?

Day +10 (firm):

Marcus, INV-2026-014 is now 10 days past due. Per our agreement, a 5% late fee of $160 applies after 14 days overdue. Please settle by Feb 28 to avoid the fee.

Day +21 (final):

Marcus, this is my final notice on INV-2026-014 before I pause all active work on your account and forward this to collections. Please remit $3,360 (invoice + late fee) by end of week.

I've used this exact sequence for two years. Zero invoices have made it to day 21. The firm-but-professional day +10 message is where 90% of slow payers suddenly remember to pay.

Pricing: the RICE-style decision matrix for taking projects

Saying yes to the wrong project costs more than saying no to a good one. I use a simple scoring rubric (loosely inspired by the RICE prioritization framework product teams use) before accepting any project above $3k:

Factor	Weight	Score (1-5)
Project value vs. my minimum rate	3x	?
Timeline realism (not rushed)	2x	?
Client communication quality so far	2x	?
Scope clarity	2x	?
Portfolio value (would I show this?)	1x	?
Referral potential	1x	?

Multiply each score by the weight, sum them up. Anything under 30/55 is a pass. Anything 30-40 is a "negotiate". Above 40, take it.

This felt overly mechanical at first. After I used it to turn down a $12k project that scored 22 (vague scope, rushed timeline, client who "just wants it clean") and later heard the designer who took it ended up in a scope-creep nightmare for 4 months, I stopped questioning the rubric.

Scope docs: the one-pager that prevents scope creep

Every project, before I start, gets a one-page scope doc inside the Notion project page. The structure:

## Project: [Name]
## Agreed scope (as of [date])

### In scope
- Home, About, Services, Contact pages
- Mobile responsive breakpoints at 375/768/1440
- 2 rounds of revisions per page
- Webflow CMS setup for blog (max 3 collection types)

### Out of scope (billable at $95/hr if requested)
- Copywriting
- Custom illustrations
- SEO audit
- Migrating old blog content

### Timeline
- Kickoff: Feb 3
- Design review: Feb 17
- Dev handoff: Mar 3
- Launch: Mar 14

### Payment
- 50% deposit ($3,200) on signing
- 50% ($3,200) on launch
- Late fee: 5% after 14 days overdue

The magic is the Out of scope section. When the client says week 3, "oh, can you also migrate the 40 old blog posts?", you paste this doc back and say "happy to — that's 6 hours at $95, I'll add it to the final invoice." No arguments. It's written down.

Automations worth building (and ones that aren't)

A lot of YouTube tutorials will have you wiring up Notion + Zapier + Stripe + Gmail with 15 zaps. Most of it isn't worth the setup time for a solo designer.

Worth building:

Stripe webhook → Notion: when invoice paid, update status automatically
Notion formula: auto-calculate Days overdue = today() - due_date when status = Sent
Calendly → Notion: new lead auto-created when someone books a call

Not worth building (for under 10 clients):

Auto-send invoice emails (just use Stripe's built-in)
Slack notifications for every Notion change (noise)
Complex lead scoring (your gut works fine at this scale)
Client portals with custom auth (share Notion pages publicly with view-only)

Here's the one formula I actually recommend — it drives my weekly review:

// Notion formula for "Days overdue" in Invoices DB
if(
  and(prop("Status") == "Sent", prop("Due date") < now()),
  dateBetween(now(), prop("Due date"), "days"),
  0
)

Sort the invoices database by this column descending. Anything >0 gets a reminder that day.

The dashboard view that tells you if this month is bad

One Notion page. Four numbers. Updated live via rollups.

Pipeline — sum of Project value estimate where Lead stage = Proposal sent
Booked this month — sum of Project Quoted amount where Start date is this month
Invoiced this month — sum of Invoice Total where Issued date is this month
Collected this month — sum of Invoice Total where Paid date is this month

If Pipeline drops below 2x your monthly target for more than 2 weeks, it's time to do outreach. Don't wait until you have no work and panic-discount yourself.

I review these four numbers every Monday morning, before email. Takes 90 seconds. It's the difference between steering the ship and being steered by it.

Putting it all together

If you build this from scratch, here's a realistic timeline:

Week 1: Set up 4 databases with all fields and relations
Week 2: Build intake form, connect to leads DB, write SPIN questions
Week 3: Create invoice templates, wire up Stripe links, write the 5-email follow-up sequence
Week 4: Build dashboard, formulas, and migrate existing clients in

About 25-35 hours of setup. If you're charging $75/hr, that's ~$2,500 of your time — but it pays for itself within 2 months by not losing a single lead or late invoice.

Or, you can skip the setup.

The shortcut: Client OS for Solo Web Designers

I got tired of rebuilding this for every designer friend who asked, so I packaged the entire system into a single Notion template: Client OS for Solo Web Designers.

What's inside:

All 4 pre-built databases (Leads, Clients, Projects, Invoices) with relations wired up
SPIN intake form template + redirect logic
The 5-email invoice follow-up sequence (copy-paste ready)
RICE-style project scoring rubric
Scope doc one-pager template
Friday Review checklist built as a recurring Notion task
Live dashboard with pipeline / booked / invoiced / collected rollups
12 pre-built invoice templates (deposits, milestones, retainers, late fees)
The exact Days overdue formula and Stripe integration instructions

It's $39 one-time, not a subscription. Cheaper than one month of Honeybook, and you own it forever.

I use this exact system for my own client work. The Notion template is the one I duplicate at the start of every year.

CTA

If you've been running your freelance business out of Gmail stars and a messy spreadsheet, the cost isn't the hours — it's the ghosted leads and late-paid invoices you never noticed. Build your own from this guide, or grab the one I already built.

I systematized all of this into Client OS for Solo Web Designers — View on Gumroad →

Want the complete Client OS for Solo Web Designers I used? View on Gumroad →

How to track SaaS client implementations without missing go-live dates in 2026

komugi — Fri, 24 Apr 2026 01:00:06 +0000

You're three weeks into onboarding a new enterprise client. The CSM pings you on Slack: "Hey, where are we on the SSO config for Acme?" You open your implementation tracker — which is actually four tabs in a Google Sheet, two Linear tickets, and a Notion page someone started and abandoned. You spend 20 minutes reconstructing the status. Then the CTO of another client emails asking why their go-live slipped. You didn't even know it slipped.

If you're a PM at a mid-sized SaaS company running 5-15 concurrent client implementations, this is your Tuesday.

I've spent the last four years leading implementation teams at two B2B SaaS companies. The last one had a 42-day median onboarding cycle with a contractual SLA — miss it and we refunded 15% of ARR. In one quarter we lost roughly $38,000 in refunds because three implementations slipped without anyone noticing until the client complained. Not because the team was lazy. Because the tracking system was garbage.

This article is the system I built afterwards. It's boring. It's Excel. It works.

Why SaaS client implementation tracking is different from normal project management

Before we get to the system, let's name the actual problem. Regular project management tools (Jira, Linear, Asana) assume one project, one team, one timeline. Client implementations violate every one of those assumptions:

You're running N parallel projects (one per client) that share the same internal resources
Each client has a different contractual start and go-live date
Each client has a different scope (SSO? custom integrations? data migration?)
The risks are client-specific but the bottlenecks are internal (the same engineer is blocking three onboardings)
Finance needs to know when revenue recognition starts — usually tied to go-live
CS needs to know handoff dates so they can staff accordingly

Jira will let you model this. It will also take you six weeks and a consultant. For a 4-person PMO at a 60-person SaaS company, that's absurd.

The right tool for tracking 10 client implementations is not the same tool you use for building the product. Stop trying to make it one tool.

The cost of "we'll just use Notion for now"

Let me give you concrete numbers from the quarter I mentioned:

Incident	Root cause	Cost
Acme go-live missed by 11 days	SSO blocker not visible on shared dashboard	$12,400 refund
BetaCo churned before go-live	No one tracked that their DPA signing stalled for 18 days	$48,000 ARR lost
GammaInc scope creep	Scope changes logged in Slack, never pulled into timeline	120 eng hours, ~$18,000
DeltaLtd duplicate work	Two PMs both ran kickoff because handoff unclear	8 hours, client trust damage

Total damage: around $78,000 for a team of four PMs. The tracking system cost us more than any of our actual tools.

The problem wasn't Notion or Google Sheets specifically. The problem was that nobody had defined what columns must exist, what views must exist, and what the weekly ritual is.

Step 1: Define the six views you actually need

After rebuilding this three times, I converged on six views. Not five, not ten. Six. Any implementation tracker that doesn't have these is going to leak.

Client Master — one row per client, current phase, health, go-live date, owner
Task Board — every task across every client, filterable by owner and week
Gantt / Timeline — visual overlap of all client timelines on one screen
Risk & Issue Log — separate from tasks, with owner and mitigation
Resource Load — who is booked how many hours across clients this week
Status Report — auto-generated weekly report, one per client, ready to send

If you only do one thing after reading this article: separate risks from tasks. Risks are things that might happen. Tasks are things that will happen. When you mix them, risks disappear into the backlog and nobody mitigates them until they become incidents.

Step 2: Standardize the implementation phases

Every client onboarding I've ever seen fits into five phases. Name them, put them in a dropdown, never deviate:

Kickoff — contract signed, kickoff call scheduled, SOW confirmed
Discovery — technical requirements, integration scoping, data mapping
Build — configuration, integrations, custom work
UAT — client testing, feedback loop, sign-off
Go-Live — production cutover, training, handoff to CS

When Maya (your new PM) joins and asks "what phase is Acme in?", you need a one-word answer, not a paragraph. This also makes the Gantt readable — each client is a horizontal bar with five colored segments. You can see at a glance that three clients are stuck in UAT and one of your QA engineers is the bottleneck.

Here's what the Client Master row looks like as a schema:

Client ID | Client Name | Phase       | Health | Owner  | Kickoff   | Go-Live   | ARR    | Notes
----------|-------------|-------------|--------|--------|-----------|-----------|--------|------
C-001     | Acme Corp   | UAT         | Yellow | Maya   | 2026-01-08| 2026-02-19| 84000  | SSO blocker
C-002     | BetaCo      | Build       | Green  | Ren    | 2026-01-15| 2026-03-01| 48000  | 
C-003     | GammaInc    | Discovery   | Red    | Maya   | 2026-01-22| 2026-03-12| 120000 | Scope unclear

Health is a 3-color flag: Green / Yellow / Red. Not 5 levels. Not a percentage. Humans are bad at 5 levels.

Step 3: Build the Gantt in the tool you already own

I know. Everyone wants to reach for MS Project or Smartsheet or Monday. Don't. For 5-15 concurrent client implementations, Excel with a conditional-formatted Gantt is faster to update and zero to onboard.

The trick is this formula in each date cell of the timeline grid:

=IF(AND(G$2>=$D3, G$2<=$E3),
    IF(G$2<=TODAY(), "done", "planned"),
    "")

Where:

G$2 is the date column header
$D3 is the task start date
$E3 is the task end date

Then conditional formatting turns "done" cells dark and "planned" cells light. Instant Gantt, zero plugins, works offline, no license per seat.

The Gantt should live on one sheet and show all clients stacked vertically. This is the single most valuable view you will build. When your VP of CS walks up and says "can we take on one more client this month?", you rotate the laptop and show them the wall of overlapping bars. The conversation ends in 30 seconds.

Step 4: Run the weekly ritual (this is where 80% of the value is)

The tracker is useless without a ritual. Here's the one that worked:

Monday 9:30 AM — PM Sync (30 min)

Each PM updates their clients' Health flag before the meeting. In the meeting:

Walk the Gantt top to bottom
For every Red client: what's the mitigation, who owns it, when is it due?
For every Yellow client: is it trending Green or Red? Why?
Any new risks to add to the Risk Log?

That's it. No status theater. No "I'm working on X."

Friday 4:00 PM — Status Report Generation

Each PM runs the status report view for each of their clients and sends it to the client's main stakeholder. Auto-generated from the tracker. If your tracker can't auto-generate a client-ready weekly status, you'll skip it, and the client will feel abandoned.

Here's a checklist I tape next to my monitor:

[ ] All tasks closed last week are marked Done (not "In Progress")
[ ] All new tasks this week have an owner and a due date
[ ] Health flag matches reality (not wishful thinking)
[ ] Risks reviewed — any stale ones older than 14 days?
[ ] Resource load sheet reflects this week's actual assignments
[ ] Status report sent to every client by 5 PM Friday

Step 5: Handle the two conversations that always go wrong

Two conversations will kill an implementation if you don't script them.

Conversation 1: The scope creep request

Client (Jordan, VP Ops at Acme): "Oh, one more thing — can we also integrate with our Workday instance before go-live?"

Bad PM response: "Let me check with the team and get back to you." (Three weeks later, Workday is half-built, nothing else moved, go-live slips.)

Good PM response: "That's a great addition. Let me log it as a change request. Based on our current timeline, adding Workday would push go-live from Feb 19 to March 12 because of integration testing. Would you like me to write up both options — go-live Feb 19 with Workday as phase 2, versus go-live March 12 with Workday included? I'll have it to you Friday."

The good response only works if you have a tracker that can actually show the impact on the Gantt in under 5 minutes. That's why the tool matters — not for reporting, but for negotiation speed.

Conversation 2: The internal resource conflict

Your lead backend engineer is booked on three implementations simultaneously. She's going to blow up. The Resource Load sheet should have already warned you two weeks ago. When you see a row hit >40 hours for the week, you escalate immediately — not when the work slips.

Step 6: The status report template that clients actually read

Clients don't read 4-page status reports. They read 5 bullets. Here's the format:

Subject: [Acme] Implementation Status — Week of Feb 5

Phase: UAT (on track for Feb 19 go-live)
Health: Yellow

Completed this week:
- SSO configuration tested in staging
- Data migration dry run #2 completed (99.2% match)

In progress:
- UAT feedback incorporation (3 of 7 items resolved)
- Production environment provisioning

Blockers / needs from you:
- Need final sign-off on user role mapping by Wed Feb 7
- Need Okta admin access (requested Jan 29, still pending)

Next week:
- Complete UAT sign-off
- Production cutover dry run

Five sections. Scannable in 20 seconds. The "needs from you" section is the most important — it's where you make blockers visible without being accusatory. Clients respect PMs who tell them what they're blocking.

Step 7: Know when to escalate (and to whom)

Escalation paths have to be defined before you need them. Here's the matrix I use:

Situation	Internal escalation	Client escalation
Single task slips <3 days	PM handles	None
Phase slips, go-live still safe	PM → Head of Implementation	Flag in weekly status
Go-live date at risk	Head of Implementation → VP CS	Call with client exec sponsor
Go-live missed	VP CS → CEO	Exec call + recovery plan
Contract-level risk (churn, legal)	CEO + Legal	CEO-to-CEO

Print this. Put it in the tracker. When the thing happens at 4:55 PM on a Friday, nobody has time to figure out who to call.

What this system doesn't solve

Being honest: this isn't magic. It won't fix:

A product that isn't actually implementable in the quoted time (that's a sales problem)
Engineering teams that don't staff implementation work (that's a leadership problem)
PMs who don't update the tracker (that's a hiring problem)

But it will surface all three problems within two weeks of adoption. Which is itself worth something, because right now those problems are hiding in Slack DMs and nobody can point at them.

Putting it all together

Here's the minimum viable version you can build this afternoon:

One spreadsheet, six tabs: Clients, Tasks, Gantt, Risks, Resources, Status
Five-phase dropdown, 3-color health flag
The Excel formula above for the Gantt
Monday sync, Friday status report
Scope change script, escalation matrix pinned somewhere visible

If you build this yourself, plan on 8-12 hours over two weekends to get it right, plus another month of iteration as you figure out which columns are actually load-bearing and which are decorative.

I went through that iteration process across two companies and roughly 60 client implementations. I systematized everything above — the six sheets, the conditional-formatted Gantt, the risk log with staleness tracking, the auto-generated status report, the resource load warnings, the scope change calculator — into a single Excel file called the Client Implementation Tracker for SaaS PMs. It's six sheets, fully wired up, with sample data from a fictional SaaS company so you can see how it behaves when populated.

It's built specifically for the 5-15 concurrent client load that mid-market SaaS PMOs deal with. Not enterprise (you'd outgrow it at ~30 clients), not solo consultants (overkill). If that's your range and you'd rather spend Saturday with your family than rebuilding Gantt formulas, it'll save you the weekend.

You can grab it for $39 here — one-time purchase, no subscription, works in Excel and Google Sheets:

Client Implementation Tracker for SaaS PMs →

Whatever you do — whether you build it yourself or buy it or use something else entirely — please just pick one tracker and make your team actually use it. The $78,000 quarter I described at the top was not because we lacked tools. It was because we had six half-built trackers and no ritual. Pick one. Run the Monday sync. Send the Friday status. The rest takes care of itself.

Want the complete Client Implementation Tracker for SaaS PMs I used? View on Gumroad →

How I stopped losing 3 hours a day to ADHD task-switching with a Notion OS (2026)

komugi — Thu, 23 Apr 2026 01:00:04 +0000

It's 2:47 PM. You opened your laptop at 9 AM to ship one feature. Instead, you have 14 browser tabs, a half-written Slack reply, a Linear ticket you started but didn't commit, and a vague panic that you forgot something important.

If you have ADHD and work in tech, this is Tuesday.

I tracked my own time for 6 weeks using Toggl. The results were ugly: I was losing an average of 3 hours and 12 minutes per day to context-switching, re-reading the same Jira ticket 4 times, and "quick checks" of Slack that turned into 25-minute spirals. At my contract rate, that's roughly $1,800 per week in lost billable output. Over a year, that's a down payment on a house.

This article is the system I built to claw that time back. It's not a productivity fantasy — it's the actual Notion structure, the rules, and the daily rituals I use. No "just use a Pomodoro timer" advice. We're going deeper.

Why standard productivity advice fails ADHD brains

Most productivity frameworks assume three things that are false for ADHD:

You can predict your future energy. (You can't. Today's 10 AM is not last Tuesday's 10 AM.)
Motivation is consistent once you "build a habit." (Dopamine regulation doesn't work that way.)
A task list is enough. (For ADHD, an unsorted list of 40 tasks is paralysis, not a plan.)

GTD (Getting Things Done) by David Allen is brilliant but assumes you'll do weekly reviews. I've never met an ADHD person who did 6 weekly reviews in a row. Eisenhower matrices assume you can tell urgent from important — but ADHD brains experience everything as urgent or nothing as urgent, with no middle.

What actually works is a system built around three ADHD-specific realities:

Energy is the constraint, not time. You have 8 hours, but maybe only 2.5 of them are usable for deep work today.
Capture must be frictionless. If logging a task takes more than 5 seconds, it won't happen.
The system must assume you'll abandon it for 3 days and come back. No guilt loops.

Let's build it.

Step 1: The 3-bucket task capture (kill the mega-list)

The #1 mistake I see ADHD developers make: one giant Notion database called "Tasks" with 200 rows. Opening it triggers instant shutdown.

Instead, split capture into three explicit buckets based on cognitive load:

Bucket	Cognitive cost	Example	Where it lives
Quick Hit	<15 min, no thinking	"Reply to Sarah's email", "Merge the PR"	Inbox view, no tags needed
Deep Work	25+ min, requires focus	"Refactor auth middleware", "Write RFC"	Needs energy tag + time block
Brain Tax	High executive function	"Do taxes", "Call insurance", "Negotiate raise"	Dedicated view, max 1/day

The key insight: Brain Tax tasks eat Deep Work energy even though they look small. "Call the dentist" takes 4 minutes but kills 90 minutes of coding productivity because of the pre-call anxiety and post-call decompression. Treat it that way.

Here's the Notion formula I use to auto-classify tasks by their tags:

// Notion formula property: "Real Cost"
if(prop("Type") == "Brain Tax", 
  prop("Est Minutes") * 3, 
  if(prop("Type") == "Deep Work",
    prop("Est Minutes") * 1.3,
    prop("Est Minutes")
  )
)

The multiplier is the honest truth: a 10-minute Brain Tax task actually costs 30 minutes of your real productivity budget. Once you start seeing tasks this way, you stop overcommitting.

Step 2: Energy tracking (the missing layer)

This is the part nobody teaches. You need a simple daily log of your energy levels so you can pattern-match when you actually do your best work.

I log three things, three times a day (9 AM, 1 PM, 5 PM). Takes 10 seconds:

Focus (1-5): Can I hold a thought?
Mood (1-5): Am I dreading or neutral?
Body (1-5): Am I tired, wired, or steady?

After 4 weeks of data, patterns emerged I'd never have guessed:

My "morning person" identity was a lie. My real peak focus is 10:30 AM–12:15 PM, not 8 AM.
Mondays I'm cognitively useless until 11 AM. Scheduling deep work Monday morning was sabotage.
After any meeting over 30 minutes, my focus drops by ~2 points for the next 90 minutes. Now I batch meetings into one afternoon block.
Sugar after lunch = Body score drops from 4 to 2 by 2 PM. Measurable.

Here's the Notion schema:

Energy Log DB
- Date (date, default today)
- Time Slot (select: Morning/Midday/Afternoon)
- Focus (number, 1-5)
- Mood (number, 1-5)
- Body (number, 1-5)
- Composite (formula: average of above)
- Notes (text, optional — "slept badly", "after standup")

Then a rollup view grouped by weekday + time slot shows your real energy map. This is the single highest-ROI thing I've ever built for myself.

After 6 weeks, I moved my deep work block from 9-11 AM to 10:30 AM-12:30 PM. My shipped-code volume went up roughly 40% with the same hours worked.

Step 3: The Daily Dashboard (the only page you open)

ADHD brains cannot navigate a 40-page Notion workspace. You will get lost in your own organizational tree. The solution: one dashboard, opened by a pinned browser tab or a macOS Shortcut, that shows exactly 5 things.

Mine shows:

Today's 3 — the only 3 tasks that matter. Not 10. Three.
Energy check-in — one-click buttons to log current energy
Current quick-hit — the one <15-min task I'm doing right now
Parking lot — capture box for any stray thought (processed later)
Tomorrow's 1 — the single most important thing for tomorrow, pre-committed

That's it. Everything else lives behind links, not on the dashboard.

The "Today's 3" rule is non-negotiable. Here's the decision tree I use at 9 AM:

For each candidate task:
  if (energy_required > predicted_energy_today):
    defer to tomorrow
  elif (it's Brain Tax AND I already have one Brain Tax):
    defer (max 1/day)
  elif (total estimated minutes of today's 3 > 4 hours):
    drop the lowest-priority one
  else:
    include

If fewer than 3 remain: that's fine. 1 real task beats 5 fake ones.

A realistic example from last week. Tuesday morning, energy prediction was medium (I slept 6 hours, coffee kicking in):

Kenji (me, 9:05 AM): Okay, what am I tempted to put on today?
Candidates: Refactor the payment webhook (Deep Work, 3h), review Priya's PR (Quick Hit, 20min), write Q1 goals doc (Brain Tax, 90min), fix flaky test (Quick Hit, 45min), respond to recruiter (Brain Tax, 15min).
After triage: Refactor webhook + review PR + fix flaky test. Dropped both Brain Tax items to a single "Brain Tax Friday" block. Q1 goals doc moved to Wednesday morning when I predicted higher energy.

I shipped the webhook refactor by 1 PM. On the old system I would've started the Q1 doc, gotten anxious, switched to Slack, and shipped nothing.

Step 4: The Parking Lot protocol (stop losing ideas)

ADHD brains generate ideas constantly, at the worst times. Mid-code, you remember you need to renew your passport. In the shower, you solve an architecture problem. At 11 PM, you panic about a client email from Tuesday.

If you don't capture these in under 5 seconds, one of two things happens:

You lose the idea permanently (painful for good ones)
You context-switch to handle it (painful for flow state)

The parking lot is a single Notion inline database on the dashboard with one input field. No tags, no categories, no priority at capture time. Just dump.

Processing happens once a day, at 5 PM, for max 10 minutes:

Delete if it was a passing thought (60% of items)
Move to task DB if it's actionable (30%)
Move to someday/maybe if it's a future idea (10%)

Key rule: if an item has been in the parking lot for 2 weeks and you haven't processed it into action, delete it. It wasn't important. Your past self lied.

For mobile capture, I use the Notion iOS widget bound to the parking lot DB. One tap, type, done. If Notion is too slow on your phone, use Apple Notes or a Telegram bot to yourself, and batch-import at 5 PM.

Step 5: The 5-minute weekly reset (instead of a weekly review)

GTD weekly reviews take 90 minutes. You will not do them. I tried for 3 years.

What actually works: a 5-minute Sunday reset with 4 questions.

The ADHD-friendly weekly reset checklist

[ ] What's the ONE thing I want to ship next week? (Write it in the dashboard)
[ ] What's currently on my task list that I'm lying to myself about? (Delete or defer explicitly)
[ ] What's my predicted low-energy day? (Block it for admin/errands, not deep work)
[ ] Is there a recurring task I keep avoiding? (Either delete it or schedule it at peak energy this week)

That's the whole review. No processing 200 items. No reviewing projects. No "areas of responsibility."

The third question is the one that changed my life. I used to schedule important writing on Mondays and wonder why it never happened. Now I know: Monday morning, I do Quick Hits. Monday afternoon or Tuesday morning, I write.

Step 6: Shutdown ritual (the part that protects tomorrow)

ADHD brains don't turn off. Without an explicit shutdown, you'll either:

Keep working until 10 PM and burn out by Thursday
Stop working but keep ruminating, destroying sleep quality
Open your laptop at 9 PM "just to check one thing" and lose 2 hours

My shutdown ritual is a 4-item checklist, done at a fixed time (6:30 PM for me):

[ ] Write tomorrow's ONE task on the dashboard
[ ] Process parking lot (max 10 min)
[ ] Close all tabs and Slack
[ ] Say out loud: "I'm done for today."

The last step sounds ridiculous. It works. There's research (Cal Newport's writing on shutdown rituals, adapted from Zeigarnik effect studies) showing that verbal closure signals to your brain that open loops are parked. For ADHD specifically, the verbal cue is a stronger signal than just closing the laptop.

Step 7: Handling the inevitable collapse

Here's the part productivity gurus won't tell you: every ADHD system collapses periodically. You'll use it for 9 days, have a bad weekend, and not open Notion for 4 days. The dashboard will feel like a judgmental ex.

The entire system must be designed for re-entry without guilt.

My re-entry protocol:

Do not read old entries. Don't scroll back through what you missed. It triggers shame spiral.
Do today's 3 — just pick 3 things for today. That's it.
Clear the parking lot in under 10 minutes. Delete liberally.
Do not weekly-review the missed weeks. They're gone. Move on.

The system earns its keep by being usable on day 1 after a collapse, not by being perfect for 30 days straight. If your system requires streak maintenance, it will fail you exactly when you need it most.

What I systematized into a single Notion template

Everything above is free. You can build it yourself in Notion over a weekend. I did, iteratively, over about 8 months, across maybe 15 rebuilds as I figured out what actually worked vs. what looked good on a YouTube thumbnail.

After the 15th rebuild, I packaged the final version — with all the formulas, the energy tracking dashboard, the 3-bucket task system, the parking lot with auto-cleanup rules, the daily dashboard, the weekly reset template, and the shutdown ritual — into a single Notion template called ADHD Life OS.

What's inside:

Pre-built daily dashboard with the 5-section layout (Today's 3, energy check-in, current task, parking lot, tomorrow's 1)
Energy tracking database with pre-configured rollup views by weekday and time slot, so your energy map appears automatically after ~2 weeks of logging
3-bucket task system with the Real Cost formula already wired up
Parking lot with the 2-week auto-archive view
Weekly reset template — the 4-question version, not the 90-minute GTD one
Shutdown ritual checklist as a recurring toggle
Re-entry guide for when (not if) you collapse

It's built for people who have tried 4 other Notion templates and bounced off because they were designed for neurotypical productivity influencers with 3-hour morning routines. This one assumes you'll miss days, lose motivation, and need to rebuild trust with yourself.

If you want to build it yourself from this article, please do — the principles matter more than the template. But if you'd rather skip the 8 months of iteration and start with a working system tonight, the template is $35 on Gumroad. That's roughly 1 hour of my consulting rate, or about 20 minutes of recovered productivity per week for a year.

TL;DR checklist

[ ] Split tasks into 3 buckets (Quick Hit / Deep Work / Brain Tax), not one mega-list
[ ] Log energy 3x/day for 4 weeks to find your actual peak hours
[ ] Build ONE dashboard with max 5 elements, ignore the rest of your workspace
[ ] Capture stray thoughts in a parking lot, process once daily at 5 PM
[ ] Replace weekly review with 4-question Sunday reset
[ ] Add a verbal shutdown ritual at a fixed time
[ ] Design for collapse and re-entry, not for streaks

The system is the scaffolding. Your brain is still your brain. But with the right scaffolding, ADHD becomes a manageable operating constraint instead of a daily crisis.

Want the complete ADHD Life OS Notion template I used? View on Gumroad →

How Rideshare Drivers Track 1099 Income and Schedule C Deductions in 2026

komugi — Wed, 22 Apr 2026 16:48:13 +0000

It's February. You just got your 1099-K from Uber, your 1099-NEC from DoorDash, and a weekly summary from Lyft sitting in three different email threads. You open a shoebox full of gas receipts, your phone's Photos app has 400 screenshots of parking stubs, and you have no idea how many miles you actually drove for business last year.

You call your CPA. She says: "Send me your mileage log and a Schedule C worksheet." You freeze. You don't have one.

This is how most rideshare drivers lose between $2,800 and $6,400 a year in legitimate deductions — not because the IRS is unfair, but because they never built a tracking system that survives December 31st.

I drove rideshare as a W-2 side hustle for three years while working a day job. The first year I paid $4,100 more in taxes than I needed to. The second year I built a spreadsheet. The third year I over-refined it into the system I'm going to walk you through below.

This article covers:

Why the standard mileage deduction beats actual expenses for 90% of drivers
The exact fields a 1099 tracker needs to survive an IRS audit
How to reconcile 1099-K vs 1099-NEC vs your bank deposits
A Schedule C line-by-line map so you stop guessing
A weekly 15-minute routine that makes April painless

The real cost of not tracking: a concrete example

Let's put numbers on it. Meet Marcus, a software QA tester by day who drove Uber and Lyft on weekends in 2024.

Gross 1099 income: $28,400
Miles driven for business (estimated, no log): 22,000
Actual miles if he'd tracked them: 31,200
2024 standard mileage rate: $0.67/mile

Without a log, Marcus claimed 22,000 miles = $14,740 deduction.
With a proper log, he could have claimed 31,200 miles = $20,904 deduction.

The $6,164 gap, at his combined marginal rate of 31% (22% federal + 7.65% SE + ~1.35% effective state after deduction), cost him roughly $1,910 in extra tax.

Add the parking, tolls, phone percentage, car washes, and the $200 dashcam he bought but forgot to deduct — we're talking another $900+.

If you drive more than 10 hours a week and don't have a system, you are almost certainly overpaying tax by a four-figure number.

Standard mileage vs actual expenses: stop overthinking this

Every tax thread on Reddit devolves into this debate. Here's the honest answer for 95% of rideshare drivers:

Factor	Standard Mileage	Actual Expenses
Rate (2024)	$0.67/mile	Sum of real costs × business-use %
Recordkeeping	Miles log only	Every receipt, depreciation schedule
Works with used car bought cash	✅	⚠️ depreciation limits
Audit risk	Lower (simpler)	Higher (more to verify)
Typical winner for Toyota Prius / Corolla / Civic	✅	❌
Typical winner for 2023 Tesla Model Y bought new	❌	✅

Rule of thumb: if your vehicle cost under $25k and gets better than 30 mpg, standard mileage wins. If you bought a new EV or luxury SUV specifically for rideshare, run both calculations.

Once you pick standard mileage in year 1, you can switch later. But if you pick actual expenses in year 1, you're locked out of standard mileage for that vehicle forever. Start with standard mileage unless you have a specific reason not to.

The 8 fields your mileage log must have (IRS Pub 463)

The IRS doesn't require a specific format, but in an audit they want contemporaneous records with these fields. If your log is missing any of these, an auditor can disallow the deduction entirely.

1. Date of trip
2. Starting location (or starting odometer)
3. Ending location (or ending odometer)
4. Total miles for the trip
5. Business purpose ("Uber pickup," "Lyft en route," "deadhead to surge zone")
6. Platform / payer (Uber, Lyft, DoorDash)
7. Gross earnings for that shift (for income reconciliation)
8. Notes (tolls paid, parking, passenger incidents)

"Contemporaneous" is the key word. A log you reconstruct in March from credit card statements is weaker than one you updated the same night. Auditors know the difference.

The three-tier mileage you're probably missing

Most drivers only log P3 (passenger in car) miles because that's what Uber shows them. You can legally deduct:

P1: App on, waiting for a request (deductible)
P2: En route to pick up passenger (deductible)
P3: Passenger in vehicle (deductible)
Deadhead: Driving home after your last ride, if you're still logged in and available (deductible per most tax pros; verify with yours)
Commute: First drive from home to your "first stop" (NOT deductible unless you have a qualifying home office)

Uber's "on-trip" miles report dramatically undercounts your deductible miles. Lyft is slightly better. Neither is a substitute for your own log.

Reconciling 1099-K vs 1099-NEC vs your bank

Here's where side-hustlers get tripped up. In 2024+, Uber issues:

1099-K if you did 200+ rides AND got paid $20,000+ (federal threshold; some states lower)
1099-NEC for incentives, referrals, and quest bonuses over $600
A "Tax Summary" (NOT a tax form) that reconciles gross fares to net payout

Your bank shows net deposits. Your 1099-K shows gross fares. The difference is Uber's service fee, booking fee, tolls passed through, and sometimes tips.

You report the gross number on Schedule C Line 1, then deduct fees on Line 10 (Commissions and fees). This is critical. If you report net, you accidentally inflate your income when the IRS matches the 1099-K they received.

Example reconciliation:

1099-K gross fares (Uber):          $24,800
1099-NEC bonuses (Uber):             $1,600
1099-K gross (Lyft):                $11,200
Total Schedule C Line 1:            $37,600

Uber service fees (from summary):  -$6,100
Lyft service fees:                 -$2,800
Booking fees pass-through:           -$890
Schedule C Line 10:                 $9,790

Your net deposit to your bank will be roughly $37,600 - $9,790 = $27,810. If your bank shows $27,810 but you report $27,810 as gross income, you just overpaid tax on the fees (they're already deducted) OR you'll get an IRS CP2000 notice saying your 1099-K gross doesn't match. Both are bad.

Schedule C line-by-line for rideshare

This is the map I wish someone had handed me in year one. Not tax advice, but this is what every rideshare CPA I've talked to uses.

Line 1 — Gross receipts: Sum of 1099-K + 1099-NEC gross. Include tips even if not on the form.
Line 8 — Advertising: Business cards, decals if you ran any.
Line 9 — Car and truck expenses: This is your mileage × rate OR actual expenses. Fill out Part IV of Schedule C.
Line 10 — Commissions and fees: Uber/Lyft service fees, booking fees.
Line 13 — Depreciation: Only if using actual expenses.
Line 15 — Insurance (other than health): Rideshare endorsement on your policy.
Line 17 — Legal and professional: CPA fees, LLC filing.
Line 22 — Supplies: Phone mount, chargers, water bottles for pax, cleaning supplies.
Line 24a — Travel: Out-of-town driving trips, if any.
Line 25 — Utilities: Business-use % of cell phone bill.
Line 27a — Other expenses: Dashcam, car washes (if standard mileage — car washes arguably not deductible; verify), parking, tolls (if not already in mileage rate — they're NOT, so deduct separately), roadside assistance.

The deductions 80% of drivers miss

Go through this checklist right now:

[ ] Portion of cell phone bill (I use 70% business)
[ ] Phone case and replacement cables bought during driving year
[ ] Dashcam + memory cards
[ ] Car washes (if actual expense method)
[ ] Parking fees (not your rent — actual paid parking during shifts)
[ ] Tolls paid during business trips (even if using standard mileage)
[ ] Water, gum, phone chargers offered to passengers
[ ] Rideshare insurance endorsement (the extra $10-30/mo on top of personal)
[ ] Roadside assistance / AAA (business-use portion)
[ ] Health insurance premiums (if self-employed is primary; side gig with W-2 day job usually doesn't qualify)
[ ] Home office — only if you have a dedicated space used exclusively for dispatch/admin, which is rare for drivers
[ ] Self-employed retirement contributions (Solo 401k / SEP-IRA) — huge, and most people skip it

The 15-minute weekly routine

This is the habit that separates people who pay $1,900 extra from people who don't. Every Sunday night:

Open your tracker spreadsheet.
Pull the week's Uber earnings summary (gross fares + fees + tips).
Pull Lyft weekly summary. Same fields.
Export your mileage from whatever tool you use (more on this below).
Reconcile: does gross - fees = net deposit? If not, find the delta.
Photograph and log any cash expenses (tolls, car wash, mount).
Update running YTD totals: gross income, total miles, total expenses.

Fifteen minutes. If you do this 50 weeks a year, April takes 45 minutes instead of a panicked weekend.

Mileage tracking apps — honest comparison

Tool	Auto-track	Cost	Catches P1/P2	Export
Stride	✅	Free	⚠️ needs manual start	CSV
MileIQ	✅	$5.99/mo	✅	CSV
Everlance	✅	$8/mo	✅	CSV + PDF
Manual log	❌	$0	Depends on you	Whatever you build
Uber's built-in	❌	Free	Only P2/P3	Not a legal log

I used Stride in year one and Everlance in years two and three. Either works. The important part is that the app's output flows into a spreadsheet where you can combine it with income data from Uber/Lyft/DoorDash. No app gives you the full Schedule C.

Quarterly estimated taxes: the trap that hits side-hustlers

If you have a W-2 day job that over-withholds, you may be fine. But if your rideshare net profit crosses roughly $5,000 and your W-2 withholding isn't covering it, you owe quarterly estimated taxes (Form 1040-ES). Due dates:

Q1: April 15
Q2: June 15
Q3: September 15
Q4: January 15 of following year

Underpayment penalty is small but real — usually 7-8% annualized on the shortfall. The simpler fix: bump your W-2 withholding (Form W-4, extra $ per paycheck) to cover the expected rideshare tax. Then you don't file 1040-ES at all.

Quick estimate formula:

Estimated tax owed = (Rideshare net profit) × 0.30

Where 0.30 ≈ 15.3% SE tax + ~12-22% federal + state

Conservative. Adjust down if your marginal rate is lower.

A real conversation that saved a driver $3,200

Last March, a friend — I'll call her Priya, who drives Lyft 20 hours a week on top of a remote QA job — sent me her draft Schedule C.

Priya: "My CPA says I owe $4,800. Does that sound right?"

Me: "What'd you put on Line 9?"

Priya: "$8,200. That's 12,200 miles times the rate."

Me: "How'd you get 12,200?"

Priya: "Lyft's annual summary."

Me: "Did you track P1 and deadhead?"

Priya: "What?"

We went back through her Google Maps Timeline (which she'd had on for two years), filtered the trips that happened during her Lyft driving windows, and rebuilt a reasonable log. Actual business miles: 18,600. Extra deduction: 6,400 miles × $0.67 = $4,288. At her ~28% marginal rate, that was about $1,200 in tax.

Then we added: dashcam ($180), rideshare insurance endorsement ($240/yr), 70% of her phone bill ($840), and her SEP-IRA contribution (she'd skipped it entirely — eligible for ~$3,400 at her income, saving ~$950 in tax).

Final number dropped from $4,800 owed to $1,600 owed. $3,200 saved in a two-hour Sunday afternoon.

The only reason we could do this was Google Maps Timeline had been running. Without some data source — any data source — we'd have been stuck.

What a real tracker looks like

At minimum, you need three connected sheets:

Daily shift log — one row per driving session. Date, platform, start/end time, start/end odometer, P1 miles, P3 miles, gross fares, fees, tips, tolls, notes.
Expense log — one row per non-mileage expense. Date, category (maps to Schedule C line), amount, vendor, receipt photo link, business-use %.
Schedule C summary — auto-sums the two logs above into each Schedule C line so you can hand your CPA (or TurboTax) a single clean number per line.

Here's the kind of formula that makes the summary sheet work:

=SUMIFS(ExpenseLog[Amount], ExpenseLog[ScheduleC_Line], "Line 10", ExpenseLog[Year], 2025) 
 + SUMIFS(ShiftLog[Fees], ShiftLog[Year], 2025)

One formula per Schedule C line. When the CPA asks "what's your Line 22?" you point to a cell.

The system, packaged

I spent three tax seasons iterating on this. By year three my weekly reconciliation was 12 minutes, my CPA stopped charging me the "disorganized client" hourly surcharge, and I stopped losing sleep in March.

I systematized all of this — the daily shift log, the expense log with Schedule C line mapping, the income reconciliation tab that catches 1099-K vs bank deposit mismatches, the quarterly estimated tax calculator, and a Schedule C summary that outputs a single clean number per line — into a single Excel workbook called the 1099 Tax Tracker for Rideshare Drivers.

What's inside:

Pre-built daily shift log with dropdowns for Uber / Lyft / DoorDash / Instacart
Auto-calculating P1 + P2 + P3 mileage columns
Expense categorizer that tags each expense to its Schedule C line
1099-K / 1099-NEC / bank deposit reconciliation tab
Quarterly estimated tax worksheet with 2025 + 2026 rates
Schedule C summary sheet — hand this to your CPA and you're done
Mileage deduction vs actual expenses side-by-side calculator
Deduction checklist (the one above, but built into the workbook)
Works in Excel, LibreOffice, and Google Sheets (with minor formula tweaks)

It's not a SaaS, not a subscription, not another app you have to log into. It's a spreadsheet you own, drop on your Desktop, and update 15 minutes a week. $25, one-time.

If you drive rideshare as a side hustle and you've been recreating this logic from scratch in your head every April, you can skip three years of iteration.

Want the complete 1099 Tax Tracker for Rideshare Drivers I used? View on Gumroad →