In the previous post, I explained why I built a website on my own domain instead of using an all-in-one blogging platform.

This post covers the actual process: how an Astro project on my computer became a public website at hekate.work.

Build with Astro
→ Store the code on GitHub
→ Deploy with Cloudflare Pages
→ Connect a personal domain

1. Installing Node.js

Astro requires Node.js. Installing Node also provides npm, the package manager used to install and run JavaScript tools.

I verified the installation in PowerShell.

node --version
npm.cmd --version

Windows PowerShell can sometimes block the npm.ps1 script because of its execution policy. Using npm.cmd is a straightforward way to run the same npm command without changing that policy.

The installer also displayed a notice about a newer npm release. It was an update notification, not an error, so I first confirmed that the project worked with the installed version.

2. Moving to the right directory

My first Astro project creation attempt ran from C:\Windows\System32, which caused a permission error when it tried to create a new folder.

The problem was not Node.js or Astro. I moved to my user Documents directory and ran the setup again.

cd "$env:USERPROFILE\Documents"

PowerShell can show its current location with:

Get-Location

The error was simple, but it highlighted an important limitation of following AI-generated instructions. ChatGPT can reason from the commands and messages it receives, but it does not automatically know the current folder, terminal session, or last successful action on a user’s computer.

If someone focuses only on running the next suggested command, a small environmental issue may take longer than necessary. A tool may be installed correctly, yet the process can still appear stuck because the terminal is in the wrong directory or has not refreshed its path.

When asking AI for help, it is useful to include the current path, the exact command, the complete error, and the last step that worked.

3. Creating and running the Astro project

I created an Astro project called my-blog and selected the blog template. After setup, I entered the project directory.

cd "$env:USERPROFILE\Documents\my-blog"

Then I started the local development server.

npm.cmd run dev

Astro provided a local URL:

http://localhost:4321/

The terminal continued to display watching for file changes.... This was not a stalled process. It meant that Astro was running and waiting to refresh the site whenever a file changed.

4. Installing Git and tracking changes

After Git was installed, the PowerShell window that had been open before installation did not immediately recognize the git command. Running the executable through its full path confirmed that Git itself was installed correctly.

& "C:\Program Files\Git\cmd\git.exe" --version

Restarting PowerShell and Visual Studio Code refreshed the environment, and git --version worked normally.

Inside the project, I initialized a repository and created the first commit.

git init -b main
git add .
git commit -m "Initial commit"

Git displayed warnings that some LF line endings would become CRLF on Windows. These were compatibility notices rather than failed operations.

5. Pushing the project to GitHub

I created a GitHub repository called my-blog, connected it to the local project, and pushed the main branch.

git remote add origin https://github.com/hekatework/my-blog.git
git push -u origin main

The first push required browser authentication. After that, the normal update cycle became:

git add .
git commit -m "Describe the change"
git push

6. Deploying with Cloudflare Pages

In Cloudflare Pages, I connected my GitHub account and selected the my-blog repository.

The Astro build settings were:

Framework preset: Astro
Build command: npm run build
Build output directory: dist
Production branch: main

Cloudflare pulled the repository, built the static site, and first published it on my-blog-76n.pages.dev.

From that point on, every push to the main branch triggered a new deployment automatically.

7. Connecting the domain

I connected the hekate.work domain, purchased through Cloudflare, to the Pages project.

The domain initially appeared as Initializing or Verifying. This was not a failure; DNS records and the SSL certificate needed time to become active.

Once completed, both addresses worked:

https://hekate.work
https://www.hekate.work

8. The ongoing editing and deployment loop

I replaced the default Astro design with a personal homepage and portfolio. I added English and Korean pages, an about section, a language switch, and a custom social sharing image.

Every change follows the same loop:

Edit in Visual Studio Code
→ Review locally
→ Record the change with Git
→ Push to GitHub
→ Cloudflare deploys automatically
→ The update appears on hekate.work

AI still needs environmental context

ChatGPT was useful for finding commands and narrowing down errors. But the same command can behave differently depending on the current directory, terminal session, running server, permissions, and operating system configuration.

The most useful troubleshooting sequence was:

1. Check the current directory.
2. Confirm the installed version.
3. Read the complete error message.
4. Identify the last successful step.
5. Change one thing at a time.

The site’s foundation is now complete. Posts can be written in Markdown, saved to GitHub, and deployed automatically by Cloudflare Pages.

The initial setup involved several tools, but the publishing workflow is now simple:

Write
→ Save
→ Push to GitHub
→ Deploy automatically

The project gave me a practical understanding of how Node.js, Astro, GitHub, Cloudflare Pages, and DNS connect. It also showed that someone who can define requirements and evaluate outcomes can use AI to build and own a working website without being a professional developer.