GitHub Actions: Automating Your Website Updates

You know that scenario? Finish writing an article, open an FTP client, find the right directory on the server, manually upload files, then manually clear the cache. The whole process takes at least 10 minutes. If you're updating multiple articles or changing configuration, half an hour is normal. Even worse: sometimes you forget to upload a file and the site breaks. I dealt with this constantly when I started my content site. Eventually I couldn't take it anymore, dug into GitHub Actions, and automated the entire flow. Now, from finishing an article to having it live, I do just one thing — type git push and hit Enter. Everything else happens automatically.

GitHub Actions is an automation tool provided by GitHub. Simply put, it's a robot running in the cloud. You give it a set of instructions: when [event] happens, automatically execute [these actions]. The most common scenario: whenever I push code to the main branch, automatically install dependencies, build, and deploy to the server. No manual intervention needed. My setup with Vercel takes this to the extreme.

Why This Topic Matters

Compare the efficiency difference between automated and manual deployment. Traditional manual deployment: save the article file, open FTP to connect to the server (sometimes the connection fails), find the site root directory (with lots of subdirectories), upload the file, check for missed files, manually trigger build (if using an SSG framework), flush CDN cache. This whole dance takes at least 30 minutes per article. With GitHub Actions + Vercel, the flow becomes: git add, git commit, git push, then wait 30 seconds to 1 minute and the site is automatically updated. From 30 minutes to 5 seconds — a 360× efficiency improvement.

How to configure it? First, your project needs a repository on GitHub. Then create a .github/workflows directory at your repository root, and create a YAML file inside — you can call it deploy.yml. This file tells GitHub Actions when to do what. If you're using Vercel, it's actually even simpler — Vercel supports direct GitHub repository integration. You don't need to write complex deploy scripts. Just link your GitHub repo in Vercel, and Vercel automatically watches for push events on the main branch. Each new push triggers Vercel to pull code, install dependencies, build, and deploy to production. The entire configuration takes just a few minutes.

But if you're not using Vercel, or if you want to run additional checks before and after deployment, GitHub Actions is incredibly powerful. Here's my personal workflow: every time I push code to main, GitHub Actions first runs ESLint for code quality, then checks for dead links and incorrect internal links, then executes next build. If the build succeeds, it automatically deploys the output to Vercel. If the build fails, it sends a notification to my Feishu group. Even if I'm not at my computer, I know the deployment status.

Step 1: Find Your Positioning

Here's a real working workflow configuration example. Create .github/workflows/deploy.yml in your repository root. The content: name: "Deploy Website." on: push to branches: [main]. jobs: define a deploy job, runs-on: ubuntu-latest. Steps: checkout code, setup Node.js (version 18 or 20), npm ci to install dependencies, npm run build, deploy to Vercel (using vercel-action or directly via Vercel CLI). The key point: every step has explicit error handling — no situation where a failed build still tries to deploy.

For people managing articles in MDX, GitHub Actions can do even more. I wrote a script that checks all article files for proper frontmatter format and missing required fields. If a new article is missing a description or slug field, the build fails and I get a notification to fix it. This dramatically reduces deployment failures caused by formatting issues. I also added an automatic image compression step — each push scans the assets directory for new images, converts them to WebP format using the sharp library, and compresses them to under 200KB. This saves bandwidth and improves page speed.

Some might ask: if every push auto-deploys, what if I push buggy code? That concern is valid. GitHub Actions supports manual rollback. In Vercel's dashboard, you can see the complete deploy history. One click rolls back to any previous version. So you can push with confidence — if something breaks, just roll back.

Step 2: Build the System

Another very useful scenario is scheduled publishing. You might batch-write a bunch of articles on the weekend and want to space them out for daily publication. GitHub Actions' schedule trigger can help. Configure a cron expression in on.schedule in the workflow file — for example, publish one article every day at 3 AM. Place pending articles in a specific folder and use a script to automatically move one per day to the publish directory, then commit and push. Alternatively, manage this through branches: write articles on a dev or draft branch, then use a scheduled task to automatically merge specific content from the draft branch to main to trigger deployment.

My AgentClaw project is the best validation of this automation flow. From day one to now, every content update has been a single git push. Written articles, generated images, configuration changes — all managed through Git. The project has been running for months, with deployment success rates close to 100%. Occasional build failures are usually due to dependency version changes or code formatting issues — fix and re-push, takes just a few minutes.

There's another overlooked benefit of GitHub Actions: your project has a complete version history. Every article, every change, every atomic-level modification is clearly recorded in the Git log. If you accidentally delete a file or change something you shouldn't have, you can always git revert. This simply isn't possible with traditional FTP. Managing content changes with Git means every action is traceable and reversible. For a solo entrepreneur, that's a massive sense of security.

Step 3: Content Output

If you haven't set up GitHub Actions in your project yet, here's the lowest-cost starting plan. Change nothing. Just link your GitHub repo in the Vercel dashboard and enable auto-deploy. Vercel will automatically build and deploy after each push. First, experience that feeling of "push, stare at the screen for 10 seconds, refresh the page, and the content is updated." Once you're comfortable with Vercel's auto-deployment, then start layering on GitHub Actions' extra features like code checks, image optimization, and auto-notifications. Take it step by step — don't overcomplicate things at the start.

Some people deploy on self-hosted servers or cloud VPS. In that case, GitHub Actions still works — the deployment target just isn't Vercel anymore. In the last step of your workflow, you can transfer the built files to your server via SSH and remotely execute the service restart command. The prerequisite is that your GitHub repo needs SSH keys or a deployment token configured. More complex than Vercel integration, but the automation concept is identical.

Let's talk cost. GitHub Actions' free plan gives you 2,000 minutes per month — plenty for personal projects. I do roughly 100 deployments per month, each build taking about 2 minutes, totaling 200 minutes — well within the free tier. If you need more concurrency or longer run times, you can upgrade to Team plan, but the free tier is sufficient for a solo company. Vercel's free plan also has no deployment restrictions. So the entire automation pipeline costs zero.

Step 4: Traffic Acquisition

Let me summarize the core value GitHub Actions brings to a solo company. First, efficiency: from writing to publishing takes just one git push — no manual operations needed. Second, reliability: automation runs by fixed rules; no one forgets to upload a file. Third, traceability: every change has version records; roll back anytime if something goes wrong. If you're still deploying manually, I strongly recommend spending one hour setting up automated deployment. That one hour will save you countless 30-minute chunks in the future.

Long-term Strategy