Rebuilding a Client Website to Cut Costs and Move Faster

Overview

This project came up while I was already in the middle of another one. A Squarespace site I managed was about to renew at a much higher cost than necessary, and it was clear the client did not need to be paying that much just to keep a relatively simple website online.

Instead of letting the renewal go through, I offered to rebuild the site in a more cost-effective way. That turned into my second freelance website project and became a good example of what real client value can look like. It was not about adding a long list of features. It was about solving the right problem, doing it efficiently, and improving the long-term setup for the client.

It was also one of the first projects where I leaned more heavily on AI tools like Cursor and Claude Code during development. That made it an important project not only from a freelance perspective, but also in terms of how my workflow was starting to change.

Backstory

What made this project interesting was how suddenly it came up. I was already focused on something else when I realized the existing Squarespace site was approaching renewal, and the cost was hard to justify for what the site actually needed.

Because there was a clear opportunity to save money and simplify the setup, it made sense to prioritize it. That felt like a very real freelance moment. Work is not always linear, and sometimes the most valuable thing you can do for a client is address the problem that is creating the most immediate cost or friction.

This project reminded me that freelance development is not only about building new things from scratch. Sometimes it is about stepping in, recognizing an inefficient setup, and replacing it with something more practical.

The Problem I Was Solving

At the center of this project was a business problem more than a technical one. The Squarespace renewal was around $300, and that ongoing cost did not make much sense for the needs of the site.

The client mainly needed a reliable website and domain without unnecessary platform costs. That made the real question less about what I could build and more about what setup would make the most sense moving forward.

Rebuilding the site and hosting it on Vercel gave us a much simpler and more affordable solution. In that sense, the value of the project was not just the website itself. It was the cost savings, the cleaner hosting setup, and the fact that the client ended up with something that better matched what they actually needed.

Goals of the Project

The goals for this project were practical from the start.

First, I wanted to move the site away from an unnecessarily expensive platform while preserving the content and functionality that actually mattered. Second, I wanted the rebuilt version to be reliable, easy to host, and cheaper to maintain over time. Third, I wanted to deliver it quickly without sacrificing quality.

That shaped a lot of the project decisions. This was not a feature-heavy build where the main challenge was complexity. The challenge was creating a strong result through good judgment: keeping what mattered, simplifying what did not, and making sure the final setup served the client better than the old one.

Tech Stack and Hosting Decisions

For this project, I stuck with a frontend stack I was already comfortable with. That helped me move faster and keep the work focused on solving the actual problem instead of experimenting with unfamiliar tools.

Hosting on Vercel was one of the most important decisions in the project. It gave me a reliable deployment workflow, reduced infrastructure overhead, and made it possible to run the site at a much lower ongoing cost than the previous Squarespace setup. Since the site did not need heavy backend complexity, that simplicity was a big advantage.

This project reinforced something I keep seeing more clearly: the best technical choice is not always the most advanced one. Often it is the one that is easiest to maintain, easiest to host, and most aligned with the real needs of the client.

How I Used Cursor and Claude Code

This was one of the first projects where I started leaning more on AI tools as part of my development process. I used Cursor and Claude Code to help speed up parts of the workflow like scaffolding, implementation, debugging, and iteration.

What stood out to me was not that AI replaced the work. It did not. The value came from acceleration. It helped me move through repetitive or lower-friction tasks faster so I could stay focused on architecture, decision-making, review, and the parts of the build that actually needed judgment.

That distinction mattered a lot, especially in client work. When you are shipping something real, responsibility does not disappear just because an AI tool helped generate part of the solution. I still had to make the technical decisions, verify the output, keep the code maintainable, and make sure the end result was dependable.

This project was one of the first times I really felt that AI could become a meaningful part of my workflow, not as a replacement for thinking, but as a tool that helped me execute faster and stay in flow.

Challenges and Tradeoffs

One of the main challenges in the project was balancing speed, cost savings, and quality. The whole point of the rebuild was to create a more efficient setup, but moving quickly only helps if the final result is stable and maintainable.

Another tradeoff came from the migration itself. When moving away from an existing platform, you have to decide what to preserve and what to leave behind. Not every piece of the old setup deserves to come with you, and part of the work is figuring out what actually matters to the client and to the site.

Using AI also introduced its own tradeoffs. It made iteration faster, but it also increased the need for careful review. Moving quickly can be useful, but only if you stay disciplined about correctness and long-term maintainability.

This project made those tradeoffs feel very tangible. The goal was never just speed. It was speed in service of a better outcome.

What I Learned

The biggest lesson from this project was that good freelance development is not always about building something bigger. Sometimes it is about solving a simple but expensive problem in the most practical way possible.

I also learned that hosting and platform decisions can matter just as much as the code itself. A client does not only benefit from what a site looks like or how it functions. They also benefit from lower costs, simpler maintenance, and a setup that actually matches their needs.

This project also taught me more about how AI fits into my workflow. Used well, tools like Cursor and Claude Code can be strong accelerators. They can help speed up execution, but they do not remove the need for judgment, review, and responsibility. If anything, client work makes those responsibilities even more important.

What I Would Do Differently

If I were doing the project again, I would probably plan the migration path a bit more formally from the start and document the before-and-after setup more clearly. That would make the transition easier to explain and make handoff even stronger for the client.

I would also spend more time standardizing how I use AI in a client workflow. This project showed me that these tools are useful, but it also made me think more carefully about where stronger manual review is needed and how to keep the process consistent.

More broadly, I think I would place even more emphasis on documentation and handoff. The technical work matters, but part of the value in freelance development is leaving the client with something that feels understandable and sustainable after the project is complete.

Final Thoughts

This project was a good reminder that freelance development is not just about building features. It is about identifying the right problem, making smart technical decisions, and delivering value in a way that actually helps the client.

In this case, that meant reducing unnecessary costs, rebuilding the site in a more practical way, and using AI tools to speed up execution without lowering the standard of the final product.

That combination made this project feel like an important step for me, both as a freelance developer and as someone starting to build a more AI-assisted workflow.