Building a fast website without knowing how to code

I didn’t set out to build a perfect website.

I set out to stop feeling frustrated while building my own.

The frustration

Here’s the part that still surprises people when I say it out loud.

I didn’t know Git. I’ve been using Linux for twelve years, but only at the level you need to get real work done. I know my way around the terminal. I don’t know code. I’m not a programmer, and I’ve never tried to be.

Most of my closest friends are programmers. They’re brilliant. They’re also always busy.

Whenever I thought about asking for help, the answer was always reasonable and familiar. “After this sprint.” “Once this deadline passes.” “Next week.” No drama. Just reality. Their time was never really available, and I didn’t want to build my site in the gaps of someone else’s schedule.

That was one of the reasons I decided to build a custom website myself. On my own terms. On my own timeline.

I’ve spent my career working as a marketer and strategist, usually somewhere between products, platforms, and performance dashboards. I can talk strategy all day. But when it came to building my own website, I was standing on the outside, looking in.

That’s where the frustration kicked in.

Every modern website conversation seems to assume you either become technical or you accept bloat as the price of entry. Heavy frameworks. Endless plugins. Animations that look clever but slow everything down. Consent banners are fighting for attention before a sentence is even read.

I didn’t want that.

I wanted a site that was fast by default. Secure without drama. Accessible without a checklist. Readable without tricks. SEO-ready because the fundamentals were solid, not because I’d stacked tools on top.

That meant saying no to many things marketers are supposed to say yes to.

No heavy animations. No visual noise. No dashboards full of charts I’d never act on. I chose to focus on reading, because reading is the job of this site.

It helped that I’m starting out. No legacy. No audience expectations. No pressure to optimise too early. The only analytics I plan to use is Cloudflare Analytics, and that’s a deliberate constraint, not a limitation.

I spend a lot of my time inside tools like Google Analytics, so this wasn’t a rejection of data. It was a reminder that strategy starts with the audience and the site’s job, not the other way around.

My job has always been to decide what should be built, not how every line is written.

The frustration wasn’t that I couldn’t build something complex.

It was that complexity had quietly become the default. And I wanted to see how far I could get by choosing the opposite.

If complexity were the default, what would happen if simplicity became a rule instead of a preference?

The constraint

I set one simple rule.

Build a personal website that scores 100 per cent on Lighthouse, without writing code, without growth tools, and without anything that competes with reading.

That meant optimising for speed, security, accessibility, and SEO. And deliberately not optimising for conversion, tracking, or persuasion.

No pop-ups. No ads. No consent banner. No heavy animations. No clever interactions that slow things down or distract from the words.

Just a fast, quiet, black-and-white website that does one job well. Let people read and decide for themselves what to do next.

Everything that didn’t serve that goal was out.

Everything that remained had to earn its place.

The failures

I didn’t get there in a straight line.

My first instinct was to compromise. To keep the constraint in theory, but quietly bend it while building.

I tried themes that promised speed but came bundled with opinions I didn’t need. I added tools “just in case”. I told myself I could start minimal and layer things on later.

Each time, the same thing happened.

The site got heavier. Decisions multiplied. Pages slowed down. I spent more time configuring than writing. The moment I introduced optional complexity, it stopped being optional.

The worst part wasn’t the technical friction.

It was the mental noise.

Every extra tool came with new questions. Should I track this? Should I optimise that? Should I redesign this because a metric dipped?

None of those questions made the site better to read.

At one point, I realised I was building a system to justify future optimisation rather than a place to publish thoughts clearly. That’s when it clicked that the constraint only works if it’s enforced brutally.

Minimalism doesn’t fail gradually. It fails the moment you negotiate with it.

So I rolled things back. I removed more than I added. I stopped preparing for a future version of the site that didn’t exist yet.

What finally worked wasn’t a smarter setup.

It was sticking to the rule, even when it felt uncomfortable.

The decision

The turning point wasn’t a breakthrough.

It was a refusal.

I stopped asking what else I could add and started asking what I was willing to live without.

I decided the site wouldn’t try to persuade. It wouldn’t interrupt. It wouldn’t optimise for behaviour I couldn’t see or control. If someone stays, they stay because the words are useful. If they leave, that’s fine too.

So I stripped it back.

No pop-ups. No ads. No consent banner. No heavy animations. No growth tools waiting in the background. Black text. White space. Pages that load before you have time to think about loading.

I chose to trust fundamentals. Clean structure. Predictable navigation. Content that respects attention instead of competing for it.

The decision wasn’t about purity.

It was about focus.

I wanted a website I’d enjoy opening myself. One that felt calm instead of performative. One that didn’t ask the reader for anything except a few minutes of attention.

Once that decision was made, everything else got easier.

There were fewer choices. Fewer trade-offs. Fewer reasons to second-guess.

The site stopped feeling like a technical challenge.

It started feeling like a place I was building deliberately.

What I gained

The first thing I noticed wasn’t a score or a metric.

It was calm.

Pages loaded instantly. Content felt light. I could read what I’d written without anything competing for attention. That alone changed how I felt about publishing before I’d even launched.

Speed stopped being an optimisation goal and became a baseline. Security came bundled, not bolted on. Accessibility improved almost accidentally, because simple structures are easier to navigate than clever ones. SEO followed the same pattern.

I also gained confidence. Not the loud kind that comes from dashboards going up and to the right, but the quieter kind that comes from understanding every decision on the page.

Another unexpected gain was freedom.

Without pop-ups or funnels to maintain, I could focus on writing. Without attribution models, I didn’t second-guess every sentence. Without growth experiments waiting in the background, there was no pressure to perform.

Cloudflare Analytics gives me just enough signal to stay curious, and not enough to become anxious.

And then there was enjoyment.

I like opening the site while it’s still unfinished. I like how it looks. I like how it behaves. For the first time in a long while, building my personal website doesn’t feel like assembling a marketing asset.

It feels like shaping something I’ll actually want to use.

What I gave up

I gave up certainty.

Without pop-ups, forms, or funnels, I won’t know who reads what. I won’t see intent. I won’t be able to nudge people back. If someone finds something useful and leaves quietly, I’ll never know.

I gave up attribution.

There will be no neat line connecting an article to a conversation. No retargeting. No sequences. No proof that a paragraph worked, other than trusting that it did.

I gave up optimisation.

At least the kind that feels productive because it’s measurable. I’m not A/B testing headlines. I’m not tweaking layouts to squeeze out another click. There’s nothing to tune, because there’s nothing trying to convert.

And I gave up control.

Letting people read without guiding them means accepting that their journey won’t look the way I’d design it.

That’s the trade.

In exchange for speed, clarity, and calm, I accepted ambiguity.

Right now, while I’m still building, that feels like the right bargain.

The practical choices

For anyone wondering what actually sits underneath this site, here’s the short, non-mystical version.

The site is fully static. No databases. No server-side logic. No runtime decisions. Just files served fast.

I’m building it with Astro and Tailwind CSS. Not because they’re trendy, but because they encourage restraint. Astro ships almost nothing by default. Tailwind keeps the design honest. If something looks heavy, it usually is.

I don’t write code line by line. I guide it. I use AI to move faster, test ideas, and translate intent into structure. The technique matters less than the judgment behind it.

Hosting is on Cloudflare Pages. HTTPS, caching, and security come bundled, without configuration sprawl or surprise decisions. Version control lives on GitHub, even though I’m still learning my way around it.

Where a form is unavoidable, I use Formspark. It exists only where it’s needed.

For email, I plan to use Resend. Simple, transactional, and out of the way.

Analytics are intentionally minimal. I work with Google Analytics daily, and it’s often the right choice. In this case, it wasn’t.

This site doesn’t need behavioural modelling or conversion analysis. It needs to load fast, be readable, and earn trust over time.

None of these tools is special.

The constraint is.

Who this is for

This approach isn’t for everyone.

It’s for people who write first and market second. People who care more about being understood than being captured. People who want their website to feel calm, fast, and honest.

It’s for independents and small teams at the beginning. When there’s no legacy to protect, no funnel to maintain, and no pressure to prove impact before clarity exists.

This is not for high-volume lead generation. It’s not for e-commerce. It’s not for teams with legal requirements or aggressive growth targets.

This is a choice, not a doctrine.

If your goal is to persuade, capture, and scale, this will feel frustrating.

If your goal is to publish clearly, build trust slowly, and let the work speak for itself, it might feel like a relief.

The quiet lesson

I didn’t learn how to build a website without code.

I learned how much disappears when you stop trying to control outcomes.

By removing layers as I built, I wasn’t just simplifying the site. I was simplifying my relationship with it. There was nothing to tweak, nothing to optimise, nothing to watch obsessively.

The Lighthouse score is not the point. It’s a side effect of choosing restraint.

This won’t be the final version of the site. Constraints change. Needs evolve. I’ll probably add things back in when they earn their place.

But starting here, before launch, taught me something I’ll carry into every future project.

Sometimes the fastest way forward is to remove pressure, not add tools.

And sometimes, the most respectful thing you can do for a reader is to get out of their way.

If you want more context on how I ended up thinking this way, I’ve written a bit more about my path here.