You built something cool. Maybe it's a personal portfolio, a small React app, a landing page for your side project, or something you put together with an AI coding assistant over the weekend.

Now you want to share it with the world.

The good news? You don't necessarily need to buy a domain, rent a VPS, or manage a server just to put your project online.

In this guide, I'll show you how to deploy a website using Vercel and connect a free custom subdomain from Public Free Suffix (PFS).

The goal is simple: get a real, publicly accessible website running without paying for hosting or a domain.

What we're going to use

Just three things:

  • GitHub — to store your project's source code.
  • Vercel — to build and host the website.
  • Public Free Suffix (PFS) — to get a free subdomain with DNS management.

For this example, our final website address will look something like:

myproject.fs.kg

No paid hosting plan. No domain registration fee. No server maintenance.

There are still usage limits and service policies, which we'll cover later.

Step 1: Put your project on GitHub

If your code is already on GitHub, you can skip this step.

Otherwise, create a new repository and push your project.

For example:

git init git add . git commit -m "Initial commit" git branch -M main git remote add origin https://github.com/YOUR_USERNAME/YOUR_REPO.git git push -u origin main 

Replace the repository URL with your own.

If you're working with React, Vue, Astro, Next.js, or a simple static HTML project, Vercel can handle many common setups automatically.

One important thing: check that your project builds locally before deploying it.

And make sure you haven't accidentally committed API keys, passwords, or other secrets.

Step 2: Deploy your website on Vercel

Head over to:

https://vercel.com

Sign in and connect your GitHub account.

Then:

  1. Click Add New → Project.
  2. Import your GitHub repository.
  3. Check the framework and build settings.
  4. Add environment variables if your app needs them.
  5. Click Deploy.

Once the deployment finishes, Vercel provides a default URL, something like:

myproject.vercel.app

Your website is already online!

For personal projects and experiments, the free Hobby plan is often enough, provided your usage complies with its limits and non-commercial restrictions.

You can stop here if you're happy with the default address.

But what if you want something shorter or more personal?

Step 3: Get a free domain with PFS

This is where Public Free Suffix (PFS) comes in.

PFS is a community-driven, non-profit project that provides free subdomains for developers, students, hobbyists, and people who want to experiment with the web.

Project website:

https://publicfreesuffix.org

Instead of buying a domain, you can apply for an address such as:

myproject.fs.kg

PFS provides DNS management, including common record types such as A, AAAA, CNAME, MX, and TXT.

That means you're not tied to one hosting platform. You can use your subdomain with Vercel, another compatible hosting provider, or your own server.

How to apply

Visit the PFS website and open the domain application console.

Search for the name you'd like to use, select an available option, and follow the registration process.

A few requirements are worth knowing upfront:

  • PFS currently requires a GitHub account that's at least two years old for verification.
  • You need to put your domain to use within 30 days; unused domains may be reclaimed.
  • Domains are provided without annual registration fees, subject to the project's terms and acceptable-use rules.

For this tutorial, let's assume you successfully registered:

myproject.fs.kg

Now it's time to connect it to Vercel.

Step 4: Connect your free domain to Vercel

Go back to your Vercel dashboard.

Open your project, then navigate to:

Settings → Domains

Enter your new address:

myproject.fs.kg

Vercel will tell you which DNS records are required.

For a subdomain, this will typically involve creating a CNAME record pointing to the target Vercel provides.

Now open the PFS DNS management panel.

Create the CNAME record using the hostname and target supplied by Vercel.

The exact values matter, so use what Vercel shows for your project rather than copying an IP address or CNAME target from an old tutorial.

Save the record, then return to Vercel.

DNS changes aren't always visible immediately. Give them time to propagate and follow any additional ownership verification instructions Vercel displays.

When the configuration is valid, Vercel can automatically provision an SSL certificate.

Your website should then be accessible at:

https://myproject.fs.kg

And that's it. Your project now has a custom address without a hosting bill or domain registration fee.

Step 5: Verify that everything works

It's worth checking the DNS configuration yourself.

On macOS or Linux, you can use:

dig myproject.fs.kg CNAME 

You should see the CNAME target configured in your DNS panel.

You can also check whether the website responds over HTTPS:

curl -I https://myproject.fs.kg 

A successful response confirms the site is reachable, although your application may return different HTTP status codes depending on its configuration.

If the domain isn't working, check these things first:

  • Did you enter the full hostname in Vercel?
  • Does the DNS record match Vercel's recommended target?
  • Is there a conflicting A, AAAA, or CNAME record?
  • Is Vercel requesting an additional TXT record for ownership verification?
  • Has DNS propagation finished?

Most custom-domain problems come down to DNS configuration or incomplete verification.

Why bother with a custom domain at all?

You might be wondering why you need a custom address when Vercel already gives you a free vercel.app URL.

And that's a fair question.

You don't need one.

But a separate address can be useful if you want to:

  • Give your portfolio or personal website a memorable name.
  • Share a cleaner URL for an open-source project.
  • Use the same hostname when migrating between hosting providers.
  • Learn how real-world DNS configuration works.
  • Experiment with different platforms without registering a paid domain.

That last point is particularly interesting.

A domain name gives you an identity that's separate from the hosting provider. As long as you retain control of the name, you can change where it points.

Of course, a free subdomain is not the same as owning a registered top-level domain. You're relying on the operator of the parent domain, its policies, and its continued availability.

For a long-term business or mission-critical project, purchasing a domain you control more directly may still be the better decision.

For learning, prototypes, portfolios, and hobby projects, though, a free subdomain can be a practical starting point.

A little about why PFS exists

There's something I really like about the modern web development ecosystem: we've made it much easier to build and deploy things.

GitHub gives developers a place to collaborate. Platforms like Vercel make deployment accessible. Open-source frameworks have dramatically reduced the work needed to build an application.

But having an address for your project can still be an unnecessary barrier, especially for students, beginners, and people who just want to experiment.

PFS is an attempt to make that part a little easier.

It's not a replacement for every paid domain registrar, and it's not trying to make domain ownership irrelevant.

The idea is much simpler: people should have an accessible way to give their projects a home on the internet.

If someone wants to learn how DNS works, publish their first website, or test a project idea, they shouldn't necessarily have to spend money before they can begin.

That's the motivation behind making free subdomains available to the community.

A few things to keep in mind

Free doesn't mean unlimited.

Vercel has usage limits