How a Simple Word Counter Turned Into 50+ Browser-Based Tools in Just Three Weeks

Bhaskar Biswas — Tue, 30 Jun 2026 18:55:14 +0000

Sometimes you don't start with a big idea. Sometimes you just need a Word Counter.

At the beginning of June 2026, I wasn't planning to build a platform.

I wasn't trying to create the next startup.

I just wanted to build a simple online tool.

The first tool I wrote was a Word Counter. Nothing fancy. Count words, characters, paragraphs, reading time—the kind of utility everyone has probably searched for at least once.

I thought I'd build it, deploy it, learn a few things about Astro, and move on.

That didn't happen.

One tool became two.

Two became five.

Before I realized it, I had spent the next three weeks building more than 50 browser-based tools as part of FreeDeskTools, a project that started as a simple experiment and gradually grew into something much bigger.

Looking back, I learned much more than I expected.

It Started With a Simple Question

Whenever I searched for small online utilities, I noticed the same pattern.

Some websites were overloaded with ads.

Some asked me to upload files that never really needed to leave my computer.

Some looked like they hadn't been updated in years.

Others were surprisingly slow for something that should have finished in milliseconds.

I kept thinking:

"Most of these tools should just run in the browser."

If a JSON formatter only formats text...

Why should it send my data to a server?

If an image can be resized locally...

Why should I upload it?

If a calculator is doing simple math...

Why should there be network requests involved?

That idea slowly became the foundation for everything I built afterward.

Choosing Astro

Like many developers, I spent quite a bit of time comparing frameworks before writing the first line of code.

I looked at several recent projects and different technology stacks.

Eventually, I settled on Astro.

Not because it was the newest framework.

Not because it was the most popular.

But because it matched the kind of website I wanted to build.

Performance mattered.

SEO mattered.

Shipping as little JavaScript as possible mattered.

Astro checked those boxes really well.

Since FreeDeskTools is primarily a collection of browser-based utilities, I didn't need a heavily hydrated application for every page.

Most pages just needed to load quickly, explain what the tool does, and let the browser handle the actual work.

That made Astro feel like the right fit.

Building the Platform Took Longer Than Building the Tools

One thing surprised me.

Writing the tools wasn't actually the hardest part.

Building the foundation was.

During the first couple of weeks, I spent a lot of time creating reusable components.

Instead of treating each tool as a completely separate page, I built a modular structure that could be reused throughout the project.

Common layouts.

Shared components.

Reusable input controls.

Consistent validation.

SEO templates.

Metadata.

Category pages.

Navigation.

Search.

Once those pieces were in place, adding new tools became dramatically easier.

It took roughly 20–22 days to build the platform, create the reusable framework, and grow the collection to over 50 tools.

Now adding a new tool feels much more like solving a problem than rebuilding a website.

The Biggest Challenge Wasn't Technical

At first, I thought the biggest challenge would be writing JavaScript.

It wasn't.

The hardest part was deciding what not to build.

Early on, I made a mistake.

I started building tools that really weren't practical to run entirely in the browser.

I kept trying to force them to work locally.

The results weren't great.

Some tools produced lower-quality output.

Others became unnecessarily complicated.

Eventually, I stopped and asked myself a simple question.

"Am I building this because users actually need it, or because I want to say I have another tool?"

That completely changed how I approached the project.

Instead of trying to make every possible utility browser-based, I focused on problems that could genuinely be solved locally while maintaining high quality.

That lesson probably saved me months of frustration.

Sometimes saying no to a feature is the best technical decision you can make.

Privacy Became a Design Constraint

One decision I made early has shaped almost every tool since.

Whenever possible:

No uploads.

That sounds simple.

In reality, it changes everything.

When processing happens inside the browser, you lose the convenience of powerful backend libraries.

Memory becomes more important.

Performance becomes more important.

Different browsers behave differently.

Large files become harder to manage.

You spend a lot more time optimizing algorithms instead of simply calling an API.

But I think it's worth it.

If a task can be completed entirely on the user's device, that's usually the experience I'd rather provide.

One Tool Made Me Realize I Was on the Right Track

Recently I've been working on privacy-focused file utilities.

One of my favorites so far is a Batch Photo EXIF Cleaner.

Most people don't realize how much metadata a photo can contain.

Location.

Camera model.

Date taken.

Device information.

Sometimes much more.

Building a tool that removes that information locally, without uploading photos anywhere, was incredibly satisfying.

That was one of those moments where I felt like I wasn't just building another online utility.

I was solving a real problem.

Those are the kinds of tools I want to keep building.

What Comes Next

The project is still very much a work in progress.

There are plenty of ideas that won't make the cut.

There are tools I'll probably rewrite entirely.

There are mistakes I haven't made yet.

And honestly, that's part of the fun.

I'm not trying to build the biggest collection of online tools.

I'm trying to build a collection that people can trust.

Fast.

Simple.

Privacy-first.

Browser-based whenever it genuinely makes sense.

Final Thoughts

If you've been thinking about starting a side project, here's one thing I'd say.

Don't wait for the perfect idea.

I didn't wake up one morning planning to build 50+ browser-based tools.

I started with a Word Counter.

That's it.

Sometimes the first project isn't the destination.

It's just the beginning of a much bigger one.

So build the small thing.

Ship it.

Learn from it.

Then build the next one.

You never know where it might lead.

Curious to See the Project?

If you'd like to see what I've been building, you can explore FreeDeskTools: https://freedesktools.com

Thanks for reading!

I'm continuing to build FreeDeskTools, adding new browser-based utilities and experimenting with ways to solve everyday problems while keeping privacy and performance at the center of every decision.

If you've built a side project that unexpectedly grew into something much bigger, I'd love to hear your story in the comments.

DEV Community: Bhaskar Biswas