Today, I came across a way to avoid it in REST APIs while working with the Stripe API. I am naming this the Expand pattern (courtesy of Stripe API Developers). Take this pattern and implement it in your REST APIs to avoid the n+1 problem.

Problem

Let us look at a simple API call.

1

GET /v1/invoices/:invoice-id

1
2
3
4
5
6
7
8
9
10

{
  "id": "in_1MtHbELkdIwHu7ixl4OzzPMv",
  "object": "invoice",
  "customer": "cus_NeZwdNtLEOXuvB",
  "subscription": "sub_1MoGGTLkdIwHu7ixZkAA1J0n",
  "payment_intent": "pi_3MtHbELkdIwHu7ix0rUOgsLj",
  "amount_due": 5000,
  "currency": "usd",
  "status": "open"
}

You usually want to make another request for a field whose ID is present in the response. Let us say we want the customer’s email address. Then we end up making one more API call to get the full customer object.

This does not look bad for a single invoice. But we usually list things.

1

GET /v1/invoices

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

{
  "object": "list",
  "url": "/v1/invoices",
  "has_more": false,
  "data": [
    {
      "id": "in_1MtHbELkdIwHu7ixl4OzzPMv",
      "object": "invoice",
      "customer": "cus_NeZwdNtLEOXuvB",
      "amount_due": 5000,
      "currency": "usd",
      "status": "open"
    },
    {
      "id": "in_1NaB2cLkdIwHu7ix9Qe3FpzT",
      "object": "invoice",
      "customer": "cus_OpZ1aRtMFQYwxC",
      "amount_due": 8200,
      "currency": "usd",
      "status": "open"
    }
  ]
}

To show the customer’s email for each invoice, we make one more call per invoice. List N invoices and we make N more calls - 1 for the list and N for the customers. That is the n+1 problem.

Expand Pattern

Stripe provides a param called expand for this on most of its APIs. You can use it to pass the field names that you want to expand. That means you get the full object instead of just the object id.

1

GET /v1/invoices/:invoice-id?expand[]=customer

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

{
  "id": "in_1MtHbELkdIwHu7ixl4OzzPMv",
  "object": "invoice",
  "customer": {
    "id": "cus_NeZwdNtLEOXuvB",
    "object": "customer",
    "email": "jenny.rosen@example.com",
    "name": "Jenny Rosen"
  },
  "subscription": "sub_1MoGGTLkdIwHu7ixZkAA1J0n",
  "payment_intent": "pi_3MtHbELkdIwHu7ix0rUOgsLj",
  "amount_due": 5000,
  "currency": "usd",
  "status": "open"
}

The same works on a list. Expand data.customer and every customer comes back inlined in that single call.

1

GET /v1/invoices?expand[]=data.customer

No more N extra calls.

GraphQL, when?

What if I only want the customer’s email and not the whole customer object?

That doesn’t seem to be possible with expand. It returns all the fields of the expanded object.

This is the place where we enter the GraphQL territory. GraphQL lets you pick exactly the fields you want. expand only saves you the extra round trip, not the over-fetching cost. But still a good win!

Nested Expand

It seems like you can do nested expands in the Stripe API like this

1

GET /v1/invoices/:invoice-id?expand[]=customer.default_source

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

{
  "id": "in_1MtHbELkdIwHu7ixl4OzzPMv",
  "object": "invoice",
  "customer": {
    "id": "cus_NeZwdNtLEOXuvB",
    "object": "customer",
    "email": "jenny.rosen@example.com",
    "name": "Jenny Rosen",
    "default_source": {
      "id": "card_1NLOFm2eZvKYlo2C8Z9k3K2L",
      "object": "card",
      "brand": "Visa",
      "last4": "4242",
      "exp_month": 8,
      "exp_year": 2026
    }
  },
  "subscription": "sub_1MoGGTLkdIwHu7ixZkAA1J0n",
  "payment_intent": "pi_3MtHbELkdIwHu7ix0rUOgsLj",
  "amount_due": 5000,
  "currency": "usd",
  "status": "open"
}

However, there is a limitation for how deep you can traverse - 4 levels. Still, a deeply nested fetch that would have been several round trips collapses into one call.

There is no particular reason mentioned for picking 4 as the limit, but if we were to implement the expand pattern in our APIs, we can do something like this. We want a default max depth so a single request cannot fan out forever:

1
2
3
4
5

Let T = number of tables
Let D = maximum depth of relations between your tables   (the optimal value)
Let B = a higher limit you pick for your app's use case / bandwidth savings

limit = min(D, B),  where  limit < T

No worries

I think this pattern is useful to know about to avoid overthinking things, like “what if my app becomes a hit overnight and it’s doing a lot of n+1 calls”, “That won’t scale!” etc.

I am never going to worry about anything like that while building new apps. Just focus on a solid REST API and do the expand pattern - That should give us good mileage.

During that exploration, I realized that there is one underrated skill for an engineer: “counting the number of zeros in a number”.

There is a cultural element to why I am calling this a skill. It is because all the software-related literature (books, RFCs, design docs, blog posts, papers, etc.) follows the International number system. I am from/in India, where we follow the Indian Number System. The international system is a 2-mark question in our grade/class 1. After that, I moved on to use the Indian number system for almost anything for the next 20 years - that includes all the numbers needed for my algebra, calculus, finance, economics, physics, and chemistry.

What does that mean?

Take a look at this number: 1000000 (That’s six zeros if you are counting).

• A person practicing the International Number System
  • would write it as 1,000,000
  • would read it as 1 million
• A person practicing the Indian Number system
  • would write it as 10,00,000
  • would read it as 10 lakhs

I initially struggled to read software literature with numbers. If a blog post says we had 1 million users hit our servers at peak times, I would actually spend a few seconds in my mind trying to convert it and say, “Oh, they had 10 lakh users! That’s great!”

Once, I was working at a startup where my primary task was to benchmark various KV stores to migrate the system to a store that could handle 10x load. That was my peak number struggling days. I was showing the numbers from a benchmark to the CTO. He sat down with me, and the first thing he started doing was counting zeros. (To my luck, he did it out loud)

1, 2, 3 - That is three zeros, that means a K. So this is 4K bytes.

And he goes,

We have 3… 6 zeros. - That means a million. So this is 4M requests.

That is a turning point for me. Because you can understand things faster that way. I gave up on my “convert to Indian numerals to understand the impact” idea and instead embraced the idea that counting zeros is the way.

If you ask me how it looks in my brain now. It is as if there are two languages for mathematics. One I use to count money (this is the main use-case for the Indian number system for me), and another one I use to count numbers while working with computers.

Okay, so this is what you have to remember if you are coming from a similar cultural background:

• Count zeros
• 1000
  • 3 zeros
  • That is a thousand.
  • It has another name: Kilo - Kilobyte is one thousand bytes.
  • Instagram teenagers mean 4,000 when they say 4k
  • = 10³
• 1,000,000
  • 6 zeros
  • That is a million.
  • It has another name: Mega - Megabyte is one million bytes.
  • If an engineer says you have 1M rows in a table that is not indexed, you are in trouble.
  • = 10⁶
• 1,000,000,000
  • 9 zeros
  • That is a billion
  • It is denoted by Giga - Gigabyte is a thousand megabytes i.e., a billion bytes.
  • The world population is ~8.3 billion people as of mid-2026.
  • = 10⁹

~ ~ ~

That’s enough zeros to get you a good mileage.

Books

I read 10 books this year.

• How to Take Smart Notes - The first book I read this year. It helped me form a note-taking habit. It not only teaches how to take notes but also how to consume knowledge. Highly recommended to anyone.
• The Bullet Journal Method - I picked this up to learn a journaling system. It led me to develop a journaling habit this year. I read it once and re-read parts of it throughout the year to clarify and reinforce certain aspects of the process.
• The War of Art - I discovered this via this podcast episode — I paused it midway to get the book. The book introduced me to the idea of resistance (which I discussed here) that every artist or creative individual faces.
• Turning Pro - This is a sequel to “The War of Art.” I kept both of these books on my table for a while. Whenever I felt distracted from work, I made myself pick up and read these books instead of doing something else. That usually helped me return to work energized.
• Self-Led - This book is about Internal Family Systems. After reading it, I’ve been observing my “self” and noticing a phenomenon called “Parts Party” (the idea of how one thing leads to another emotionally). Overall, this has made me more self-aware and conscious of how I make others feel. I’m glad I picked up this book earlier this year.
• Dare to Win - My daughter randomly chose this book in the bookstore and gave it to me. I took it as a sign from the universe and bought the book. I like reading these kinds of books when I feel low.
• Excellent Advice for Living: Wisdom I Wish I’d Known Earlier - Assorted advice on a variety of things. Loved it!
• A Little Book of Life - Similar to the previous book, but this one is by Ruskin Bond (the author of many stories I’m reading these days to my daughter).
• The Almanack of Naval Ravikant - Soulful. Complete. Clear. This book calmed me down a lot. It had such a positive impact on me that I chose to gift a copy to my sister.
• Coding Interview Patterns - I chose to read this at the start of the year to overcome my anxiety about the job market and job security. A friend recommended it to me. It’s well written and did the job of reducing my anxiety.

I also started a few more books that I couldn’t complete:

• Four Thousand Weeks - I didn’t complete it, but it still had a great influence on me. I might re-read it from the start if I get the chance.
• Dopamine Nation - I have been hearing to some podcasts about dopamine that has made me more mindful about how I spend my energy. I guess I ran out of dopamine to complete this book 😅 I will revisit this book only when I feel like I am misusing my dopamine.
• The Idea Factory - This books is about the engineers who worked at Bell Labs (The birthplace of various breakthrough technologies like Transistors, UNIX, C, etc.)
• API Security in Action - Left halfway because O’Reilly free trial ended ended - lol. But also I found what I was looking for. The thing that completed my journey here was reading through the docs of Ory Hydra.
• PostgreSQL 14 Internals - My strategy for getting strong with Postgres is to read this book and look at what happened in the future releases of Postgres. It is kind of an intense book and demands certain level of energy.

Gadgets

I love trying out and using new gadgets. Here are some gadgets I got this year:

• ThinkPad P16s Gen 2 – I received a laptop refresh at work. Previously, I used a Dell XPS 15 and several older ThinkPads, so it was finally time for something new. My personal (and controversial) preference is still the XPS 15 over any ThinkPad. The good thing about ThinkPads is that Ubuntu runs smoothly on them out of the box.
• OnePlus Nord Buds 2r – I got these as a gift. I’ve always preferred wired audio devices—Apple EarPods (wired) have been my primary choice for the past five years. For some reason, I gave these wireless buds a try, and they’ve become my main audio device. I’ve overcome my “wired” obsession because wireless clearly wins in certain situations (for example, wireless is so much better than wired headphones while washing dishes).
• Moto razr 60 – I’ve been using the Moto g82 for the past three years and have wanted to try a foldable phone. I wished for a Samsung Galaxy Z Fold7, but it’s way out of my league price-wise. Hopefully, foldables will become more affordable in the future. I got my hands on the razr 60 in December, so it’s too soon to say much about it.
• Saregama Carvaan – This is my most loved gadget of the year (picture below). It comes loaded with playlists of retro songs. You can often find me carrying this box around the house and playing tunes whenever I feel like it. My favorite playlist is “Top 300.” Overall, I think I listened to more songs on this box than on Spotify this year.

Work

• New title: “Staff Software Engineer” 🎉
• This year marks half a decade with my current employer: Hasura / PromptQL and a full decade working at various startups.
• What I have realized over these years is that, there are going to be ups and downs in every org. It is best to focus on learning and getting better and making the most out of our time.
• The essence of my journey had been “show up, ship things, and help others ship” - I like it this way!

Finance

• 🚗 Fixed my car loan.
• 💲 Fixed personal loans from the past.
• 🏦 Did decent in savings :)
• Doing bad in investments, but it is okay for a guy who had been floating in loans from the past.

Events

I showed up at only one in-person tech event this whole year. It was at BLR Go Meetup (Jan) - I helped with getting my employer to be the venue sponsor for this meetup. One thing I loved about this meetup was that they gave the mic to everyone in the room. They have to introduce themselves to the crowd and tell what they are looking to learn out of that meetup. I shared how I discovered Go programming in BMTC (public bus transport of Bangalore) and made a whole bunch of people to laugh/smile. Reflecting back, I feel like that is one of the proudest things I have done in 2025 - putting smiles on faces :)

I did get a chance to watch the recordings of a few conferences.

• SOSS Days India
• FOSDEM 2025 Go Videos
• Some GopherCon EU 2025 videos
• Currently active: GopherCon US 2025

Habits

Some habits that I formed this year:

• Taking notes while reading books
• Bullet journal
• Drinking coffee in the morning (successfully quit this too — lol :D)
• Drinking tea in the evening (actively in the process of quitting this)
• Switching to warm lighting at night
• Maintaining less than an hour of screen time per day on mobile
• Opening my journal instead of my phone as the first thing in the morning

Note Taking

I’m proud of my note-taking journey. I blogged about my note-taking setup here earlier this year. I’ve tweaked it a bit to fit into my bullet journal, but the core principles remain the same.

All my notes end up in my Obsidian vault. To celebrate my progress, I’m going to share my knowledge graph from Obsidian. This is how it looked around the start of the year:

And this is how it looks now:

Journals

This was the biggest productivity experiment I ran throughout the year. I chose bullet journals as my system for journaling. I remixed and adapted a few things, but overall I’m happy with the outcomes.

One thing I missed in my process was not reflecting enough. I want to improve in that aspect.

I think the bullet journal book clearly advocates using paper notebooks for journaling (analog). I ran a micro-experiment to go all digital with the help of Obsidian. The outcome: paper wins! I still use Obsidian, but mostly for notes and sometimes as a digital scratchpad. Paper notebooks are a clear winner—they can slow down time for you!

Mantras

Some things I needed to consciously repeat to myself — hopefully to ingrain them in my behavior:

• Order matters: Brush, Bath, Pray, Eat.
• Do not talk about work with my wife.
• Overcome Resistance.
• Attention residue is real.
• Acquire “Specific Knowledge” every day.
• Calm down and observe the situation. You’ll find a way forward.
• Watch your mood, rest up, and rejuvenate.
• Meditate multiple times a day. Life has tangled so much that one won’t cut it.
• Drop judgments. See what could be good in any situation.

50% have become second nature to me. I am still working on the rest.

Side Projects

I tried working on two side projects this year. Both of them flopped, and I had to stop working on them.

• gokakashi – Open source. Built with friends from work (mostly to deploy at work). Stack: Go + Postgres + Vite + React. We had to replace it with something like this. This is a story in itself with a good deal of learning (saving it for another time).
• A small app I built for my cousin with Next.js + Postgres + Tailwind + shadcn/ui. We had to throw it away because I struggled to find time to make it useful, and my cousin went back to doing things his old way. But this was a valuable learning experience for me. I probably tried out most of the AI-assisted coding tools in the market while working on this project and formed my opinions about them.

If I have to set a goal for side projects, it would be to build something that stands the test of time.

~ ~ ~ ~

Overall, I feel good about all the progress I’ve made this year. I want to keep up the good work and focus on improving!

To tell what that is, I must quote a few lines from the book:

Most of us have two lives. The life we live, and the unlived life within us. Between the two stands Resistance…..

Are you a writer who doesn’t write, a painter who doesn’t paint, an entrepreneur who never starts a venture? Then you know what Resistance is.

The moment I read those lines, I had this realization: “I have become a blogger who doesn’t blog.”

Today, I want to break that and overcome my resistance to writing blog posts. Because blogging is a soulful act for me. I find it personally rewarding every time I do it, and I always want to do more of it.

So, here I am! Opening up my journal in the middle of the night to write this blog post on paper to overcome my resistance. “Having to turn on my computer every time I want to write a blog post” has become a resistance for me. Not just that, I am sure there are n different things resisting me at a given point in time. But that is okay - I just need to do better at overcoming them!

I don’t know why, but I am finding it fun to write this on paper. The words are flowing faster, and I am saving myself from a little bit of screen time.

I want to do more of this: Resisting my resistance.

Here’s the thing: When you have an idea for a project (that light-bulb moment) or when a friend calls you up and says, “Hey, why don’t we build this side project?” your builder instinct kicks in and replies, “Let’s do it!”

That moment right there is causing a drift in your timeline. I want you to be conscious of that. The thing is, there are only 24 hours in a day, and by signing up to build this new project, you will devote a significant chunk of those hours to it. This might prevent you from doing other activities that are essential for your “work-life balance”.

How do you find time then? Well, you don’t need to find time for projects. Instead, try finding the right projects for your time.

Who is this for?

Before I continue, I would like to state that this piece of advice is contextual and doesn’t apply to everyone. This advice best applies to you if

• You have a full-time job.
• You are living with your family (and looking to spend your precious evenings with them)
• You are having trouble prioritizing “what to work on”, “what to study”, etc.
• You are having trouble scheduling time.
• You are having constant thoughts of building new projects.
• You sometimes regret spending like 10 hours a week on a project that didn’t go anywhere.
• (I guess you get it)

The Framework

The truth is, you are building one of these:

• a project with no users
• a project where you are the user
• a project where you have a user (who is not you)

When you start building a new project, it should fall under one of the above categories. It will eventually lead to one of the following outcomes:

• Best case: Your project is thriving and being used (hopefully by a good number of audience)
• Average case: You hack on your project for a while and eventually forget about it.
• Worst case: You question yourself, “What am I doing with my life?” after weeks/months (hopefully not “years”) of working on the project.

Just like how most startups go nowhere, I am guessing that most of the side projects don’t hit the best-case outcome. They usually end up in worst or average-case outcomes. From my personal experience, I think I have been part of projects that fall under all (if not most) of the categories and outcomes defined above. Based on that, I have come to the following deduction:

First User Framework: Start a project only after you have the first user, who is ready to try it out and provide feedback from day 1.

If a category 1 and 2 (no users and you are the user) project seems attractive to you, then challenge yourself to put yourself out there and turn it into category 3 (you have a first user) and then work on it. Instead of taking four months to build a project that no one uses, you will find yourself making meaningful progress in a week if you are able to qualify the project to be category 3 upfront. (we are looking at exponential time gains here; that should be more attractive to you)

On the other hand, this makes you ruthless about your time and priorities. You might already be working on a short-term goal that is important for you. At times like that, this framework will shine. Either your short-term goal is more important and you pass on the opportunity or this new “category 3” project becomes your short-term goal.

But my passion project?

Usually, passion projects fall under category 1 or 2. So this blog post makes me a villain in the eyes of passion projects. As I mentioned above, this framework is contextual and is written for people who are not finding time and balance in life. If you have the time and freedom to work on a passion project, you should probably do it! There is an immense sense of satisfaction that comes with it.

For example, I did a category 2 (passion) project: a small binary to kick-start my blog writing process. I have been a solo user of it for the past 5 years. I have zero regrets about the time I put into it. So my point is not “don’t work on passion projects”. My point is “Be mindful of your time”.

~ ~ ~ ~

“But my friends are calling me to build the next Google?”

Well, attend the call and ask them, “Where is our first user?”