It was almost a year ago when I built my first proper automation. Looking back at it now, I believe that was the moment I truly began to understand what it means to solve problems with code. At the time, it was just a Google Form: something simple, something that seemed like a small fix for an annoying process. That small fix eventually grew into a bigger solution. It fundamentally changed the way we handled auction photos.
The problem seemed straightforward at first glance. In reality, though, it was a complete mess. During each auction, people uploaded hundreds, sometimes thousands, of photos for the lots being listed. There was no structure to how these images were stored. For example, if someone uploaded five photos for Lot 1 and ten for Lot 2, Google Forms would place them all into the same folder. There was no way to tell which photo belonged to which lot. The filenames were random, meaningless strings of letters and numbers. There was no mapping, no sorting, and no way to link these images directly to our auction system. To make matters worse, before we even used Google Forms, people had been sending photos via WhatsApp. That platform compressed images so badly that photo quality dropped by 80%. As a result, auction listings looked terrible, and bidders couldn’t see the details they needed.
To fix this, I built a script. It wasn’t complicated, but it worked. Each time a form was submitted, the script would read the response, grab the lot number from the answer field, collect the uploaded photos, place them into a new folder, and name that folder after the lot number. For the first time, every photo set was automatically sorted into its correct place without anyone needing to go through them manually. It was a small change, but it saved hours of work.
Initially, I thought that was enough. The photos were no longer mixed together, and there was no need to manually drag and drop them into folders. However, there was still another challenge. The auction house’s back-office system required a strict naming convention: the lot number, followed by an underscore, and then a sequence number. For example, Lot 6 needed its first photo named 6_1.jpg, the second 6_2.jpg, and so on. Google Forms ignored this. It saved files using random names. So we moved from manually sorting folders to manually renaming every file instead.
I tried renaming files directly in Google Drive using Apps Script. Unfortunately, Apps Script is painfully slow. Renaming more than a handful of files at once would cause the script to crash or time out. I had to batch the work—ten files at a time, maybe twenty if I was lucky. The process was extremely slow. I remember sitting and waiting for each batch to finish, thinking, "There has to be a better way."
Eventually, it hit me. Why was I doing this inside Google Drive when a local computer could handle it instantly?
That moment was the breakthrough. Instead of relying on Apps Script, I wrote a batch script to run on a local machine. We would download everything, let the script handle renaming in seconds, and then upload the renamed files. The difference was night and day.
The batch script did two main things. First, it looped through each folder—Lot 1, Lot 2, Lot 3—and renamed all the photos inside so they followed the proper sequence. Then it added the lot number prefix so each filename matched the auction system’s format. No more dragging, no more guessing. Just clean, consistently named files, ready to be uploaded.
There was still one last issue. The first photo in each lot mattered more than the others. It had to be the best one—the photo that caught a bidder’s attention. However, due to the upload process, the best photo often ended up buried somewhere in the middle. That part still required a bit of manual review. Fortunately, it was now the only task that required human input. Instead of wasting hours renaming files, the only thing left was choosing the best cover image before uploading.
This system, which we referred to as Version 2, stayed with us for a long time. It completely transformed the photo handling workflow at the auction house. What had once been a chaotic, frustrating, manual process became a structured and streamlined workflow that took a fraction of the time.
Looking back, I realize this wasn’t just about fixing one problem. It was about learning how to think differently. At first, I tried to improve an existing process. Eventually, I understood that the entire process needed to be rebuilt. This wasn’t just about automation—it was about redefining how the system worked.
That, to me, was the real achievement. It wasn’t just about saving time. It was about proving to myself that I could solve meaningful problems. That I could take something broken, inefficient, and assumed to be unchangeable, and turn it into something better.
A year ago, this was my first real development project. Now, looking at everything I’ve built since, I see that moment as the turning point—from learning about automation to using it to create change.
This system served us well for months. It wasn’t flawless, but it was effective. Every auction followed the same steps: download the photos, batch rename them, and upload them to the back-office system. The process had gone from being an unpredictable mess to something consistent and manageable. It still required a bit of manual effort, but it was a huge leap forward.
At first, I believed we had reached the limit of what was possible. But after several months of using the system, I started questioning it again. Too many steps still relied on manual fixes. The biggest issue was photo order. No matter how carefully I renamed them, 60 to 70 percent of the time, the order was still incorrect. Since the first photo was the most important, I still had to manually rearrange them after every upload. For five or six months, I sat through this process, dragging and dropping photos into the correct order. It was better than before, but it was still wasted time.
Even so, the system was working. Auctions were running smoother than ever. We were seeing £100K, £120K, even £150K in sales. Clearly, high-quality, well-organized photos made a big difference. Still, I kept thinking, “There must be a way to automate this final part too.”
Eventually, I had another realization: Could Apps Script rename files directly?
I had been using Apps Script to organize photos into folders, but never considered renaming them right in Drive. I asked the question, gave it a try, and yes—it worked.
This was a game changer. Now the script could not only sort the photos but also rename them automatically at the point of upload.
I redesigned the form. Instead of dumping all photos into one folder, it now asked three key questions:
- The first photo (manually selected).
- The lot number (for proper naming).
- The remaining photos (uploaded in bulk).
Initially, this felt like the perfect solution. The form would instantly rename everything, and I wouldn’t need to rearrange the photos afterward. Then I ran into another Google Forms limitation: it only allowed ten files per question.
There was no way around this restriction. It was fine for smaller lots, but high-value items often came with 15, 20, or even 30 photos. There wasn’t enough space to upload them all in one field.
To address this, I made the third question optional. Sellers with more than ten photos could upload the extras in a second field. It wasn’t ideal, but it was the most reasonable compromise I could make.
Another major challenge was user resistance.
People generally dislike change. In fact, they often hate it. I wasn’t just changing a part of their process. I was introducing an entirely new system.
As soon as I introduced the form, people pushed back strongly. They didn’t like it. Complaints poured in. They wanted to go back to WhatsApp, because it was easy and familiar. Even though the new system saved them time, they resisted it.
I had to find a middle ground. If I made them manually order every photo, they would have abandoned the form. They might have even gone to management, called the system too complicated, and shut it down.
Instead, I made a key compromise. I only asked them to choose the first photo. Just one selection. The rest could be uploaded in any order, and the script would rename and reorder everything.
That solution worked. They didn’t love the system, but they accepted it. And after eight months, it became the new standard for handling photos.
Now we had a clean, structured system:
- Sellers submitted photos through the form.
- Photos were automatically renamed and sorted into folders.
- The first photo was always correct.
- Files were downloaded in batches (Compile 1, Compile 2, Compile 3…).
- Uploading to the auction system became a one-step process.
A task that once took hours now took minutes.
Looking back, I know this may not seem groundbreaking to an experienced developer. It’s just basic file handling. But in a non-technical company, where people were still dragging images through WhatsApp, this was transformative.
This is what I’ve come to understand. Real-world automation isn’t about complex or elegant code. The most powerful scripts I’ve written are tiny—some just 20KB or 50KB. Yet they’ve saved weeks of labor.
This system, built over the course of a year, completely changed how we handled auction photos. More importantly, it showed me that I could do this.
I didn’t just write code.
I reimagined a process.
I made something that lasted.