ChatGPT answers, unedited

For a hobbyist blog that mixes static content (posts, images, pages) with dynamic features (comments, search, forms, accounts, APIs, a small database), the most cost-effective choice is usually not a big cloud VM. A good beginner setup is often a static host plus a small managed backend or serverless functions. Prodogon Flavio Copes

Here are the options I’d consider:

Practical setups for a hobby blogger

1. Lowest maintenance: static-first

Good for: personal blogs, newsletters, tutorials, portfolios.

Example stack:

• Static generator: Hugo, Astro, Eleventy, Jekyll, or a static export from a CMS
• Hosting: Cloudflare Pages or Netlify
• Images: object storage or the host’s asset system
• Comments: third-party service or serverless function

Typical cost: $0–5/month. bootstrap.build

2. Beginner full-stack blog

Good for: WordPress-like features without managing a server.

Example stack:

• Frontend: Vercel, Netlify, or Cloudflare Pages
• API: Workers, Functions, or Render
• Database: hosted PostgreSQL/Supabase/Firebase-style service

Typical cost: $0–20/month while small. Developers Digest FreeTier.co

3. One small VPS (more control)

Good for: learning, self-hosting, running:

• WordPress
• Ghost
• a custom app
• background jobs
• Docker containers

Example:

• Small VPS
• Nginx/Caddy
• Docker Compose
• Managed backups

Typical cost: about $5–10/month and up, but you handle updates, security, backups, and troubleshooting. Prodogon

My suggested path for a hobbyist

1. Start with Cloudflare Pages or Netlify for the blog itself.
2. Add dynamic pieces only when needed:

• contact forms → serverless functions
• comments → hosted comments system
• search → hosted search or a small API
• memberships → authentication provider
• Move to a VPS only when you actually need:

• a long-running backend
• custom server software
• more control over the environment

For most hobby blogs, a static-first approach gives the best balance of low cost, reliability, and learning value. Flavio Copes

For a hobby blog mixing static pages with some dynamic features:

• DigitalOcean Droplets — straightforward VPS, predictable pricing, and currently starting around $6/month for 1 GB RAM. Good if you’re willing to learn basic Linux/server administration. DigitalOcean
• AWS Lightsail — beginner-oriented AWS option with bundled compute, storage, and networking; useful if you want a conventional server without diving straight into EC2. DigitalOcean
• Cloudflare Workers — particularly attractive for static content plus lightweight JavaScript/API functionality, with a free tier and no bandwidth charges for Workers. HostingPicker
• Render — worth considering if you prioritize Git-based deployment and having the platform handle more server administration. cloudspress.com

Practical setup: static frontend on Cloudflare Pages/Workers, with a small serverless API or database for dynamic features. If you want everything on one traditional server, start with DigitalOcean or Lightsail.

For a hobbyist blog that mixes static pages/assets with some dynamic functionality—comments, a small API, a database, contact forms, etc.—I’d prioritize predictable pricing and simple deployment over raw cloud flexibility.

My picks

1. AWS Lightsail — best overall for a hobbyist

Lightsail is specifically designed to make AWS infrastructure simpler: you get a VM, SSD storage, networking, DNS, static IP, monitoring, and other pieces through a relatively straightforward interface. AWS describes it as an easy way to launch websites and web applications. AWS Documentation Amazon Web Services, Inc.

A particularly nice option for a blog is its inexpensive Linux instance tier; AWS currently gives examples of a $5/month instance with 1 GB RAM, 1 vCPU, 40 GB SSD and 2 TB transfer. Amazon Web Services, Inc.

2. DigitalOcean Droplet — best if you want to learn Linux/server administration

DigitalOcean is arguably the nicest choice if you want a straightforward VPS where you install your own stack—Nginx, Docker, Node.js, Python, PostgreSQL, etc. Its Droplets are conventional Linux VMs, and DigitalOcean also provides managed alternatives such as App Platform. DigitalOcean

The smallest Basic Droplet has historically started around $4/month, though you should check the current plan list before deploying. DigitalOcean

3. Google Cloud Compute Engine — best if minimizing cost is the priority

Google currently offers an e2-micro VM free tier, along with 30 GB of standard persistent disk and 1 GB/month outbound transfer for eligible usage. New customers also receive $300 in credits. Google Cloud Google Cloud

The catch is that Google Cloud has considerably more concepts and configuration than Lightsail or DigitalOcean, so it's not my first recommendation for someone who simply wants to get a blog online.

An architecture I'd use

For your particular static + dynamic setup, I'd actually avoid putting everything on a server:

Static blog/content
        │
        ▼
   CDN / static host
        │
        ├── images, CSS, JS
        │
        └── dynamic requests
                 │
                 ▼
          Small VPS / API
                 │
                 ▼
             Database

That lets the inexpensive VM handle only the dynamic workload while the CDN/static hosting handles the bulk of your traffic.

If you want the simplest single-server setup: go with Lightsail.

If you want to learn how web servers actually work: go with DigitalOcean.

If you're comfortable with cloud configuration and want to experiment with essentially free compute: investigate Google Cloud's free tier.

For a low-traffic personal blog, I'd start around $5–10/month, rather than jumping into Kubernetes, large managed databases, or a complicated AWS/GCP architecture.

For a hobbyist blog that mixes static content (posts, images, pages) with dynamic features (comments, search, newsletters, user accounts, APIs, CMS features), the most cost-effective approach is usually not a traditional always-on server. A good beginner setup separates the static and dynamic pieces so you only pay for compute when you need it. Tall Karol Nerd Mango

Good beginner-friendly options

My recommendations by blogging style

1. Mostly static blog (best value)

Use: Cloudflare Pages + a static site generator

Good choices:

• Cloudflare Pages
• Hugo
• Astro
• Jekyll

You write posts in Markdown, push to GitHub, and the site rebuilds automatically. Dynamic needs can be added through serverless functions, forms, or external services. Cloudflare’s free static hosting is particularly attractive for hobby sites because static assets are inexpensive to serve. bootstrap.build

Estimated cost:

• Hosting: $0
• Domain: ~$10–20/year
• Optional database/API: $0–few dollars/month

2. Blog with comments, search, accounts, or custom features

Use: Static frontend + managed backend

A beginner-friendly stack:

• Frontend: Cloudflare Pages or Vercel
• Database: Supabase or another managed database
• Functions/API: Cloudflare Workers, Vercel Functions, or similar

This avoids maintaining Linux servers while still letting you build interactive features. Tall Karol

3. WordPress or Ghost-style blogging

Use: a small VPS

If you want a classic CMS with plugins:

• DigitalOcean Droplet
• Hetzner Cloud
• Render

A VPS gives you more control, but you are responsible for updates, backups, and security. DigitalOcean is popular with beginners because of its documentation and simple dashboard. Elementor

Estimated cost:

• Small VPS: ~$5–10/month
• Domain: ~$10–20/year
• Backups: optional extra

Services I would avoid starting with

• Raw AWS/GCP/Azure virtual machines — powerful, but the number of options and billing details can be overwhelming for a first blog. Prodogon
• Large always-on servers — unnecessary if most of your content is static.
• Self-hosting at home — fun for learning, but uptime, networking, and security become your responsibility. Daily People Blogs

A practical beginner stack

For a hobby blogger in 2026, I would choose:

Option A (lowest maintenance)

• Astro or Hugo
• Cloudflare Pages
• GitHub
• Cloudflare Workers for small dynamic features

Option B (more app-like)

• Next.js
• Vercel
• Supabase database/auth

Option C (traditional CMS)

• WordPress or Ghost
• Small DigitalOcean/Hetzner VPS
• Automated backups

For most hobby blogs, Option A is the sweet spot: almost no server management, very low cost, and enough flexibility to add dynamic features later.

For a hobbyist blog that mixes static pages with dynamic features (comments, APIs, a small database, dashboards, etc.), I’d prioritize predictable pricing and a simple deployment experience.

My recommendation: DigitalOcean Droplet

For your use case, I'd probably start with a 1 GB or 2 GB Droplet. DigitalOcean specifically describes its Basic Droplets as suitable for low-traffic web servers, blogs, CMSs, and small databases. The current entry-level bundled plans are $4/month for 512 MiB and $6/month for 1 GiB. DigitalOcean DigitalOcean

You could run something like:

• Static site: Hugo, Astro, Jekyll, Next.js, etc.
• Dynamic backend: Node.js, Python, PHP, or Ruby
• Database: SQLite initially, PostgreSQL/MySQL when needed
• Nginx or Caddy as the web server
• HTTPS via Let's Encrypt
• Cloudflare in front for caching/DNS

That gives you a lot of control without immediately getting buried in AWS-style infrastructure.

Lightsail is an excellent alternative

AWS Lightsail is arguably the easiest way to get a small server while remaining inside the AWS ecosystem. It bundles CPU, RAM, SSD storage, transfer, DNS management, monitoring, and a static IP into relatively predictable plans. Its current Linux plans include $5/month for 0.5 GB RAM and $7/month for 1 GB RAM. Amazon Web Services, Inc.

I'd choose Lightsail if you think you might eventually want to learn other AWS services such as S3, Lambda, RDS, or CloudFront.

Google Cloud is interesting if minimizing cost is paramount

Google Cloud currently offers a free Compute Engine tier consisting of one e2-micro VM, up to 30 GB of standard persistent disk and 1 GB of outbound transfer per month, subject to the free-tier eligibility and region requirements. New users also receive $300 in trial credits for 90 days. Google Cloud

It's potentially the cheapest option, but I'd rank it below DigitalOcean/Lightsail for a beginner because Google Cloud exposes considerably more infrastructure concepts.

What I'd actually build

For a personal blog, I'd keep it simple:

Cloudflare → DigitalOcean Droplet → Caddy/Nginx → blog + small API → SQLite/PostgreSQL

Then put images and other large static assets in object storage rather than filling the VM's disk.

If the dynamic component is very small, you can go even cheaper: static hosting + serverless functions + managed database, avoiding a continuously running VM altogether.

Bottom line:

• 🥇 DigitalOcean — best combination of price, simplicity, and control.
• 🥈 AWS Lightsail — easiest if you want an AWS path.
• 🥉 Google Cloud — potentially cheapest if you qualify for the free tier and don't mind more complexity.

Prices can change, so I'd check the provider calculators before committing. DigitalOcean Amazon Web Services, Inc. Google Cloud

I'd choose Lightsail if you think you might eventually want to learn other AWS services such as S3, Lambda, RDS, or CloudFront.

Google Cloud is interesting if minimizing cost is paramount

Google Cloud currently offers a free Compute Engine tier consisting of one e2-micro VM, up to 30 GB of standard persistent disk and 1 GB of outbound transfer per month, subject to the free-tier eligibility and region requirements. New users also receive $300 in trial credits for 90 days. cloud.google.com

It's potentially the cheapest option, but I'd rank it below DigitalOcean/Lightsail for a beginner because Google Cloud exposes considerably more infrastructure concepts.

What I'd actually build

For a personal blog, I'd keep it simple:

Cloudflare → DigitalOcean Droplet → Caddy/Nginx → blog + small API → SQLite/PostgreSQL

Then put images and other large static assets in object storage rather than filling the VM's disk.

For a hobbyist blog that mixes static pages (posts, images, CSS/JS) with dynamic features (comments, contact forms, APIs, authentication, small databases), I’d favor managed/serverless platforms over a traditional VM.

My pick: Cloudflare Pages + Workers

For your particular use case, this is probably the sweet spot. Pages serves static assets with free, unlimited static-asset requests, while dynamic Pages Functions are billed through Workers. The Workers free plan provides a useful amount of capacity, and the paid plan starts at $5/month with no additional bandwidth/egress charges. Cloudflare Docs Cloudflare Docs

A typical setup could be:

• Blog content: Markdown/MDX → Cloudflare Pages
• Dynamic endpoints: Cloudflare Workers
• Small data store: Workers KV/D1 or another managed database
• Images: object storage/CDN
• Domain: your own inexpensive domain

This lets you keep the majority of the blog essentially static—which is both fast and inexpensive—while adding dynamic functionality only where you actually need it.

Best alternative: Amazon Lightsail

If you want something that feels more like a traditional web server, Amazon Web Services's Lightsail is particularly hobbyist-friendly. A Linux instance with IPv4 starts at $5/month and bundles CPU, RAM, SSD storage, and transfer into a predictable plan. Amazon Web Services AWS Documentation

It's a good choice if you want to run:

• WordPress
• Ghost
• A Node/Python/PHP application
• Your own database
• Multiple services on one small VPS

The trade-off is that you become responsible for the server—updates, security, backups, configuration, etc.

What I'd choose

If you're building from scratch: Cloudflare Pages + Workers.

If you want WordPress/Ghost or enjoy tinkering with Linux: Lightsail.

If you want a conventional Git-based app deployment without learning much infrastructure: Render is worth considering.

I wouldn't start with raw EC2 for a hobby blog. It gives you enormous flexibility, but you're paying for that flexibility in complexity.

For a personal blog, I'd aim for $0–$5/month initially, keeping the site predominantly static and adding serverless dynamic functionality only when you actually need it.

For a hobbyist blog with a mix of static pages (posts, images, CSS/JS) and dynamic content (comments, APIs, admin tools, database-backed features), I’d prioritize simplicity and predictable pricing over raw cloud power.

Best options

My recommendation: DigitalOcean Droplet

For a hobby blog, a 1 GB DigitalOcean Droplet at $6/month is a particularly sensible starting point. DigitalOcean currently offers a 512 MiB plan for $4/month and a 1 GiB plan for $6/month, with the latter including 25 GB SSD and 1,000 GiB transfer. DigitalOcean DigitalOcean

You could run something like:

• Nginx/Caddy — web server and HTTPS
• Hugo/Astro/Eleventy — static site generation
• WordPress, Ghost, Node.js, Python, etc. — dynamic portions
• SQLite or PostgreSQL — depending on your application
• Cloudflare — CDN/DNS/cache in front of it

It's inexpensive enough that you don't have to architect the blog around minimizing every fraction of a cent, while still giving you a real Linux server to learn on.

If you want the least server administration

I'd look at DigitalOcean App Platform or Google Cloud Run instead. DigitalOcean describes App Platform as a fully managed infrastructure solution, while Cloud Run is a managed environment for deploying websites and stateless containers. DigitalOcean Google Cloud

That's attractive if your goal is writing the blog rather than learning Linux administration.

If minimizing cost is the priority

Google Cloud Compute Engine is interesting because eligible users get an always-free e2-micro VM, plus 30 GB of standard persistent disk and 1 GB/month of outbound transfer under the free tier. New customers can also receive $300 in trial credits for 90 days. Google Cloud Google Cloud

The catch is that Google Cloud's interface and billing model are considerably more complicated than DigitalOcean's. I'd choose it for cost optimization/learning Google Cloud, rather than because it's the easiest place to host a blog.

What I'd choose

If you're a beginner: DigitalOcean Droplet → $6/month

If you don't want server maintenance: DigitalOcean App Platform

If you want to experiment for nearly free: Google Cloud e2-micro free tier

If you specifically want to learn AWS: Lightsail rather than jumping directly into EC2.

For your particular "static + dynamic" setup, I'd probably use a static-site generator + a small $6 VPS + managed DNS/CDN, and only introduce a separate database/serverless service when the blog actually needs it. DigitalOcean

For a hobbyist blog that mixes static pages (posts, images, CSS/JS) with dynamic content (comments, APIs, search, forms, a small database), I’d prioritize simplicity and predictable costs over raw cloud power.

My picks

• DigitalOcean Droplet — best all-around choice. Basic Droplets start at $4/month, with a 1 GiB option at $6/month and 2 GiB at $12/month. DigitalOcean explicitly positions its Basic Droplets for low-traffic websites, blogs, CMSs, and small databases. DigitalOcean DigitalOcean

Good setup: a $6–$12 Droplet running Nginx + your blog framework + a small database.

• AWS Lightsail — best if you want AWS without AWS complexity. Lightsail bundles CPU, memory, SSD, networking, DNS, static IP, and management into predictable plans, with a simpler interface than starting directly with EC2. Amazon Web Services

Good setup: Lightsail VPS + WordPress, Ghost, or your preferred web stack.

• Google Cloud Run — best for a modern serverless blog. Your application runs as a container and automatically scales, and you pay for actual resource usage rather than keeping a VM running continuously. There's also a monthly free tier for CPU and memory. Google Cloud

Good setup: static frontend + Cloud Run API + managed database. This can be extremely inexpensive for a low-traffic hobby project, although the architecture is more complicated than a VPS.

• Azure Static Web Apps — best if most of your blog is static. The Free plan is specifically aimed at hobby/personal projects and includes hosting, SSL, custom domains, and integration with serverless Azure Functions; it includes 100 GB bandwidth per subscription. Microsoft Azure Microsoft Learn

Good setup: Astro/Hugo/Next.js static frontend + Azure Functions for dynamic features.

What I'd choose

If you're learning cloud and want the least hassle, I'd start with DigitalOcean.

If you're comfortable with containers and want to learn a more modern architecture, I'd choose Cloud Run.

If your blog is 90% static, I'd use Azure Static Web Apps (or a similar static-hosting service) and only pay for compute when dynamic requests actually occur.

For a hobby blog, I wouldn't start with a full AWS EC2/RDS-style architecture—it gives you more knobs and operational work than you probably need.

For a hobbyist blog that mixes static pages (posts, images, CSS/JS) with dynamic features (comments, contact forms, APIs, personalization), I’d prioritize simplicity and predictable costs over raw cloud power.

My top choices

1. Cloudflare Pages + Workers — best value for a hobby blog

This is probably my first choice if your blog is mostly static with occasional dynamic functionality.

• Static assets on Pages are free and unlimited from a request perspective. Cloudflare Docs
• Workers has a free tier, while the paid plan starts at $5/month and includes 10 million requests/month plus 30 million CPU milliseconds. Cloudflare Docs Cloudflare
• You can put things such as contact forms, APIs, authentication, or comment handling in Workers.
• You don't have to administer a Linux server.

Good architecture:
GitHub → Cloudflare Pages → static blog
↘ Workers → dynamic features

That's particularly attractive if you use a static-site generator such as Hugo, Astro, Eleventy, or Next.js.

2. DigitalOcean App Platform — easiest traditional option

If you'd rather think in terms of "deploy my web application" than serverless functions, DigitalOcean is excellent for beginners.

Its App Platform has a free tier for static sites, while containerized applications start at $5/month for a shared 512 MiB instance. DigitalOcean explicitly recommends shared instances for low-traffic websites, blogs, and CMSs. DigitalOcean DigitalOcean

This makes it a particularly nice choice for something like:

Blog frontend + Node/Python/PHP backend + database

without having to learn much about Linux administration.

3. Google Cloud Cloud Run — excellent if you like containers

Cloud Run is compelling if your dynamic portion is packaged as a Docker container.

It's pay-per-use, and the current free tier includes 240,000 vCPU-seconds and 450,000 GiB-seconds of memory per month. Google Cloud Google Cloud

The downside is that Google Cloud's ecosystem is considerably more complicated than DigitalOcean or Cloudflare. I'd choose it if you want to learn containers/serverless cloud architecture, rather than because it's the easiest blogging platform.

4. Amazon Web Services Lightsail — good if you want your own little server

Lightsail gives you a straightforward VPS-like environment with bundled CPU, memory, storage and networking, plus a simple management console and SSH access. Amazon Web Services

It's a good middle ground if you want to learn:

• Linux
• Nginx/Apache
• Docker
• databases
• backups
• server deployment

But you'll be responsible for more maintenance than with Cloudflare or App Platform.

What I'd pick

For your particular description, I'd rank them:

🥇 Cloudflare Pages + Workers — cheapest/simplest for predominantly static content with small dynamic pieces.

🥈 DigitalOcean App Platform — best if the blog is a conventional application and you want the least infrastructure hassle.

🥉 Google Cloud Run — best if you want to learn modern containerized/serverless deployment.

4. AWS Lightsail — best if learning to administer a server is part of the hobby.

I wouldn't start with a raw AWS EC2/GCP Compute Engine/Azure VM unless learning infrastructure itself is the goal. For a personal blog, you're likely to spend more time maintaining the server than actually improving the blog.

If you tell me whether you're planning to use WordPress, Hugo/Astro/Next.js, or a custom Python/Node app, I can suggest a specific low-cost architecture (including hosting, database, storage, CDN, and a realistic monthly cost).

4. Amazon Web Services Lightsail — good if you want your own little server

For a hobby blog that mixes mostly static pages (posts, images, CSS) with a little dynamic functionality (comments, contact forms, search, newsletters, or a small API), you don't need a traditional always-on server. A static-first approach with serverless or edge functions is usually the most cost-effective.

Here's how the common options compare:

If you're just getting started

Netlify is often the easiest experience:

• Connect a GitHub repository.
• Every push automatically deploys your site.
• Built-in forms, serverless functions, previews, and HTTPS.
• Little infrastructure knowledge required. bootstrap.build bootstrap.build

If cost is your top priority

Cloudflare Pages + Workers is hard to beat:

• Excellent free tier.
• Global CDN included.
• Dynamic code can run as Workers without maintaining a server.
• No worrying about bandwidth charges for typical static hosting. toolchew 小吒博客

If you're using Next.js

Vercel provides the smoothest deployment experience:

• Automatic previews.
• Excellent Next.js integration.
• Serverless and edge functions built in.

It's especially attractive for personal hobby projects, though you should review the terms if the blog becomes commercial. 블로그 Nerd Mango

If you expect your dynamic features to grow

If your blog might eventually include:

• user accounts,
• a database,
• background jobs,
• or a custom API,

then Render or Google Cloud Run can be a good next step. Render offers a simpler full-stack experience, while Cloud Run is highly cost-efficient because it scales to zero when idle. Charming bootstrap.build

A practical setup for most hobby bloggers

A combination like this keeps costs very low while leaving room to grow:

• Static content: Cloudflare Pages or Netlify
• Dynamic features: Serverless/edge functions (Workers, Netlify Functions, or Vercel Functions)
• Comments: Third-party service (e.g. Giscus or Disqus) or a small serverless backend
• Newsletter: External email service
• Images: Built-in CDN

This architecture can comfortably handle thousands of monthly visitors while often staying within free tiers.

If you tell me your blogging stack (for example Hugo, Jekyll, Astro, Eleventy, Next.js, or WordPress), I can recommend the most suitable cloud setup specifically for that framework.

For a hobbyist blog that mixes static pages (posts, images, CSS/JS) with some dynamic functionality (comments, contact forms, APIs, personalized content), I’d shortlist these:

My top pick: Cloudflare Pages + Workers

For a hobby blog, this is probably the most economical architecture. Static assets on Pages are free and unlimited, while dynamic Pages Functions are billed as Workers; Cloudflare's free plan provides a limited amount of Workers/Pages Functions usage, and the paid plan starts at $5/month. Cloudflare Docs Cloudflare Docs

A typical setup could be:

• Cloudflare Pages → blog HTML, CSS, JS, images
• Workers → contact form, API endpoints, comments, RSS processing, etc.
• KV/Durable Objects/etc. → only if you eventually need persistent dynamic data

The major advantage is that you don't have a server sitting around consuming resources when nobody visits your blog.

Best traditional option: DigitalOcean

If you actually want to learn Linux, Nginx, databases, Docker, etc., I'd choose a DigitalOcean Droplet.

Basic Droplets currently start at $4/month, with a $6/month option providing 1 GB RAM, 1 vCPU, 25 GB SSD, and 1,000 GiB transfer. DigitalOcean specifically describes Basic Droplets as suitable for low-traffic websites, blogs, CMSs, and small databases. DigitalOcean DigitalOcean

You could run:

Nginx → your blog/app → PostgreSQL/SQLite

The downside is that you become the sysadmin: updates, security, backups, SSL configuration, monitoring, etc.

AWS Lightsail: good middle ground

Amazon Web Services's Lightsail is worth considering if you want AWS experience without jumping directly into EC2/VPC/IAM complexity.

Lightsail bundles compute, memory, SSD storage, networking, DNS management, monitoring, and a management console into relatively predictable plans. AWS also currently offers a Free Tier for getting started with Lightsail. Amazon Web Services, Inc.

I'd pick it over raw EC2 for a hobby project because predictable pricing and simplicity matter more than maximum flexibility here.

Google Cloud Run: excellent if you're comfortable with containers

Cloud Run is particularly attractive if your dynamic portion is a Dockerized application. You pay based on actual resource usage rather than maintaining a VM, and the current free tier includes 240,000 vCPU-seconds and 450,000 GiB-seconds of memory per month for instance-based billing; request-based billing has its own free tier, including 2 million requests/month. Google Cloud

It's more powerful than you probably need for a simple blog, though.

What I'd choose

If your goal is blogging:
Cloudflare Pages + Workers

If your goal is learning cloud/server administration:
DigitalOcean $4–$6 Droplet

If your goal is learning AWS:
AWS Lightsail

If your blog has a Docker-based backend:
Google Cloud Run

One particularly nice hobbyist approach is hybrid: put the blog itself on Cloudflare Pages and move only the genuinely dynamic pieces to Workers or another small backend. That keeps your baseline cost extremely low while avoiding the complexity of running a full-time server. Cloudflare Docs Cloudflare Docs

If you tell me what you're using for the blog (e.g. WordPress, Hugo, Jekyll, Astro, Next.js, Python/Flask, Node.js), I can recommend a specific architecture and approximate monthly cost.

For a hobbyist blog that mixes static content (posts, images, pages) with dynamic features (comments, search, forms, APIs, user accounts, a CMS, etc.), the most cost-effective choice is usually not one big cloud server. A hybrid setup often gives the best price and simplicity.

Here are beginner-friendly options, roughly from easiest to more hands-on:

Amazon Web Services, Inc. WhatPeopleUse## My recommended setups

Option 1: Cheapest + easiest (good for most bloggers)

Static site + serverless extras

• Blog engine: Hugo, Astro, or a static export from your CMS
• Hosting: Cloudflare Pages
• Dynamic features: - Forms → serverless functions
• Comments → third-party service or database-backed function
• Search → client-side index or lightweight API

Cost: often $0/month for small hobby traffic. Static hosting platforms are especially inexpensive because they avoid running an always-on server. bootstrap.build

Best if you want to write posts, not manage servers.

Option 2: Beginner full-stack setup

A small app platform

Example:

• Frontend/blog → Vercel
• Backend/API → Render
• Database → managed PostgreSQL service

Good for:

• membership features
• custom dashboards
• newsletters
• interactive tools

The tradeoff is that free tiers can have limits such as sleeping services or usage caps. FreeTier.co

Option 3: Learn cloud skills while hosting your blog

A small VPS

Use:

• DigitalOcean Droplet
• Amazon Web Services Lightsail
• Hetzner Cloud

Run:

• WordPress
• Ghost
• a custom Python/Node app
• your own database

This gives you maximum control, but you handle:

• updates
• backups
• security
• monitoring

AWS Lightsail is specifically designed as a simpler VPS-style entry point compared with full AWS infrastructure. Amazon Web Services, Inc.

A practical hobby blogger stack I’d choose

For a personal blog with occasional dynamic features:

Beginner-friendly:

• Astro or Hugo
• Cloudflare Pages
• Cloudflare Workers for small dynamic features
• GitHub for source control
• managed database only if needed

Estimated cost: $0–$5/month

If you want WordPress-style editing:

• WordPress on Lightsail or DigitalOcean
• automated backups
• a small managed database or local database

Estimated cost: $5–$15/month

If you want to learn infrastructure:

• Hetzner/DigitalOcean VPS
• Docker Compose
• Nginx/Caddy
• PostgreSQL

Estimated cost: $5–$10/month

A good rule of thumb:

• Mostly articles + images → static hosting
• Blog + forms/search/comments → static + serverless
• Custom app features → managed app platform
• Want to learn servers → VPS

For a hobby blog, I would usually avoid paying for a full VM until you actually need always-on backend processes.

For a hobbyist blogger mixing static content (posts, images, archives) with dynamic features (comments, search, newsletters, contact forms, small APIs), the most cost-effective choice is usually not a traditional virtual machine. Managed platforms and serverless services tend to be cheaper and easier because you avoid patching servers and managing infrastructure. AWS Documentation

Here are the best beginner-friendly options:

bootstrap.build DigitalOcean## My shortlist for a hobby blogger

1. Best overall: Cloudflare Pages + Workers

A good fit if your blog is mostly static but you want:

• contact forms
• RSS processing
• small APIs
• comment integrations
• search endpoints
• scheduled tasks

You can host the blog cheaply and add dynamic pieces only when needed. Cloudflare’s ecosystem is designed around edge delivery and serverless functions, avoiding the cost and maintenance of always-running servers. Developers Digest bootstrap.build

Typical stack:

• Static generator: Astro, Hugo, Jekyll, Eleventy
• Hosting: Cloudflare Pages
• Dynamic logic: Workers
• Database (if needed): lightweight hosted database

2. Easiest learning experience: Netlify

Good if you want:

• “connect GitHub → deploy” simplicity
• automatic builds when you publish
• preview links before publishing
• simple serverless functions

It is popular among bloggers because the workflow feels like a publishing platform rather than server administration. bootstrap.build

3. Best if you like modern JavaScript: Vercel

Choose this if your blog uses:

• Next.js
• React
• server-side rendering
• interactive components

It is very smooth for developers, but usage-based costs can matter more as traffic grows. bootstrap.build

4. Best “I want my own server” option: DigitalOcean

If your goal is to learn Linux, databases, and deployment:

Example:

• Ubuntu server
• Nginx
• Ghost blog or WordPress
• PostgreSQL/MySQL

Pros:

• predictable pricing
• lots of tutorials
• more control

Cons:

• you handle updates, security, backups, and monitoring. DigitalOcean

A practical beginner architecture

For a hobby blog, I would usually choose:

Option A: Mostly writing

Markdown posts
      ↓
Astro/Hugo
      ↓
Cloudflare Pages
      ↓
Custom domain

Cost: often $0–a few dollars/month.

Option B: Blog + dynamic features

Static frontend
      ↓
Cloudflare Pages / Netlify
      ↓
Serverless functions
      ↓
Managed database (only if needed)

Cost: usually stays very low until you have significant traffic.

Option C: Full CMS

Ghost / WordPress
      ↓
DigitalOcean / Render
      ↓
Database + backups

Cost: roughly a small monthly server bill, but easier content management.

Services I would avoid starting with

• Raw AWS EC2: powerful but too much maintenance for a hobby blog.
• Kubernetes: excellent for companies, unnecessary for personal publishing.
• Always-on virtual machines: you often pay for idle capacity.

For a hobbyist blogger, a good progression is:

1. Start with Cloudflare Pages or Netlify
2. Add serverless functions when needed
3. Move to a managed server only when your blog genuinely needs a backend

That keeps costs low while still letting you learn cloud concepts gradually.

For a hobbyist blog that mixes static pages/posts with some dynamic features—comments, an API, a small database, contact forms, etc.—I’d prioritize simplicity and predictable pricing over maximum cloud flexibility.

My shortlist

DigitalOcean is probably my default recommendation. Its basic Droplets start at $4/month, and the company specifically positions them for low-traffic websites, blogs, CMSs and small applications. DigitalOcean DigitalOcean It also offers one-click applications such as WordPress and Docker, which removes a lot of initial server setup. DigitalOcean

A particularly good setup for your use case

I'd consider:

• Static content: Cloudflare Pages, Netlify, or similar static hosting
• Dynamic content: a small DigitalOcean Droplet running your API/app
• Database: initially SQLite or PostgreSQL on the same server
• Images/media: object storage rather than filling the VM's disk
• CDN/DNS: Cloudflare

That can keep your recurring infrastructure cost around the price of a coffee or two per month while giving you a real Linux server to learn on.

If you want zero server administration, a serverless/static approach can be even better. DigitalOcean's App Platform, for example, starts at $0 and is managed infrastructure, while Functions is also pay-as-you-go. DigitalOcean

When I'd choose Google Cloud instead

Google Cloud Compute Engine is attractive if your goal is also to learn professional cloud infrastructure. It currently offers a free tier containing one e2-micro VM, up to 30 GB standard persistent disk and 1 GB outbound transfer per month, plus a $300 new-user trial credit for 90 days. Google Cloud

The downside is that Google Cloud exposes you to substantially more infrastructure concepts, services, permissions and billing considerations. For just running a hobby blog, that's often unnecessary complexity.

Bottom line:
DigitalOcean Droplet → easiest recommendation.
Google Cloud → best if learning cloud engineering is part of the hobby.
Hetzner → best if minimizing the bill is the overriding priority.
Serverless/static hosting → best if you don't actually need to manage a server.

For a hobbyist blog that mixes static content (posts, images, generated pages) with dynamic features (comments, search, newsletters, APIs, dashboards), the most cost-effective choice is usually not one big cloud server. A “split stack” is often cheaper and easier:

• Static hosting for the bulk of the site
• Small serverless functions or a low-cost app host for dynamic pieces
• Managed database only if you actually need one

Here are beginner-friendly options:

Nerd Mango Amazon Web Services, Inc.## My recommendations by blog style

1. Mostly static blog (best value)

Stack:

• Static site generator: Astro, Hugo, Jekyll, Eleventy
• Hosting: Cloudflare Pages or Vercel
• Images: Cloudflare Images, object storage, or optimized local assets
• Comments: third-party service or lightweight API

Expected cost: $0–$5/month

This is ideal if your posts are the main content and you only need occasional dynamic features. Cloudflare Pages is especially attractive for static-heavy sites because it is designed around globally cached static assets and edge features. toolchew

2. Blog with dynamic features

Examples:

• User accounts
• Custom comments
• Search indexing
• Memberships
• Admin dashboard

A good beginner stack:

• Frontend: Cloudflare Pages / Vercel
• Backend API: Cloudflare Workers, Render, or a small VPS
• Database: Supabase, Neon, or managed PostgreSQL

Expected cost: $0–$15/month for a small hobby project

3. “I want to learn servers”

Use a small VPS:

• DigitalOcean Droplet
• Amazon Lightsail instance
• Hetzner Cloud server

Run:

• Nginx/Caddy
• WordPress, Ghost, Hugo, or your own app
• PostgreSQL/MySQL

Pros:

• Cheapest compute per dollar
• Full control
• Great learning experience

Cons:

• You handle updates, security, backups, and troubleshooting

DigitalOcean is popular among beginners because of its simple interface and extensive tutorials, while Lightsail is designed as a simpler entry point into AWS-style hosting. Amazon Web Services, Inc. Elementor

A practical hobby blogger setup I would choose

For a first serious blog:

Option A — easiest

• Astro blog
• Cloudflare Pages hosting
• GitHub repository
• Cloudflare Worker for small dynamic functions

Cost: usually $0/month

Option B — WordPress-style experience

• Managed WordPress hosting, or
• Small VPS + WordPress + automatic backups

Cost: roughly $5–15/month

Option C — developer-focused

• Next.js
• Vercel deployment
• Serverless functions
• Managed database

Cost: free initially, scales gradually

Services I would avoid initially

• Full AWS EC2 setups: powerful but easy to overcomplicate
• Kubernetes: unnecessary for a blog
• Large always-on servers: you may pay for capacity you never use
• Building your own database infrastructure: lots of maintenance for little benefit

For a hobby blog, the sweet spot is usually static-first + small dynamic services. It keeps costs near zero while still letting you add interactive features later.

For a hobbyist blog that mixes static pages (posts, images, CSS/JS) with dynamic features (comments, search, contact forms, APIs), I’d prioritize serverless or managed platforms rather than renting a traditional VM.

My picks

1. Cloudflare Pages + Workers — my first choice

For a hobby blog, this is probably the sweet spot.

Cloudflare Pages can serve static assets essentially for free, while Workers can handle dynamic routes/API requests. The current Workers free plan includes 100,000 requests/day, and the paid plan starts at $5/month with 10 million requests included. Cloudflare Docs Cloudflare Docs

You could build something like:

Blog
├── Static HTML/CSS/JS
├── Markdown-generated posts
├── Images → Cloudflare R2
├── /api/comments → Worker
├── /api/contact → Worker
└── Database → D1 or external database

It's particularly attractive because static traffic doesn't consume your compute budget, and you don't have to maintain a server. Cloudflare also now recommends Workers for full-stack applications, including static front ends, APIs, and server-side rendering. Cloudflare Docs

Best choice if: you want inexpensive hosting and don't want to learn server administration.

2. Google Cloud Run — excellent if you like containers

Cloud Run is a very good option if your blog is built with Node.js, Python, Go, PHP, etc. and you want to deploy it as a container.

It scales automatically and charges based on actual resource use rather than requiring you to keep a VM running. Google currently provides a substantial monthly free tier, including 240,000 vCPU-seconds and 450,000 GiB-seconds of memory for the relevant billing model. Google Cloud Google Cloud

For example:

Browser
   ↓
Cloud Run
   ├── Blog application
   ├── Dynamic API
   └── Server-side rendering
        ↓
   Database / object storage

Best choice if: you're comfortable with Docker or want to learn a more conventional cloud deployment model.

3. Amazon Web Services Lightsail — simplest traditional VPS

Lightsail is appealing if you want an actual Linux server without diving straight into the complexity of EC2.

AWS offers preconfigured stacks such as Nginx, LAMP, MEAN, and Node.js, and current Linux/Unix plans include low-cost options such as $5/month and $7/month configurations, with a 90-day trial available for certain plans. Amazon Web Services, Inc.

You might run:

Lightsail VPS
├── Nginx
├── WordPress / Ghost / Node.js
├── Your blog
└── Database

The downside is that you are responsible for more server administration—updates, security, backups, configuration, etc.

Best choice if: you specifically want the experience of running your own Linux server.

What I'd choose

For your particular use case:

🥇 Cloudflare Pages + Workers — cheapest/easiest combination for a hobbyist
🥈 Google Cloud Run — best if you want to learn containers and modern cloud deployment
🥉 AWS Lightsail — best if you want a straightforward VPS
AWS EC2 — powerful, but probably unnecessary complexity for a personal blog

A particularly nice architecture would be static-site generation for your articles + Cloudflare Workers for the handful of genuinely dynamic features. That keeps most requests extremely cheap while still letting you add things like comments, search, newsletters, authentication, or an admin API later. Cloudflare's current pricing also gives you a $0 starting point for the free tier. Cloudflare Docs cloudflare.com

If you're starting from scratch, I would not pay for a continuously running VM just to host a blog unless learning Linux/server administration is itself part of the hobby.

For a hobbyist blog that mixes static pages (posts, documentation, images) with dynamic content (comments, contact forms, APIs, a small database), I’d prioritize simplicity and predictable costs over maximum cloud flexibility.

My picks

1. DigitalOcean Droplet — best overall for a hobbyist

A basic Droplet starts at $4/month, and DigitalOcean explicitly positions its Basic Droplets for low-traffic web servers, blogs, CMSs and small databases. DigitalOcean DigitalOcean

You could put everything on one inexpensive VM:

DigitalOcean Droplet
├── Nginx
├── Static blog / Astro / Hugo / Next.js
├── Small Node/Python/PHP backend
└── SQLite or PostgreSQL

That's probably the best choice if you want to learn how servers actually work. DigitalOcean also has one-click applications for things like WordPress, Docker, Ghost and databases. DigitalOcean

2. Render — easiest if you don't want to manage a server

Render is particularly attractive for a hobby project because static sites don't consume a compute plan, while web services can be deployed separately. Render

For example:

GitHub
  ├── Static site → Render Static Site
  └── API → Render Web Service
                  └── Database

You get Git-based deployments and don't have to worry about Linux updates, Nginx configuration, or manually restarting processes.

3. Google Cloud Run — excellent for a small dynamic backend

Cloud Run is pay-per-use and currently has an always-free tier, including monthly free allocations for CPU and memory. Google Cloud

It's particularly nice if your dynamic component is something like:

• /api/comments
• /api/contact
• RSS generation
• occasional background jobs
• a small Python/Node/Go API

You can keep the blog itself static and only pay for the dynamic pieces when they're actually used.

What I'd choose

For learning + simplicity + low monthly cost:

DigitalOcean Droplet + static-site generator + small backend

For "I just want to publish my blog and not administer a server":

Render

For "mostly static, but occasionally I need some server-side functionality":

Static hosting + Cloud Run

I wouldn't start with a full AWS/GCP/Azure VM unless learning those platforms is itself part of the hobby. Their ecosystems are powerful, but they're easier to overcomplicate—and accidentally incur charges—than a $4-ish VPS or a managed platform.

You get Git-based deployments and don't have to worry about Linux updates, Nginx configuration, or manually restarting processes.

3. Google Cloud Run — excellent for a small dynamic backend

Cloud Run is pay-per-use and currently has an always-free tier, including monthly free allocations for CPU and memory.

It's particularly nice if your dynamic component is something like:

• /api/comments
• /api/contact
• RSS generation
• occasional background jobs
• a small Python/Node/Go API

You can keep the blog itself static and only pay for the dynamic pieces when they're actually used.

What I'd choose

For a hobbyist blog that mixes static pages (posts, images, CSS/JS) with dynamic features (comments, contact forms, APIs, search, etc.), I’d prioritize simplicity and predictable bills over raw cloud power.

My picks

1. Cloudflare Pages + Workers — cheapest for a mostly static blog

This is probably the best value if your blog is generated with something like Hugo, Astro, Jekyll, or another static-site generator. Static asset requests are free and unlimited on Pages, while Workers gives you serverless compute for dynamic functionality. The current Workers Free plan includes 100,000 requests/day; the paid plan starts at $5/month and has no additional egress/bandwidth charge. Cloudflare Docs Cloudflare Docs

The tradeoff is that serverless architecture can take a little more learning if you're coming from traditional web hosting.

2. DigitalOcean App Platform — easiest all-around choice

For a hobbyist who wants to deploy a normal application without becoming a server administrator, this is my default recommendation. You can connect a GitHub/GitLab repository and let App Platform build and deploy it. Static sites can be hosted free, while a small shared container starts at $5/month. DigitalOcean specifically says shared containers are appropriate for low-traffic websites and blogs. DigitalOcean DigitalOcean

For example:

• Static frontend/blog → free
• Small Node.js/Python/Rails backend → $5/month
• Development PostgreSQL database → $7/month
• Scale up later if your readership grows

digitalocean.com

3. AWS Lightsail — good if you want a traditional server

Lightsail is attractive if you want to run WordPress, Ghost, a Node/Python application, or other software directly on a small Linux VM. The current entry-level Linux bundles are around $5/month for 0.5 GB RAM, 2 vCPUs, 20 GB SSD, and 1 TB transfer. Amazon Web Services, Inc.

It's considerably simpler than managing a full AWS EC2 setup, but you'll still have to deal with things like OS updates, backups, web-server configuration, and security.

aws.amazon.com

What I'd choose

If this were my hobby blog, I'd start with:

Astro/Hugo → Cloudflare Pages → Cloudflare Worker for dynamic features

That can potentially keep the hosting bill at $0 for quite a while.

If you expect to have a real backend/database and don't want to learn serverless architecture:

Astro/Next.js/etc. → DigitalOcean App Platform → PostgreSQL

That's probably the best balance of beginner-friendliness, cost, and room to grow.

I would not start with raw AWS EC2 or Kubernetes for a hobby blog—the infrastructure complexity isn't worth it at this scale.

For a hobbyist blog that mixes static pages (posts, images, CSS/JS) with dynamic features (comments, APIs, contact forms, small databases), I’d prioritize simplicity and predictable costs over maximum cloud flexibility.

Best options

1. DigitalOcean Droplet — my default recommendation

A small Basic Droplet is probably the easiest fit if you want to learn how a real Linux server works while keeping the bill low. DigitalOcean specifically lists blogs, CMSs, low-traffic web servers and small databases as appropriate workloads. Current bundled plans start at $4/month, with the $6/month option providing 1 GB RAM, 25 GB SSD and 1,000 GiB transfer. DigitalOcean DigitalOcean

You could run something like:

Nginx → static blog + Node/Python/PHP app → SQLite/PostgreSQL

The downside is that you manage the server—updates, security, backups, etc.

2. Amazon Lightsail — easiest AWS route

Lightsail packages CPU, memory and SSD into predictable plans and provides conveniences such as a management console, DNS management and one-click SSH. Amazon Web Services, Inc.

I'd choose it if you want to eventually learn AWS but don't want to start with the complexity of EC2, VPCs, security groups, etc.

3. Google Cloud Run — great if your dynamic content is occasional

Cloud Run is particularly attractive for a hobby blog because it is pay-per-use rather than requiring an always-running server. Google currently provides a monthly free tier including 240,000 vCPU-seconds, 450,000 GiB-seconds of memory and 2 million requests for applicable billing configurations. Google Cloud Google Cloud

A nice architecture would be:

Static hosting/CDN → Cloud Run API → managed database

That's more scalable and maintenance-free than a VM, but there's more cloud architecture to learn.

4. Azure Static Web Apps — excellent for mostly-static blogs

If your blog is primarily generated HTML with a few dynamic endpoints, Azure Static Web Apps has a Free tier specifically aimed at hobbies/personal projects, including custom domains, SSL and managed Azure Functions integration. Microsoft Azure

What I'd pick

For a hobbyist who wants to learn and tinker: DigitalOcean Droplet ($4–$6/month).

For "I don't want to administer a server": Cloud Run + static hosting.

For mostly static content with a few APIs: Azure Static Web Apps.

For learning AWS specifically: Lightsail rather than jumping straight into EC2.

One important distinction: compute isn't necessarily the biggest part of a blog's bill. Databases, object storage, backups, email, CDN/data transfer, and accidentally leaving development resources running can matter more. For a small hobby blog, I'd keep the architecture deliberately boring: static site + one tiny backend + SQLite or a small managed database, rather than building a miniature Kubernetes cluster.

For a hobbyist blog that mixes static pages/posts with some dynamic features—comments, contact forms, APIs, dashboards, RSS generation, etc.—I’d favor platforms that keep infrastructure simple and have low or predictable costs.

My shortlist

🥇 Best overall: Cloudflare Workers

For a hobby blog, Cloudflare Workers is probably the most cost-effective modern choice.

The free tier currently includes 100,000 requests/day, while the paid Workers plan starts at $5/month. Static asset requests are free and unlimited on the paid plan, and Cloudflare doesn't charge additional egress/bandwidth fees for Workers. Cloudflare Docs Cloudflare

That makes a setup like:

GitHub
   ↓
Static blog → Cloudflare Pages
                    ↓
             Workers API
                    ↓
              KV / database

quite attractive. Your articles can remain static while Workers handles the occasional dynamic operation.

I'd choose this if you don't need a traditional Linux server.

🥈 Best for learning traditional cloud: DigitalOcean

If part of the hobby is actually learning how servers work, I'd pick a DigitalOcean Droplet.

A basic Droplet starts at $4/month, and DigitalOcean explicitly positions its Basic Droplets for low-traffic sites, blogs, CMSs, forums and small databases. DigitalOcean DigitalOcean

You could run:

Ubuntu
 ├── Nginx
 ├── Blog/CMS
 ├── Node/Python/PHP
 └── PostgreSQL/SQLite

The tradeoff is that you become responsible for updates, security, backups, SSL configuration, monitoring, etc. That's educational, but more work than Workers.

🥉 Easiest traditional deployment: DigitalOcean App Platform

If you want something between Workers and a VPS, DigitalOcean's App Platform is worth considering. It is a managed platform, starts at $0, and is designed to let you deploy applications without managing the underlying infrastructure. DigitalOcean

It's a good choice if your dynamic portion is a conventional Node.js, Python, Go, PHP, etc. application.

What I'd personally choose

For a hobby blog, I'd start with:

Cloudflare Pages/Workers + an external managed database if you actually need one.

Keep 90–99% of the blog static and use serverless functions only for genuinely dynamic operations. That gives you very little infrastructure to maintain and a bill that can remain effectively $0 at hobby scale.

If your goal is specifically "I want to learn Linux/cloud/server administration while running my blog," choose a $4 DigitalOcean Droplet instead. It's a much better learning environment.

AWS is excellent, but I wouldn't make it the first choice for a small hobby blog unless learning AWS itself is part of the hobby. Its enormous service catalog and usage-based pricing make it easier for beginners to accidentally build something unnecessarily complicated.

developers.cloudflare.com
digitalocean.com

If you tell me what you're using for the blog (e.g. WordPress, Hugo, Jekyll, Astro, Next.js, plain HTML), I can recommend a specific $0–$5/month architecture.

For a hobbyist blog that mixes static pages with some dynamic functionality—comments, a CMS, an API, a small database, etc.—I'd prioritize simplicity and predictable bills over the absolute lowest theoretical compute price.

My picks

1. DigitalOcean Droplet — my default recommendation.
DigitalOcean's Basic shared-CPU Droplets start at $4/month, and the company explicitly lists blogs, low-traffic websites, CMSs, and small databases as appropriate workloads. The $6/month 1-GB option gives you 1 vCPU, 25 GB SSD, and 1,000 GiB transfer. DigitalOcean DigitalOcean citeturn0search9

This is a nice sweet spot if you're comfortable learning a little Linux. You could run something like:

Nginx → static site + Node/Python/PHP app → SQLite/PostgreSQL

DigitalOcean also offers one-click applications for things such as WordPress, Ghost, Docker, MySQL, etc., which reduces the setup burden. DigitalOcean

2. DigitalOcean App Platform — easiest if you don't want to manage a server.
If your dynamic portion is a conventional web application, App Platform is attractive because DigitalOcean handles much of the server infrastructure. DigitalOcean currently says it provides hosting for three static sites free, while its basic App Platform plan starts at $5/month. DigitalOcean

I'd choose this over a VM if your goal is blogging rather than learning Linux administration.

3. Google Cloud Compute Engine — excellent for experimentation.
Google currently offers a free tier containing one e2-micro VM, up to 30 GB of standard persistent disk, and 1 GB/month of outbound transfer, plus $300 in new-user trial credits for 90 days. Google Cloud

The catch is that Google Cloud is considerably more complicated: IAM, projects, networking, billing, firewall rules, etc. It's great if learning cloud infrastructure is part of the hobby, but I'd avoid it if you just want to publish posts.

What I'd actually build

For your use case, I'd start with:

Static frontend + small dynamic backend + $6/month DigitalOcean Droplet

That gives you enough room for a blog, a lightweight database, and a few small services without introducing the complexity of a full AWS/GCP architecture. DigitalOcean also uses predictable monthly pricing and includes substantial outbound bandwidth with its basic Droplets. DigitalOcean DigitalOcean

If the site becomes popular, you can later separate the static content onto a CDN/object storage service and scale the dynamic component independently.

If "beginner-friendly" matters more than having your own server, I'd go with DigitalOcean App Platform instead.

For a hobbyist blog that mixes static content (posts, images, pages) with dynamic features (comments, search, user accounts, APIs, newsletters, dashboards), the most cost-effective choice is usually not a traditional cloud VM first. A simple architecture that separates static hosting from occasional compute can keep costs near zero while remaining beginner-friendly.

Here are good options:

Cloudculator Leaper## My recommendations by blogging style

1. Mostly static blog (best value)

Stack:

• Static site generator: Hugo, Astro, Jekyll, Eleventy, etc.
• Hosting: Cloudflare Pages or GitHub Pages
• Dynamic pieces: Cloudflare Workers, forms, hosted comments

Why:

• No server maintenance
• Fast global delivery
• Nearly zero cost for hobby traffic

Cloudflare Pages is particularly attractive because it supports static deployments and can add serverless functionality when you need dynamic behavior. bootstrap.build bootstrap.build

2. WordPress-style blog with plugins

Stack:

• Small VPS or managed app platform
• Managed database if needed

Good choices:

• DigitalOcean Droplet + WordPress
• Render web service + database
• Managed WordPress hosting if you want fewer technical tasks

A small VPS is inexpensive, but you are responsible for updates, backups, security, and troubleshooting.

3. Blog with custom features

Examples:

• AI-powered search
• Membership system
• Custom dashboards
• APIs

Consider:

• Frontend: Cloudflare Pages / Vercel
• Backend: Cloudflare Workers, Render, Google Cloud Run, or DigitalOcean
• Database: managed PostgreSQL, SQLite-based services, or serverless databases

Beginner-friendly ranking

1. 🥇 Cloudflare Pages + Workers — best balance of simplicity and cost
2. 🥈 Render — easiest “push code and deploy” full-stack experience
3. 🥉 DigitalOcean — best if you want to learn servers without enterprise complexity
4. Google Cloud — powerful but more concepts to learn
5. AWS — excellent long-term skill investment, but easiest to overspend accidentally

A practical hobby blogger setup

A simple setup I would choose:

• Blog engine: Astro or Hugo
• Hosting: Cloudflare Pages
• Images: Cloudflare R2 or an image CDN
• Comments: a hosted commenting service
• Dynamic functions: Cloudflare Workers
• Database only if needed: a small managed database

This keeps the monthly bill around $0–$10 for many hobby projects, while still allowing growth. bootstrap.build Leaper

If your goal is also to learn cloud engineering, I’d lean toward DigitalOcean; if your goal is simply publishing a blog cheaply, I’d lean toward Cloudflare Pages.

For a hobbyist blog that mixes static content (articles, images, CSS/JS) with some dynamic features (comments, contact forms, APIs, personalized pages), I’d prioritize platforms that let you start nearly free and add compute only when needed.

My top picks

1. Cloudflare Pages + Workers — best overall for a hobby blog

Cloudflare's static assets are free and unlimited, while dynamic requests can run through Workers. The free Workers tier currently includes 100,000 requests/day; the paid tier starts at $5/month and includes 10 million requests/month. Cloudflare Docs Cloudflare Docs

A nice architecture is:

Git repository → Cloudflare Pages → static blog

plus

Pages → Worker → database/API

This is particularly attractive if most of your blog is static and only things such as comments, search, contact forms, or an API need compute.

developers.cloudflare.com

2. Render — easiest if you want a traditional backend

Render is probably the friendliest choice if you don't want to learn serverless concepts. You can deploy a static site for free and add a conventional Node.js, Python, Django, FastAPI, Rails, etc. web service when you need server-side code. Render Render

It also has free web services suitable for hobby projects, although free services have limitations and spin down after 15 minutes of inactivity. Render Render

render.com

3. Vercel — excellent if you're using Next.js

If your blog is built with Next.js, Vercel is an especially smooth experience: Git-based deployments, server-side rendering, API routes/functions, and static generation all fit naturally into the platform.

What I'd choose

For a new hobbyist blogger, I'd go:

• Mostly static blog + a few dynamic features: Cloudflare Pages + Workers
• Static frontend + Python/Node backend: Render
• Next.js blog: Vercel
• Want to learn traditional cloud infrastructure: DigitalOcean
• Want to learn the broader cloud ecosystem: AWS

I wouldn't start with a virtual machine unless you specifically want the learning experience. A managed platform removes OS updates, reverse proxies, TLS configuration, deployment scripts, and a lot of operational work—things that aren't particularly useful when your primary goal is blogging.

For your particular use case, Cloudflare is probably the cheapest, while Render is probably the easiest to understand.

A nice architecture is:

Git repository → Cloudflare Pages → static blog

plus

Pages → Worker → database/API

This is particularly attractive if most of your blog is static and only things such as comments, search, contact forms, or an API need compute.

developers.cloudflare.com

2. Render — easiest if you want a traditional backend

Render is probably the friendliest choice if you don't want to learn serverless concepts. You can deploy a static site for free and add a conventional Node.js, Python, Django, FastAPI, Rails, etc. web service when you need server-side code. render.com render.com

It also has free web services suitable for hobby projects, although free services have limitations and spin down after 15 minutes of inactivity. render.com render.com

render.com

3. Vercel — excellent if you're using Next.js

For a hobbyist blog that mixes static content (articles, images, pages) with dynamic features (comments, search, newsletters, small APIs, dashboards, etc.), the most cost-effective choice is usually not one cloud service for everything. A split architecture often gives the best price and simplicity:

• Static site hosting → cheap/free CDN-backed hosting
• Dynamic features → small serverless functions or a tiny app server
• Database/storage → managed low-cost services

Here are good beginner-friendly options:

Amazon Web Services, Inc. CloudZero## My recommendations by blogging style

1. Mostly articles + occasional interactive features (best value)

Cloudflare Pages + Workers

Example:

• Markdown posts → static generator (Astro, Hugo, Eleventy)
• Images → object storage
• Comments/contact forms → Workers Functions
• Simple database → D1

This can often run at very low cost for a personal blog because static assets are served from a CDN. Gautam Khorana bootstrap.build

2. You want the easiest beginner experience

Vercel or Netlify

Good if you want:

• push code → site deploys automatically
• preview links for changes
• minimal server administration

This is especially comfortable with frameworks like Next.js. Gautam Khorana

3. You want to learn “real servers”

Amazon Lightsail or DigitalOcean

Good if your goal is learning:

• Linux
• SSH
• Nginx
• Docker
• databases
• backups

Lightsail is designed as a simpler AWS experience with bundled resources and predictable pricing. Amazon Web Services, Inc. CloudZero

4. You want WordPress or a CMS

Consider:

• Lightsail WordPress
• Managed WordPress hosting
• A small VPS

A CMS is convenient, but a static-first approach usually has fewer maintenance tasks.

A practical hobbyist stack

A nice balance of cost, learning, and flexibility:

• Frontend/blog: Astro or Hugo
• Hosting: Cloudflare Pages
• Dynamic functions: Cloudflare Workers
• Database: Cloudflare D1 or a small managed PostgreSQL database
• Images/files: Cloudflare R2 or similar object storage
• Source control: GitHub

Michele Bologna Gautam KhoranaFor most hobby bloggers, I would start with Cloudflare Pages + a static site generator, then add dynamic pieces only when needed. It avoids paying for an always-running server while still leaving room for interactive features. Gautam Khorana

For a hobbyist blog that mixes static pages (posts, images, CSS/JS) with dynamic content (comments, APIs, search, user accounts, etc.), I’d prioritize simple pricing and low operational overhead over raw cloud power.

My shortlist

1. DigitalOcean is probably the sweet spot.
A $6/month Basic Droplet gives you 1 vCPU, 1 GB RAM, 25 GB SSD and 1,000 GiB of transfer; DigitalOcean specifically describes Basic Droplets as suitable for low-traffic sites, blogs and CMSs. www.digitalocean.com

You could run something like:

Nginx
 ├── Static blog files
 ├── Node/Python/Ruby application
 └── PostgreSQL/SQLite

That makes it particularly good for learning how web applications actually work.

2. AWS Lightsail is the easiest AWS option.
The entry Linux plan is $5/month and bundles 0.5 GB RAM, 2 vCPUs, 20 GB SSD and 1 TB transfer, with a straightforward management console and one-click SSH. aws.amazon.com

I'd choose Lightsail over ordinary EC2 if your primary goal is "I want AWS without having to learn AWS infrastructure first."

3. DigitalOcean App Platform is attractive if you don't want server administration.
It's a managed application platform with a $0 starting tier, so you can deploy an application without maintaining the underlying VM yourself. www.digitalocean.com

What I'd personally do for a hobby blog

If you're comfortable learning a little Linux:

Cloudflare Pages → static frontend → DigitalOcean $6 Droplet → dynamic API/database

Or, for maximum simplicity:

DigitalOcean Droplet → everything

The second option is surprisingly capable for a small personal blog and gives you a very understandable architecture. You can later split the database, CDN, or application server out as the site grows.

One caveat: with a self-managed VPS, you become responsible for OS updates, backups, security, HTTPS, and monitoring. Managed platforms cost a little more in some cases but can be worth it if you want to spend your hobby time writing rather than administering servers.

DigitalOcean Droplet pricing · AWS Lightsail pricing

If you tell me whether your blog is WordPress, Hugo/Jekyll, Next.js, Python/Django, Node/Express, or something else, I can recommend the cheapest architecture for that particular stack.

For a hobbyist blog that mixes static pages (posts, images, CSS/JS) with some dynamic features (comments, contact forms, APIs, personalized content), I’d prioritize platforms that are cheap at low traffic and don't require much server administration.

My picks

1. Cloudflare Pages + Workers — best value

This is probably what I'd choose for your use case. Static assets can be hosted essentially for free, while Workers handles things such as an API endpoint, contact form, RSS generation, or dynamic page logic. The current Workers free tier includes 100,000 requests/day, and the paid plan starts at $5/month, with 10 million requests and 30 million CPU milliseconds included. developers.cloudflare.com

The tradeoff is that Cloudflare's ecosystem has a somewhat steeper learning curve than traditional hosting.

2. Render — easiest to understand

Render is particularly friendly if you already have a GitHub repository: connect the repo, choose static site or web service, and deploy. Its free tier covers static sites and small web services; free web services sleep after 15 minutes of inactivity, so the first request after a period of inactivity can be slow. render.com

It's a nice choice if your dynamic portion is a conventional Node, Python, Go, etc. API rather than a collection of serverless functions.

3. AWS Lightsail — best if you want a "real server"

Lightsail is a good middle ground between traditional VPS hosting and the complexity of the wider AWS ecosystem. AWS provides preconfigured stacks and a simple management console, and the cheapest Linux plans start around $5/month. aws.amazon.com

You could run something like Nginx + a blog CMS + your own Node/Python application on one small instance. The downside is that you're responsible for more server maintenance, security updates, backups, etc.

What I'd actually build

For a hobby blog, I'd start with:

GitHub → Cloudflare Pages → Cloudflare Workers → database/storage only if needed

Keep the blog itself static whenever possible. Put only genuinely dynamic operations behind Workers. That gives you very little infrastructure to maintain and should keep costs at $0 for quite a while, with a predictable $5/month upgrade path if you outgrow the free limits. developers.cloudflare.com

If you'd rather learn conventional server administration, choose Lightsail. If you'd rather have the simplest deployment workflow, choose Render.

For a hobbyist blog that mixes static content (articles, images, pages) with dynamic features (comments, search, newsletters, user accounts, APIs, admin dashboards), the best value usually comes from not putting everything on a traditional server. A hybrid approach is often cheaper and easier.

Here are beginner-friendly options:

aws.amazon.comwhatpeopleuse.com

My recommendations by blogging style

1. Mostly articles, photos, and occasional interactive features

Best stack:

• Static site generator (Astro, Hugo, Jekyll, etc.)
• Host on Cloudflare Pages
• Add dynamic pieces through:
  • serverless functions
  • hosted databases
  • third-party services (comments, newsletters, analytics)

Why:

• Almost no server maintenance
• Very cheap
• Fast globally
• Great fit for hobby blogs

toolchew.com

2. WordPress or Ghost-style blog

Best stack:

• A small VPS
• Managed database if you prefer less maintenance

Good beginner choices:

• DigitalOcean Droplet
• Amazon Lightsail

Advantages:

• One machine runs everything
• Easy backups
• Familiar software ecosystem

Trade-off:

• You handle updates, security, and monitoring.

aws.amazon.comwhatpeopleuse.com

3. A custom blog with code (Python, Node.js, Go, etc.)

Best stack:

• Frontend: static hosting
• Backend: app platform

Beginner-friendly choices:

• Render for deploying apps from Git repositories
• Fly.io for lightweight server deployments

This avoids learning Linux administration immediately.

bootstrap.build

A practical low-cost setup I’d suggest for a hobby blogger

Starter setup (~$0–$10/month):

• Blog pages → Cloudflare Pages
• Images → object storage or CDN
• Comments → hosted commenting service
• Newsletter → email provider
• Dynamic API → serverless functions or Render
• Database → free/low-cost managed database

This scales nicely without paying for an always-running server.

When a small VPS is worth it

Choose a VPS if you want:

• WordPress
• Ghost
• full database control
• self-hosted analytics
• custom background jobs
• learning Linux/cloud administration

A $5–$10/month VPS can comfortably run a personal blog with moderate traffic. DigitalOcean is popular among beginners because of its documentation, while cheaper VPS providers can offer more hardware for the money but may require more technical comfort. aws.amazon.comwhatpeopleuse.com

Simple decision guide

• I want to write posts and avoid maintenance → Cloudflare Pages
• I want WordPress/Ghost → DigitalOcean or Lightsail
• I want to learn cloud engineering → Oracle Cloud free tier or a small VPS
• I want custom dynamic features → Cloudflare Pages + Functions or Render
• I expect only a few hundred visitors/month → avoid overbuilding; free tiers are often enough

For most hobby bloggers in 2026, a static-first architecture with small dynamic add-ons gives the best combination of cost, speed, and simplicity.

For a hobbyist blog that mixes static pages with some dynamic functionality—comments, contact forms, APIs, personalized content, etc.—I’d prioritize platforms that let you start essentially free and add compute only when you need it.

My picks

1. Cloudflare Pages + Workers — best overall value

For a hobby blog, this is probably where I'd start. Pages gives you static hosting with a $0 tier, unlimited static requests and bandwidth, while Workers provides serverless compute for dynamic pieces. The current Workers free tier includes 100,000 requests/day; the paid plan starts at $5/month and includes substantially higher allowances. pages.cloudflare.com

It's particularly attractive if your blog is something like:

Markdown posts → static site generator → Cloudflare Pages
Contact form/API/search → Cloudflare Worker
Small bits of state → KV/Durable Objects/database

The downside is that Cloudflare's ecosystem can take a little more learning than a traditional hosting provider.

Cloudflare Pages

2. Render — easiest if you want a conventional backend

Render is a nice choice if you'd rather think in terms of "here's my Python/Node/Ruby app" than serverless functions. It supports Node.js, Python, Ruby, Go, Rust, Elixir, and Docker, and offers static sites, web services and managed Postgres. render.com

It also has free instances for static sites and web services. The catch is that free web services spin down after 15 minutes without inbound traffic, so the first request after inactivity can be slow. render.com

Render

3. AWS Lightsail — best if you want to learn servers

If part of the hobby is learning Linux, Nginx, Docker, databases, etc., Lightsail is compelling. Its smallest Linux VPS is currently $5/month, with 0.5 GB RAM, 2 vCPUs, 20 GB SSD and 1 TB transfer. render.comrender.comaws.amazon.com

It's more hands-on, though—you become responsible for considerably more of the server administration.

Amazon Lightsail

What I'd choose

For a personal hobby blog, I'd rank them:

Cloudflare Pages + Workers > Render > Vercel/Netlify > Lightsail

If you want the least maintenance, choose Cloudflare or Render.

If you want to learn cloud/server administration, choose Lightsail.

If your blog is built with Next.js, Vercel becomes much more attractive.

And if the site is 95% static, don't pay for an always-running VM at all—put the static content on a free static host and use serverless compute only for the handful of dynamic operations. That can keep a hobby blog at $0/month for quite a while. pages.cloudflare.com

For a hobbyist blog with a mix of static pages and some dynamic functionality—comments, contact forms, an API, a small database, etc.—I’d prioritize simple pricing and low operational overhead over raw compute power.

My picks

1. DigitalOcean App Platform — best overall for a hobbyist

You can host static sites for free, deploy directly from GitHub/GitLab, get HTTPS and CDN support, and move to a paid application starting at $5/month when you need server-side functionality. www.digitalocean.com

The big advantage is that you don't have to maintain a Linux server, install updates, configure Nginx, etc. That's particularly attractive if blogging is the hobby rather than server administration.

2. Amazon Lightsail — best if you want to learn traditional hosting

Lightsail is essentially a simplified VPS. The entry Linux instance is $5/month, with 0.5 GB RAM, 2 vCPUs, 20 GB SSD and 1 TB transfer. docs.aws.amazon.com

It also has ready-made blueprints for things such as WordPress, Ghost, Node.js, Django, Nginx and LAMP, making it considerably easier than starting with EC2. docs.aws.amazon.com

I'd choose this if you want the experience of actually managing your own web server.

3. Cloudflare Workers — best for a modern static + dynamic architecture

If your blog is mostly static, you can put the static content on Cloudflare and use Workers for small dynamic endpoints. The Workers free plan provides a useful amount of serverless compute, while the paid plan starts at $5/month and has no additional egress/bandwidth charge. developers.cloudflare.com

This is excellent for things like:

• /api/comments
• contact forms
• RSS generation
• authentication
• small database-backed features
• personalized responses

The tradeoff is that serverless concepts can be somewhat less intuitive to a beginner than "here's my Linux server."

One particularly cheap setup

For a hobby blog, I'd seriously consider:

Static frontend → Cloudflare Pages/Workers → small managed database

rather than paying for a permanently running VM.

If you want a more conventional setup:

DigitalOcean App Platform → application + database

is probably the least frustrating starting point.

And if learning Linux/server administration is part of the hobby, go with Lightsail. Its predictable $5/month entry point and preconfigured applications make it unusually approachable for a VPS. docs.aws.amazon.com

Bottom line:

• 🥇 Easiest: DigitalOcean App Platform
• 💰 Cheap + traditional: Amazon Lightsail
• ⚡ Best modern serverless option: Cloudflare Workers
• 🛠️ Most control per dollar: DigitalOcean Droplet

If you tell me what you're using for the blog (e.g. Hugo/Jekyll + Python/Node backend, WordPress, Astro/Next.js, etc.), I can narrow this down to a specific architecture and likely monthly cost.

For a hobbyist blog that mixes static pages with some dynamic functionality—comments, a small API, contact forms, RSS generation, analytics, etc.—I’d prioritize simplicity and predictable costs over raw cloud power.

My picks

1. DigitalOcean Droplet — best overall for a hobbyist

A $4/month Basic Droplet gives you a tiny VM; the $6/month option provides 1 GB RAM, 1 vCPU, 25 GB SSD and 1,000 GiB transfer. DigitalOcean explicitly describes its Basic Droplets as suitable for low-traffic websites, blogs, CMSs and small databases. www.digitalocean.com

You could run:

• Nginx/Caddy
• Hugo/Astro/Eleventy-generated static content
• WordPress or Ghost
• Node/Python/PHP backend
• SQLite or a small PostgreSQL database
• cron jobs

The downside is that you're responsible for server maintenance, security updates and backups.

2. Google Cloud Run — best if the dynamic part is small

Cloud Run is particularly attractive if your blog is mostly static but occasionally invokes a backend. It bills based on actual resource usage and automatically scales instances, including scaling down when there isn't traffic. Google currently provides a monthly free tier including 240,000 vCPU-seconds and 450,000 GiB-seconds of memory. cloud.google.com

For example:

Static site → CDN/hosting → Cloud Run API → database

That's potentially extremely cheap for a personal blog, although Google's ecosystem is more complicated than DigitalOcean's.

3. AWS Lightsail — best if you want AWS without AWS complexity

Lightsail is essentially AWS's beginner-oriented VPS offering. It bundles CPU, RAM and SSD into predictable plans and includes conveniences such as DNS management, a static IP and browser-based SSH. aws.amazon.com

I'd choose it over ordinary EC2 if your goal is "I want to learn AWS, but I don't want to learn 25 AWS services just to host my blog."

4. Azure Static Web Apps — excellent for static-first blogs

If the dynamic component can be handled through APIs/Azure Functions, this is worth considering. Azure's Free plan includes web hosting, GitHub integration, globally distributed static content, SSL and managed APIs via Azure Functions. learn.microsoft.com

What I'd actually build

For your use case, I'd probably start with:

Astro/Hugo/Eleventy → DigitalOcean $4–6/month Droplet → Caddy → small Node/Python API

That gives you a very understandable architecture and a predictable bill. DigitalOcean's current Droplet pricing is particularly hobby-friendly because of its monthly caps and straightforward VM model. www.digitalocean.com

If you expect the dynamic portion to be very intermittent, I'd instead go:

Static hosting → Cloud Run API

That can be cheaper because you're not paying for an always-running VM. cloud.google.com

Bottom line:

• 🥇 Easiest all-in-one: DigitalOcean Droplet
• 💰 Potentially cheapest for sporadic dynamic requests: Google Cloud Run
• ☁️ Best beginner route into AWS: Lightsail
• 🪶 Best static-first/serverless setup: Azure Static Web Apps

If you tell me whether you're thinking WordPress, a static-site generator, or a custom blog (Python/Node/etc.), I can narrow this down to the cheapest sensible architecture.

For a hobbyist blog that mixes static pages (posts, images, CSS/JS) with some dynamic content (comments, contact forms, APIs, personalized widgets), I’d favor platforms that minimize server administration.

My top pick: Cloudflare Pages + Workers

For your particular use case, this is probably the sweet spot. Cloudflare Pages' free tier provides unlimited static requests and bandwidth, while Workers gives you serverless compute for dynamic functionality. pages.cloudflare.comwww.cloudflare.com

You could structure it like:

Static

• Markdown blog posts → generated HTML
• Images/CSS/JavaScript → Pages
• GitHub → deployment source

Dynamic

• Contact form → Worker
• Comments → Worker + database
• RSS/API endpoints → Worker
• Small personalized features → Worker

The Workers free tier currently allows 100,000 requests/day, and the paid tier starts at $5/month, including 10 million requests/month and 30 million CPU milliseconds. www.cloudflare.com

That's particularly attractive for a hobby site because you aren't paying for an always-running server when nobody is visiting.

Best if you want to learn Linux: DigitalOcean

DigitalOcean Droplets are excellent if part of the hobby is learning how web servers actually work.

The smallest Basic Droplet is currently $4/month, with 512 MiB RAM, 1 vCPU, 10 GB SSD, and 500 GiB transfer. DigitalOcean explicitly lists low-traffic websites and blogs among the intended workloads. www.digitalocean.com

You could run:

Nginx + static site + Node/Python/PHP + SQLite/PostgreSQL

The tradeoff is that you become responsible for OS updates, security, backups, configuring the web server, etc.

A nice middle ground: DigitalOcean App Platform

If you want something more managed than a VPS but still want conventional application hosting, DigitalOcean's App Platform is worth considering. DigitalOcean currently lists it as starting at $0/month, with managed infrastructure and automatic scaling. www.digitalocean.com

What I'd choose

For a hobby blog, I'd rank them:

1. Cloudflare Pages + Workers — cheapest and least maintenance
2. DigitalOcean App Platform — good managed middle ground
3. DigitalOcean Droplet — best if learning server administration is part of the fun
4. AWS Lightsail — reasonable, but I'd choose DigitalOcean for a first VPS
5. Google Cloud — powerful, but more complexity than a small blog needs

If your goal is "I want to blog, not become a cloud administrator," use Cloudflare Pages + Workers. If your goal is "I want my blog to be an excuse to learn Linux, Docker, Nginx, databases, and deployment," get the $4 DigitalOcean Droplet.

If you tell me whether your blog is WordPress, Hugo/Jekyll/Astro, or a custom app, I can narrow this down to the cheapest sensible architecture.

For a hobbyist blog that mixes static pages (posts, images, CSS/JS) with dynamic content (comments, APIs, dashboards, a small database), I’d prioritize simplicity and predictable costs.

My recommendation

Start with DigitalOcean App Platform if you don't want to learn server administration. It can host static sites and applications without you managing the underlying infrastructure; DigitalOcean says its static-site hosting supports three free static sites, while its basic App Platform plan starts at $5/month. www.digitalocean.com

If you're happy to learn a little Linux, a $4–$6/month DigitalOcean Droplet gives you much more control. A small Droplet can run your blog, web server, application, and even a small database on one machine. DigitalOcean specifically positions its Basic Droplets for low-traffic websites, blogs, CMSs, and small databases. www.digitalocean.com

Cloud Run is attractive if your dynamic portion is intermittent. You pay for actual compute usage rather than keeping a VM running continuously, and Google currently provides a monthly free tier of 240,000 vCPU-seconds and 450,000 GiB-seconds of RAM usage for Cloud Run. cloud.google.com

A practical hobbyist setup

I'd probably use:

Static content → inexpensive static hosting/CDN
Dynamic API → Cloud Run or App Platform
Database → managed database only when you actually need one

That keeps the blog cheap while avoiding the operational burden of maintaining a database and server from day one.

If your main goal is learning cloud infrastructure, choose a Droplet. If your goal is writing/blogging with minimal maintenance, choose App Platform or a static/Jamstack platform with serverless functions.

For a hobbyist blog that mixes static pages (posts, images, CSS/JS) with some dynamic functionality (comments, contact forms, APIs, search, etc.), I’d prioritize low operational overhead and predictable costs over raw compute power.

My picks

1. Cloud Run — best overall for a modern hobby project

If your dynamic component can be packaged as a container (Node.js, Python, Go, etc.), Cloud Run is particularly attractive. It scales down when there's no traffic, and Google currently provides a substantial always-free allowance: 240,000 vCPU-seconds, 450,000 GiB-seconds, and 2 million requests per month under the applicable pricing model. cloud.google.com

That makes it a great match for a blog where traffic is sporadic. You can put your static content on a static host/CDN and use Cloud Run only for the dynamic pieces.

2. Lightsail — easiest if you want a conventional server

Lightsail is probably the least intimidating choice if you'd rather have a small Linux server and install your blogging software yourself. AWS describes it specifically as an easy way to get started with websites and web applications, with VPS, storage, DNS, backups, and related components packaged into a simpler interface. docs.aws.amazon.com

Current Linux plans start at $5/month for 0.5 GB RAM, with a $7/month 1-GB option and $12/month 2-GB option. docs.aws.amazon.com Lightsail even provides application templates for things like WordPress, Ghost, Django, Node.js, and LAMP. docs.aws.amazon.com

3. Cloudflare Workers — excellent for "static + tiny bits of dynamic"

If your blog is generated with something like Hugo, Astro, Eleventy, or Jekyll and your dynamic requirements are modest—contact forms, small APIs, personalization, counters, etc.—Workers can keep the architecture extremely lightweight.

What I'd actually build

For a hobby blog, I'd start with:

Static site generator → CDN/static hosting → Cloud Run for dynamic endpoints → managed database only if actually needed

That avoids paying for an always-running VM just so your blog can respond to the occasional visitor.

If you want to learn server administration, choose Lightsail instead. If you just want the blog to be cheap and require very little maintenance, choose Cloud Run + static hosting.

One caution: "free" cloud tiers aren't necessarily a zero-risk $0 bill—egress, databases, storage, and other ancillary services can still generate charges. Set billing alerts before experimenting.

For a hobbyist blog that mixes static pages with some dynamic features—comments, contact forms, search, small APIs, RSS processing, etc.—I'd prioritize platforms that don't require you to maintain a server.

My pick: Cloudflare

For your particular use case, Cloudflare Pages + Workers is probably the sweet spot. Static assets are free and unlimited, while dynamic Pages Functions are billed as Workers. The free Workers plan has a limited daily allowance, and the paid plan starts at $5/month. developers.cloudflare.com

It also gives you a natural progression:

Start:

• Static site generator → Pages
• Git repository → automatic deployments
• Contact form/search/API → Workers
• Small database → D1
• Images/files → R2

Later: move more of your application logic into Workers without having to administer a Linux server. Cloudflare specifically supports full-stack applications with static assets, APIs, and server-side rendering. developers.cloudflare.com

Cloudflare Workers pricing

If you want to learn "real servers": Lightsail

AWS Lightsail is a good alternative if part of the hobby is learning how a conventional web server works. The cheapest plan starts at $5/month, with predictable hourly billing up to the monthly maximum. docs.aws.amazon.com

You could run WordPress, Ghost, a Node/Python app, or your own Nginx + application stack. The downside is that you become responsible for OS updates, security, backups, and server configuration.

Amazon Lightsail pricing

Cloud Run is great if you like containers

Google Cloud Run is particularly attractive if your dynamic portion is a Dockerized application. It scales based on requests rather than requiring an always-running VM, and currently includes monthly free usage such as 240,000 vCPU-seconds and 450,000 GiB-seconds. cloud.google.com

The tradeoff is that Google Cloud has a steeper learning curve than Cloudflare.

Google Cloud Run

DigitalOcean if you want simplicity + a VPS

DigitalOcean Droplets are straightforward virtual machines and are excellent for learning Linux, Docker, Nginx, databases, and deployment. But unlike serverless platforms, you pay while the VM exists—even if you've powered it off. docs.digitalocean.com

DigitalOcean Droplets pricing

Bottom line: I'd choose Cloudflare Pages/Workers for a hobby blog where keeping the bill near $0 matters. Choose Lightsail or DigitalOcean if learning server administration is itself part of the hobby. Choose Cloud Run if you're already comfortable with Docker or want to learn container-based deployment.

For a hobbyist blog that mixes static pages with some dynamic functionality—comments, a small API, database-backed posts, RSS generation, etc.—I'd prioritize predictable pricing and simplicity over raw cloud power.

My picks

1. Amazon Lightsail — best overall beginner choice

Lightsail is specifically designed to make launching websites and web applications easier, with VPS instances, storage, DNS, backups, databases, and other pieces presented in a relatively simple interface. Its smallest Linux plan is currently $5/month, with 0.5 GB RAM, 2 vCPUs, 20 GB SSD and 1 TB transfer. docs.aws.amazon.com

For a blog, that's a very comfortable starting point. You could run something like:

Nginx → your blog/app → SQLite or PostgreSQL

and learn the fundamentals without diving immediately into the full AWS ecosystem.

2. DigitalOcean — best for learning

DigitalOcean's Droplets are straightforward Linux VMs, and its documentation is particularly approachable. Billing is granular, and you can destroy a VM when you're finished experimenting. docs.digitalocean.com

I'd choose this if part of the hobby is learning how servers actually work.

3. Google Cloud Run — best if you don't want server administration

If your dynamic portion can be packaged as a container, Cloud Run is particularly attractive. You deploy your application and Google handles the underlying servers. Google currently lists 2 million requests/month in its free tier. cloud.google.com

This is a great architecture for:

• Static blog hosted separately
• Small dynamic API on Cloud Run
• Managed database/storage only when needed

The downside is that cloud concepts and usage-based billing can be more complicated than a $5 VPS.

4. Google Compute Engine — best free/experimental option

Google currently offers an Always Free allowance for one e2-micro VM, subject to eligibility and the specified regions/quotas, plus 30 GB standard persistent disk and limited outbound traffic. cloud.google.com

That's potentially excellent for a tiny personal blog, but it's not my first recommendation for a beginner because Google Cloud's overall interface and billing model are considerably more complex than Lightsail/DigitalOcean.

5. Hetzner — best price/performance

If you're comfortable doing a little more Linux administration, Hetzner is worth considering. Its pricing is generally aggressive, although its June 2026 price adjustment means you should check the current plan pricing rather than rely on older blog posts. docs.hetzner.com

What I'd actually do

For your use case, I'd start with Lightsail at $5/month if you want one simple machine running everything.

If you want to learn modern deployment, I'd instead use:

Static frontend → CDN/static hosting
Dynamic features → Cloud Run
Database → SQLite initially, managed PostgreSQL only when necessary

That second approach can be extremely cheap at hobby scale because you're not paying for an always-running VM.

Bottom line:

• 🥇 Easiest: Lightsail
• 🥈 Best for learning servers: DigitalOcean
• 🥉 Best serverless/container approach: Cloud Run
• 💰 Cheapest experimentation: Google Cloud's free tier
• ⚡ Best raw value: Hetzner

For a hobbyist blog mixing static pages (posts, images, CSS/JS) with dynamic features (comments, contact forms, APIs, search, etc.), I’d prioritize simplicity and predictable costs over raw VM power.

1. Cloudflare Pages + Workers — my first choice

This is particularly attractive for your use case because static assets can be served essentially independently of your dynamic compute. Cloudflare says static asset requests are free and unlimited, while the Workers free plan includes limited dynamic execution; the paid plan starts at $5/month and includes 10 million requests and 30 million CPU milliseconds. developers.cloudflare.comdocs.aws.amazon.comcloud.google.comcloud.google.com

It's a good architecture for something like:

Static site generator → Cloudflare Pages/Workers → dynamic API → database

You don't have to maintain a Linux server, install security updates, configure Nginx, etc. Cloudflare also supports full-stack applications and server-side rendering through Workers. developers.cloudflare.com

Cloudflare Workers pricing

2. Amazon Lightsail — easiest traditional server

If you'd rather have the experience of running a conventional server—Ubuntu, Nginx, WordPress, Node.js, Python, etc.—Lightsail is arguably the friendliest entry point.

AWS explicitly positions Lightsail as an easy way to get started with websites and web applications, bundling VPS compute, storage, networking, DNS, backups, and other components into a relatively predictable package. docs.aws.amazon.com

The cheapest Linux/Unix instance is currently $5/month, with hourly billing up to the monthly maximum. docs.aws.amazon.com

Amazon Lightsail

I'd pick this if: you want to learn traditional server administration while keeping AWS complexity relatively low.

3. DigitalOcean Droplets — excellent DIY option

DigitalOcean is another good hobbyist choice if you want a small VPS and don't mind managing it yourself. Droplets are ordinary Linux VMs, billed by the second with a 60-second/$0.01 minimum. docs.digitalocean.com

It's especially nice for learning:

• Linux
• Docker
• Nginx/Caddy
• PostgreSQL
• Node/Python/PHP
• Git-based deployment

The downside is that you are responsible for more of the infrastructure than with Cloudflare or a managed platform.

DigitalOcean Droplets

4. Google Cloud Run — great if you like containers

If your dynamic portion is packaged as a Docker container, Cloud Run is compelling. Google currently lists 2 million requests/month in its free tier, and you pay based on actual usage beyond the free allocation. cloud.google.comcloud.google.com

It's less beginner-friendly initially than Lightsail because containers, IAM, projects, revisions, and Google Cloud's broader ecosystem introduce some concepts—but it's an excellent stepping stone toward more sophisticated deployments.

Google Cloud Run

5. Google Compute Engine — cheap, but more infrastructure than you need

Compute Engine gives you a conventional VM. Google currently offers a free tier covering one e2-micro instance, up to 30 GB of standard persistent disk and 1 GB/month outbound transfer, subject to the free-tier conditions. cloud.google.comcloud.google.com

It's a good learning environment, but for a hobby blog I'd generally choose Lightsail or DigitalOcean if I specifically wanted a VM.

What I'd choose

If you mostly want to blog:
Static-site generator + Cloudflare Pages/Workers. Very little server maintenance and excellent economics at hobbyist traffic levels.

If you want to learn Linux/server administration:
DigitalOcean Droplet or Lightsail.

If you want WordPress:
Lightsail is particularly appealing because you can run a conventional WordPress stack without assembling as much infrastructure yourself.

If you're building a custom app and already like Docker:
Cloud Run.

One useful rule: don't rent a continuously running VM just because you have a little dynamic content. If 95% of your blog is static, serverless functions/Workers can be substantially simpler and cheaper than maintaining an always-on server.

For a hobbyist blog mixing static pages with a little dynamic functionality—comments, a small API, contact forms, a CMS, etc.—I’d prioritize predictable pricing and simple deployment over the raw power of the cloud.

My picks

1. AWS Lightsail — best all-around beginner choice

Lightsail is specifically designed to make launching websites and web applications easier, bundling things like VPS instances, databases, DNS, storage, and backups into a relatively straightforward interface. Its cheapest plan is currently $5/month. docs.aws.amazon.com

It's particularly attractive if you want to run something like:

Nginx → WordPress/Astro/Next.js → small database

without learning the entire AWS ecosystem.

2. DigitalOcean Droplet — best if you want to learn Linux

A small Droplet gives you a conventional Linux server where you control practically everything. DigitalOcean bills CPU Droplets by the second, with a one-minute/$0.01 minimum, and includes a bandwidth allowance with each plan. docs.digitalocean.com

I'd choose this if you're comfortable following tutorials and want to learn Docker, Nginx, system administration, Git deployment, etc.

3. Google Compute Engine — best if minimizing compute cost is the priority

Google currently offers an Always Free e2-micro VM, subject to its eligibility, region, storage and networking limits. The free tier includes one e2-micro, up to 30 GB of standard persistent disk, and 1 GB/month of outbound transfer. cloud.google.com

The catch is that Google Cloud is substantially more complicated than Lightsail or DigitalOcean. It's a great learning platform, but probably not the most pleasant first cloud server.

4. Azure Container Apps — interesting if your dynamic content is containerized

Container Apps is serverless and can scale based on HTTP traffic/events, with consumption pricing based on resources used. azure.microsoft.com

It's more compelling when your blog is already Dockerized rather than when you're just starting out.

What I'd actually build

For a hobby blog, I'd probably avoid putting everything on a VM unless you want the server-management experience.

A cost-efficient architecture is:

Static frontend → static hosting/CDN
Dynamic features → serverless functions/container service
Database → small managed database or serverless database
Images → object storage

That lets the static portion handle most page views cheaply while you pay for compute only when dynamic functionality is actually used.

If you specifically want one simple server running the whole thing, though, Lightsail or DigitalOcean is the sweet spot. If your goal is learning cloud infrastructure, I'd pick DigitalOcean; if your goal is spending as little time as possible managing infrastructure, I'd pick Lightsail.

For a hobbyist blog that mixes static pages with some dynamic functionality—comments, a small API, contact forms, authentication, etc.—I'd prioritize predictable pricing and low operational overhead.

My picks

1. Lightsail — easiest all-around choice

If you want something that feels like "rent a small server and put my blog on it," Lightsail is probably the best starting point. AWS specifically positions it as an easy way to launch websites and web applications, with instances, storage, DNS, backups, and other components simplified into predictable pricing. The cheapest Linux plan is currently $5/month. docs.aws.amazon.com

You could run something like:

Nginx → WordPress/Hugo/Next.js → SQLite/PostgreSQL

It's also a nice stepping stone if you eventually want to learn more AWS.

2. Cloud Run — best if your "dynamic" part is small

For a modern blog, this is arguably the most economical architecture. Put the static frontend on a CDN/static host and run your dynamic component as a container on Cloud Run.

Cloud Run scales to zero, meaning you aren't charged for idle instances under request-based billing, and Google currently provides a substantial monthly free tier. cloud.google.com

This is particularly attractive for a hobby project that gets 100 visitors one day and 10 the next.

3. Azure Static Web Apps — excellent for mostly-static blogs

The Free plan is specifically intended for personal projects and includes globally distributed static hosting, SSL, GitHub integration, custom domains, and managed APIs through Azure Functions. learn.microsoft.com

For example:

GitHub → Static Web Apps → static blog

↘ Azure Function → database

That's a very low-maintenance setup.

4. DigitalOcean — best for learning traditional server administration

A Droplet gives you a conventional Linux VM, so you have complete control over the OS, web server, database, Docker, etc. DigitalOcean bills Droplets by the second with a 60-second minimum, and you continue paying while a Droplet is merely powered off—you need to destroy it to stop billing. cloud.google.comdocs.digitalocean.com

I'd choose this if learning Linux/server administration is part of the hobby, rather than simply wanting the blog online.

What I'd do for your use case

If your blog is 90% static and 10% dynamic, I'd start with:

Static site generator → Azure Static Web Apps → serverless function for dynamic features

or

Static site → CDN/static host + Cloud Run → small database

If you want one machine and minimal architectural complexity, choose Lightsail.

If you want to learn how servers actually work, choose DigitalOcean.

The key is not to rent a large VM just because you might eventually need one. For a hobby blog, scale-to-zero/serverless or a tiny $5-ish VPS is usually plenty.