Ordinary Man Trying

AI Taught Me 17 Surprising Ways to Use GitHub for a One-Person Website Business

For a long time, I thought GitHub was basically Dropbox for programmers.

You write code, you upload it, other developers look at it.

That was about it.

Then I started building small websites.

One of my newest experiments is:

ChineseFortuneTools.online

It is not meant to be a huge business yet.

It is a laboratory.

I use it to test small tools, SEO ideas, Chinese culture content, landing pages, and experiments before deciding whether something deserves more time and money.

While building it, I slowly realized something:

GitHub is much more than a code repository.

For a solo website owner, GitHub can become part hosting platform, part database, part automation server, part analytics pipeline, part monitoring service, part API server, and even part product-management system.

And most of this can be done for little or no cost.

I am not talking about complicated enterprise DevOps.

I mean practical things a small website owner can actually use.

Here are 17 ways I now use — or plan to use — GitHub.

1. GitHub Pages Can Be a Free Website Host

The most obvious one is still surprisingly useful.

GitHub Pages can publish a static website directly from a repository.

That means HTML, CSS, JavaScript, images, and JSON files can become a real website without renting another server.

For example, I use:

ChineseFortuneTools.online

as an experimental website.

Instead of paying for another hosting account just to test ideas, I can build a tool, push it to GitHub, and put it online.

For experiments, calculators, landing pages, simple tools, documentation sites, and content-heavy static websites, that can be enough.

The important idea is not simply “free hosting.”

It is this:

Ideas can be tested before they deserve infrastructure.

If one experiment becomes popular, I can always move it later.

2. GitHub Actions Can Become a Free Robot Employee

This was the feature that changed how I looked at GitHub.

GitHub Actions lets code run automatically.

You can tell it:

  • run every day
  • run every Monday
  • run when code changes
  • run when I manually press a button

Then it can execute Python, JavaScript, shell scripts, APIs, or other tasks.

On my experimental site, I now have robots that can do things such as:

check SEO, collect analytics, monitor pages, generate files, take screenshots, and update data automatically.

That means GitHub is not only storing my website.

It is doing work for me.

For a one-person website business, that is much more interesting than code hosting.

3. GitHub Can Automatically Pull My GA4 Traffic Data

Normally, if I want to understand a website, I log into Google Analytics.

Then I check another website.

Then another.

This becomes annoying very quickly if you run many small websites.

So I connected Google Analytics to GitHub Actions.

Every day, a robot can query the GA4 API and collect data such as:

  • active users
  • sessions
  • tool usage
  • completions
  • sharing activity
  • outbound clicks

Then GitHub saves that data automatically.

For ChineseFortuneTools.online, this means my site can eventually judge which tools people actually use instead of which tools I personally think are interesting.

That is a big difference.

4. GitHub Can Pull Google Search Console Data Too

Traffic tells me what visitors do.

Search Console tells me how Google sees the site.

So I connected that too.

The robot can collect things such as:

impressions, clicks, CTR, search queries, and average rankings.

Now imagine this happening across many websites.

Instead of opening six Search Console properties manually, I could eventually have one dashboard telling me:

This page got 3,000 impressions but almost no clicks.

Or:

This keyword is ranking at position 11.4. Improve this page.

Or:

Google stopped showing this page.

That is where GitHub starts feeling less like a developer tool and more like a small business operating system.

5. JSON Files Can Work Like a Tiny Free Database

Not every website needs MySQL.

Not every project needs Supabase.

Not every experiment needs a backend.

Sometimes all I need is:

tools.json
metrics.json
ideas.json
festivals.json
zodiac.json

A static website can fetch those files directly.

For example, my experimental site stores information about tools in a JSON file.

A tool can have fields such as:

{
  "id": "gift-checker",
  "title": "Chinese Gift Checker",
  "stage": "beta",
  "status": "testing"
}

The website reads the data and builds the interface.

For public, read-heavy data that does not need complex user accounts or transactions, this can be wonderfully simple.

Of course, it is not suitable for passwords, private user information, or sensitive business data.

But for many small tools?

It works.

6. A JSON File Can Also Become a Free API

This was another mental shift for me.

An API does not always need a complicated backend.

If a public JSON file lives at:

/api/zodiac.json

another application can fetch it.

Congratulations.

You now have a very simple API.

For ChineseFortuneTools.online, I can expose structured datasets such as:

  • Chinese New Year dates
  • Chinese festivals
  • zodiac information
  • lucky numbers
  • gift taboos

A future tea website could expose:

/api/tea-types.json

A hot pot website could expose:

/api/broths.json

Static data + predictable URLs can be surprisingly powerful.

7. GitHub Issues Can Become a Lightweight Product Database

This is one of the stranger uses.

GitHub Issues are supposed to be used for bugs and feature requests.

But an Issue is also a structured object with:

  • a title
  • a description
  • labels
  • comments
  • reactions
  • dates
  • status

That starts to look suspiciously like a tiny database.

On an experimental website, a new tool idea can simply become an Issue.

For example:

“Build a Chinese Lucky Color Calculator”

Add the label:

idea

Now it is part of the product backlog.

No separate project-management SaaS required.

8. GitHub Reactions Can Become a Voting System

Once ideas are Issues, users can react to them.

A 👍 becomes a vote.

Then an Action can periodically read the Issues, count reactions, rank ideas, and generate a JSON file.

The website can display:

Community Ideas

with the most popular ideas first.

Suddenly GitHub is doing part of the work of a community voting platform.

For a serious social network, obviously this is not enough.

For a small experimental site?

It can be more than enough.

9. GitHub Can Be a Gold Mine for Product Research

This is one of the most valuable uses that has nothing to do with my own repository.

GitHub itself is an enormous public product-research database.

Suppose I want to build a recipe tool.

Instead of inventing every feature from scratch, I can study successful open-source projects.

I can look at:

  • what features they added
  • which features users request
  • what users complain about
  • what Issues keep appearing
  • which projects are still actively maintained
  • which ideas have many contributors

The interesting part is often not the source code.

It is the Issues section.

People are literally telling developers:

I need this.

This is confusing.

Please add this feature.

Why doesn’t this work?

That is free user research.

10. GitHub Is Also a Huge Open Data Warehouse

Thousands of projects publish useful data as:

  • JSON
  • CSV
  • YAML
  • SQLite databases
  • dictionaries
  • geographic datasets
  • food datasets
  • language datasets
  • public-domain collections

This can dramatically reduce the cost of building tools.

The important rule is obvious:

Open-source does not mean “steal anything you find.”

You still need to check licensing, attribution requirements, data rights, and whether commercial reuse is allowed.

But if the license permits it, GitHub can save weeks of manual data collection.

For a small website owner, that matters.

11. GitHub Secrets Can Safely Store API Keys

Suppose I want a robot to call Google, OpenAI, Gemini, or another API.

Putting the secret API key inside browser JavaScript would be a terrible idea.

Instead, GitHub has Secrets.

The website never sees the key.

The GitHub Action uses it privately.

For example:

GOOGLE_SERVICE_ACCOUNT_JSON
GA4_PROPERTY_ID
GSC_SITE_URL
AI_API_KEY

The robot can then do its work without publishing the credentials.

That creates some very interesting AI possibilities.

12. GitHub Actions Can Call AI in the Background

Most people think “AI website” means every user sends a prompt to an AI model in real time.

That can become expensive.

There is another model:

use AI before the visitor arrives.

For example, once per week GitHub Actions could ask AI to generate:

  • festival explanations
  • weekly zodiac summaries
  • name descriptions
  • cultural tips
  • structured FAQs
  • social-share descriptions

Then save the results as JSON or HTML.

One AI call can serve thousands of visitors.

That is very different from calling AI every time someone opens a page.

For many content tools, precomputation may be the smarter business model.

13. GitHub Can Run Automatic SEO Audits

Once Actions can run scripts, an SEO robot becomes possible.

Mine can check things such as:

  • page titles
  • meta descriptions
  • canonical tags
  • H1 tags
  • GA4 installation
  • structured data
  • broken links
  • sitemap health

If something important disappears, the robot can create an Issue.

Now instead of remembering:

I should probably check my websites this month.

the website checks itself.

That becomes especially valuable if I eventually run 10 or 20 small websites.

No human wants to manually inspect 20 sites every Monday morning.

Robots do not complain.

14. GitHub Can Take Automated Screenshots of My Websites

Code can break visually even when the page technically still works.

A navigation bar moves.

A mobile layout collapses.

A button disappears.

An image stretches across the screen.

So another useful automation is screenshot monitoring.

A GitHub Action can open selected pages and capture:

  • desktop screenshots
  • mobile screenshots

Then save them for later comparison.

This creates a visual history of the website.

If something suddenly looks wrong, I can compare today’s screenshot with last week’s version.

That is something I never imagined using GitHub for when I first created an account.

15. GitHub Can Become a Remote Control for Multiple Websites

Imagine having ten websites.

One tool suddenly breaks.

Do I want to edit ten separate deployments?

Not really.

Instead, I can maintain a central configuration file:

site-config/config.json

It might contain something like:

{
  "kill_switches": {
    "gift-checker": false
  }
}

A site reads the configuration.

The tool immediately appears disabled.

The same system could control:

  • maintenance banners
  • CTA text
  • affiliate links
  • seasonal messages
  • feature switches

One GitHub repository becomes a remote control panel for multiple websites.

That becomes much more useful as a portfolio grows.

16. GitHub Can Manage the Entire Life Cycle of an Experiment

I do not want every idea to become permanent.

Most ideas probably should die.

So my experimental tools can move through stages:

Lab
↓
Beta
↓
Stable
↓
Graduate

Or:

Lab
↓
No traffic
↓
Retire

The system can track:

  • launch date
  • traffic
  • Google impressions
  • clicks
  • usage
  • shares
  • outbound conversions

Then I can set rules.

For example:

Review every experiment after 60 or 90 days.

Or:

If a tool reaches 1,000 users and sends meaningful traffic to the main site, consider graduating it.

This changes website building from:

“I had an idea, so I built it.”

into:

“I run experiments, collect evidence, and keep the winners.”

That may be the most important lesson of all.

17. GitHub Can Become a One-Person Business Dashboard

This is the direction I am now moving toward.

Imagine this:

Website
   ↓
GA4
   ↓
Google Search Console
   ↓
GitHub Actions
   ↓
metrics.json
   ↓
Private Dashboard

Then I add:

ChineseNameCraft.com
ChineseFortuneTools.com
ChinaRules101.com
HotPot101.com
OrdinaryManTrying.com
ChineseFortuneTools.online

Every day the system collects data.

Eventually I want one screen that tells me:

Which website grew today?

Which page is losing traffic?

Which keyword is almost on page one?

Which experiment should I stop?

Which tool deserves more work?

Which site is actually making money?

At that point GitHub is no longer simply where my code lives.

It becomes the machinery behind a tiny internet business.

The Bigger Lesson: Cheap Tools Change What One Person Can Build

This is what I find most interesting.

A few years ago, building this kind of system might have required:

  • a developer
  • a server
  • a database
  • cron jobs
  • monitoring software
  • analytics integration
  • a CMS
  • deployment tools
  • DevOps knowledge

Today a single person can combine:

GitHub Pages + GitHub Actions + JSON + APIs + AI

and build a surprising amount of infrastructure.

Not everything should be built this way.

GitHub Pages is not a replacement for a real backend.

JSON files are not a replacement for a transactional database.

GitHub Actions is not an unlimited free cloud computer.

Public repositories should never contain secrets or sensitive business data.

And if a project becomes large enough, proper infrastructure will eventually make sense.

But that is not the point.

The point is that a new idea can start extremely small.

My New Rule for Small Website Experiments

I now think about new projects in this order:

Can this be static?
        ↓
Can JSON handle the data?
        ↓
Can GitHub Actions automate it?
        ↓
Can AI pre-generate the expensive part?
        ↓
Can I measure it with GA4 + GSC?
        ↓
Does real traffic justify more infrastructure?

Only after the answer becomes “yes, people actually want this” do I want to spend more money.

That feels like a much better way to build small internet businesses.

GitHub Is Not Just for Developers Anymore

I still barely use many advanced Git features.

I do not spend my days doing complicated rebases or memorizing terminal commands.

But I have started seeing GitHub differently.

To me, it is becoming:

a free hosting platform, automation engine, tiny database, API host, AI worker, monitoring system, experiment manager, and business dashboard.

All from a tool I originally thought was just a place to upload code.

And I suspect I have only discovered half of what is possible.

My current playground is:

ChineseFortuneTools.online

It is intentionally small.

Some experiments will fail.

Some may get no traffic at all.

But that is exactly why I built it.

The goal is not to make every idea successful.

The goal is to make experimentation cheap enough that I can afford to keep trying.

And GitHub turns out to be surprisingly good at that.

Final CTA

If you are also building tiny websites, side projects, or AI tools, I would be curious to know:

What is the strangest useful thing you have built with GitHub?

I am still learning — and I have a feeling there are many more hidden uses I have not discovered yet.

Leave a Reply

Your email address will not be published. Required fields are marked *