Migrating from Airtable to Sanity: how my portfolio ended up with three different ways of storing data
My portfolio has evolved from hardcoded data through Airtable and Supabase Storage, and has now landed on Sanity. Along the way, there were broken images, a few less-than-ideal decisions, and questions to which I’m not sure I’ll ever find an answer.
Migrating from Airtable to Sanity — or how my portfolio ended up with three different data storage methods.
My portfolio didn’t start with a well-thought-out architecture, a carefully chosen CMS, or a beautiful diagram illustrating data flow. It started with… hardcoded data. And for a while, that worked just fine. But as the number of projects grew, editing everything directly in the code became a lot less fun. So, I thought: okay, I need some kind of database.
Why Airtable?
Why Airtable, specifically? An instructor in one of my courses used it, so I wanted to see what all the fuss was about. Plus, it has a free tier, the documentation looked quite user-friendly, and looking at all those `curl` requests makes you feel like a "real" programmer. And isn't that the whole point of a portfolio—to show that you’re a good programmer?
Exactly.
That’s when a question came to mind—one that’s perhaps more important than just "can I code this?" What does it actually mean to be a good programmer? Is it just about implementing a solution well, or does it also involve considering whether the chosen tool is actually the right fit for the problem at hand? At the time, I didn’t have a good answer for that..
I finished the first version of my portfolio, everything was working, so I left it alone. Some time passed, I visited the site, and—what the heck? The images weren’t rendering. I wondered: what’s going on? I checked my "database." The images were there—they were definitely there. So why, for heaven’s sake, weren’t they showing up in production? For a moment, my first thought was, naturally: "What kind of frontend developer am I if I can’t even get images to render?" It took me a while to realize that the problem wasn't React, Next.js, or some magical curse cast upon my portfolio. It was simply that Airtable wasn't the right place to store images in the way I was trying to use it.
Well, what does a junior developer do when something doesn't work? They make it work, of course. So, the images went back… into the codebase.
Yes—hardcoded again.
Was it an ideal solution? No. Did it work? Yes. And since it worked, I could consider the matter closed.
Supabase Storage: now things should be right.
After some time, I decided it was probably time to do things a bit more properly. I settled on Supabase Storage and moved the images there.
Does it work?
It works.
So, let it stay.
And stay it did—for several years.
So, in a single project, I had project data in Airtable, images in Supabase Storage, and some elements hardcoded directly into the codebase. It might not have been total technological chaos, but it was definitely starting to look like a collection of decisions made at various different stages of my life.
Then, I decided I wanted a blog.
A few years later, I set out to refresh my portfolio. I thought it would be great to not only showcase my projects but also share what I’ve been learning while working as a frontend developer. In other words: I needed a blog.
So, I took a look at my tech stack.
And there it was: Airtable + Supabase + hardcoded bits.
I looked at it and thought: Well, then. I think this needs to be organized a bit better.
So, I asked my friend "Czaruś"—a.k.a. ChatGPT—for some recommendations. I got a few options, and one of them made my eyes go like this: 👀
Hardcoding everything.
Again.
No.
Not this time.
Since I’m already setting out to tidy up the project, going back to manually typing everything into the code would be a step backward, not forward. My options included sticking with Airtable, moving the data to Supabase, using a headless CMS, or—as it happens—choosing Sanity. There was also the "don't change anything, it works fine as it is" option, but I didn't feel quite brave enough for that.
I chose Sanity.
And that’s when the actual migration began.
Where is the data actually stored?
I broke the migration down into smaller steps: installing packages, configuration, and then setting up the Studio. At one point, a very fundamental question came up: "Right, but if I enter something into this Studio, where does it actually get saved?"
With Airtable, it was pretty intuitive—I had tables, records, and fields that I could just click on and edit. Sanity requires a slightly different way of thinking. The Studio acts as an interface for content management, while the content itself is stored within Sanity. In the project, we define document schemas, and then we can create and edit data using the Studio.
In other words, instead of keeping project data directly in the code, I can have a "project" document with fields like title, description, technologies, a link to the website, a GitHub link, an image, or the language version—and the application simply fetches that data. And this started to look like a solution that actually makes sense for the portfolio I want to continue developing.
Alright. Now, an error.
Of course an error appeared. Because why wouldn't it?
It turned out that I was using an older version of React and Next.js 14, while I had installed the latest version of Sanity. I was faced with two choices. The first: "Well, I’ll just upgrade React and Next.js. It’ll be fine." The second: "Maybe let’s not perform an unplanned migration of half the application right now, just because we want to switch to a different CMS."
I chose the second option.
Instead of rushing to update the entire project, I selected a version of Sanity that was compatible with what I already had in place. And suddenly… it worked. No need to rebuild the whole application, no creating extra headaches for myself, and no massive, simultaneous migration of React, Next.js, and half the project.
What this migration taught me?
Looking back at my portfolio, I can see the history of my own development. At first, everything was hardcoded—it was the simplest approach. Then came Airtable, because I wanted a database. Later, I added Supabase Storage, as images started causing issues. For a few years, I didn’t touch anything because… it worked. But as the portfolio grew, those small, individual decisions—made at different points in time—began to clash with one another.
That’s when the question from the beginning came back to me: is a good programmer someone who can write great code, or someone who also knows how to choose the right tool for the job?
I’m increasingly inclined to believe that one without the other is somewhat incomplete. You could write excellent code while using a completely ill-suited tool—or, conversely, you could adopt a trendy solution simply because it’s popular. You could, of course, carry out a major migration—telling yourself, "Now things will be professional"—only to find yourself wondering, two days later, why on earth you did it all in the first place.
That’s why, this time, I didn’t just want to swap one tool for another. I wanted to bring some order to how my portfolio stores and retrieves content. And, for now, Sanity is doing a great job at that.
Does this mean my portfolio is now a perfectly designed system?
Certainly not.
I’m still using Next.js 14 and an older version of React.
But that’s a story for another time.
For now, it works.
And this time, I think I have a better understanding of why.