I Bought a Domain at 15. Now It Powers 400,000+ Users.

Edward Hsing — Wed, 18 Mar 2026 10:09:04 +0000

My name is Edward Hsing.

I’m 18, and I build internet infrastructure.

Today, something I started at 15 serves over 400,000 users, with more than 150,000 GitHub stars.

I was 15 when I bought a domain name.

I didn’t expect it to become something hundreds of thousands of people would end up using.

It wasn’t a startup.
It wasn’t a plan.

I just wanted to see what I could build.

At the time, getting a domain felt unnecessarily hard. It cost money, required setup, and for many people, it was simply out of reach.

That didn’t make sense to me.

So I started experimenting.

It Started With One Question

A friend asked me something simple:

“Can I use a subdomain under your domain?”

I said yes.

Then someone else asked.

And then another.

That was the moment it stopped being mine.

What began as a personal experiment quietly turned into something people started relying on in their projects.

Building Something That Didn’t Exist

There wasn’t a system for what I wanted to do.

No platform designed to let anyone register and manage domains freely, at scale.

So I built one.

That eventually became DigitalPlat FreeDomain - a platform that lets people register and manage domains freely, at scale.

I set up BIND9 on a small VPS.
Wrote my own backend in Python and Flask.
Connected everything directly to the DNS layer.

It wasn’t perfect.
It wasn’t elegant.

But it worked.

And people kept coming.

Growth Without Permission

There was no launch.
No marketing.
No funding.

Just developers sharing it with each other.

Hundreds of users turned into thousands.
Thousands turned into tens of thousands.

And eventually, something I built at 15 became infrastructure.

At some point, it stopped feeling like a project.

It felt like something people actually relied on.

Today, it serves over 400,000 users worldwide, with over 150,000 GitHub stars.

That still doesn’t feel real.

The Part No One Sees

People think building is the hard part.

It isn’t.

Keeping something alive is.

Running a free domain infrastructure means dealing with abuse at scale - spam, phishing, misuse.

You don’t get to ignore it. You have to design for it.

So I built systems to handle it:

Automated review pipelines.
Behavioral pattern scoring.
GitHub-based identity verification.
Structured abuse reporting and response.

Not to eliminate abuse completely - that’s impossible.

But to make sure everyone else can still use the system.

What This Was Really About

At some point, I realized this was never just about domains.

A domain is identity.

It’s the ability to exist on the internet — to build something, share something, create something that is yours.

And for a lot of people, that’s still harder than it should be.

I don’t think it should be.

Access to a digital identity shouldn’t be a privilege.

It should be a basic layer of the internet.

It Became Bigger Than Me

What started as something I built alone didn’t stay that way.

Some of the earliest users stayed.
They helped.
They contributed.

Today, people help manage reports, moderate discussions, and support the system.

It became something bigger than me.

And honestly, that’s the part I’m most proud of.

Looking Back

I didn’t set out to build infrastructure used by hundreds of thousands of people.

I just bought a domain and started experimenting.

But if you keep building - even when no one is watching, even when nothing is certain -

something small can turn into something that matters.

I’m 18 now.
I’m Edward Hsing.

And I’m still building things people rely on.

Because I believe the internet should be something people can access - not something they have to earn.

If you’re interested in how it works, the project is open on GitHub.

Running a Free Domain Infrastructure Serving 400,000 Users

Edward Hsing — Tue, 03 Mar 2026 18:12:34 +0000

I was 15 when I registered a four-letter domain name that no one had claimed. I used my savings to buy it, simply wanting to experiment with something interesting. I did not expect it to grow into a public domain infrastructure serving hundreds of thousands of users worldwide.

The idea started casually. A friend asked if they could use a subdomain under my newly registered domain. That question led me to open it to others for free, which became the US.KG Domain Registry and later expanded into a broader open infrastructure initiative under DigitalPlat Foundation.

There was no ready-made system designed for managing large-scale subdomain registrations. Public DNS providers imposed limits, and existing CMS tools were not built for this kind of dynamic delegation. I deployed BIND9 on a small VPS and built a custom management layer using Python and Flask, integrating it directly with the DNS backend.

Within months of launching, registrations grew quickly through organic sharing in developer communities. Growth was exciting, but it also introduced a new responsibility: operating abuse controls at scale.

Running a free domain platform means accepting that misuse will exist. The engineering challenge is building systems that remain stable, compliant, and fair to legitimate users while filtering malicious activity efficiently.

To handle abuse efficiently, I built an automated review pipeline that integrates domain registration events, GitHub identity signals, and abuse report intake into a unified workflow. Registrations are logged and scored based on behavioral patterns, while abuse reports are triaged through a structured ticket system. The goal is not to eliminate misuse entirely, but to reduce response time and limit blast radius.

Over time, the verification model evolved into a GitHub-based identity flow using OAuth. This reduced friction for developers while improving accountability and automation in abuse handling.

As the platform matured, the infrastructure expanded across multiple domains to improve resilience and operational flexibility. Today the system operates across several zones, supported by structured abuse workflows, ticket management, and community moderation.

One of the most important lessons has been that infrastructure is not only about uptime. It is also about governance. Clear policies, rapid response to reports, and consistent communication are as critical as technical configuration.

Some early community members later became long-term collaborators. They now help manage reports, discussions, and support processes. What began as a personal experiment has grown into a distributed effort focused on maintaining reliable and responsible open infrastructure.

DEV Community: Edward Hsing