# Render.com in Mid-2026: The Plan Change on 1 August, the 20x Bandwidth Cut, and When It Is Actually the Right Host

On 23 April 2026 Render cut included bandwidth 20x: Hobby 100 GB to 5 GB, Pro 500 GB to 25 GB. Legacy workspaces auto-migrate 1 August, so here is what it really costs.

Author: J.A. Watte
Published: July 15, 2026
Source: https://jwatte.com/blog/render-com-platform-review/

---

If you have a Render workspace on a legacy plan, you have until 1 August 2026 to make a decision, and then Render makes it for you. On 23 April 2026 Render replaced its workspace plans. Legacy workspaces can opt in "between now and August 1, 2026", and the ones that do not "will automatically move to the corresponding new plan" on that date ([Render docs, New Workspace Plans](https://render.com/docs/new-workspace-plans)).

Two things happen in that swap. The per-seat fee disappears, which is genuinely good if you have a team. And the included outbound bandwidth drops by a factor of twenty, which almost nobody is talking about. Render is a good product with a real trade-off buried in its pricing, and most of what is written about it right now quotes numbers that stopped being true in April.

## What Render actually is

Render is a managed platform-as-a-service. You point it at a Git branch, it builds and runs your code, and it handles TLS, health checks, and rollouts. It was started by Anurag Goel, an early Stripe employee ([TechCrunch](https://techcrunch.com/2019/04/25/render-gets-2-25m-seed-round-as-infrastructure-alternative-to-biggest-names-in-tech/)), and took $100 million at a $1.5 billion valuation on 17 February 2026 for $258 million total raised ([Render blog](https://render.com/blog/series-c-extension)). It is not going anywhere, which matters when you pick a host.

The product surface is deliberately small. As of mid-2026 the service types are Web Service, Static Site, Private Service, Background Worker, Cron Job, Workflow (beta), Render Postgres, and Render Key Value ([Render docs](https://render.com/docs/service-types)). Notice what is missing: no serverless functions, no edge runtime. Render runs long-lived processes. That is the whole personality of the platform, and it decides most of what follows.

## The plan change, and the part that got quieter

Here is Render's own legacy-versus-new comparison, condensed. All figures as of 15 July 2026, from [Render's New Workspace Plans doc](https://render.com/docs/new-workspace-plans).

| Feature | Legacy Hobby | New Hobby | Legacy Professional | New Pro |
|---|---|---|---|---|
| Plan fee | Free | Free | $19 per member/month | $25/month flat |
| Team members | 1 | 1 | Billed per seat | Unlimited |
| Outbound bandwidth | 100 GB included | **5 GB included**, then $0.15/GB | 500 GB included | **25 GB included**, then $0.15/GB |
| Custom domains | 2 | 2, then $0.25/mo each | Unlimited | 15, then $0.25/mo each |
| Build pipeline | 500 mins/month | 500 mins/month | 500 mins/member/month | 1,000 mins/month, then $5 per 1,000 |
| Services | Unlimited | Up to 25 (all types, including suspended) | Unlimited | Unlimited |

Legacy Organization at $29 per member per month becomes Scale at $499/month flat, with SSO, SCIM, and org audit logs moving from not-included to included, and the HIPAA premium going from "20% of compute + $250/month minimum" to "20% of compute (no minimum)". Scale's bandwidth stays at 1 TB.

Read the bandwidth row twice. Hobby went 100 GB to 5 GB. Professional went 500 GB to 25 GB. Both are 20x cuts, and the overage is $0.15 per GB.

Render's stated reason, from its own FAQ, is that "the plans replace per-seat billing with flat monthly fees, so your plan cost stays predictable as your team scales" and that "bandwidth and custom domains are billed based on usage, so you only pay for the resources you actually use". Render draws no causal line between the two, so I will mark the next sentence as my reading rather than theirs: seat fees were paying for a lot of egress, and when the seat fees went, the included egress went with them. If you are a five-person team, this is a large discount. If you are one person serving files, it is a large increase. Moving is also permanent. Render's FAQ answer to "Can I move back to a legacy plan?" is "No."

## What it costs

Render's pricing FAQ is blunt about the three-part bill: "Render charges for three things: your workspace plan (flat subscription), metered features like bandwidth (usage-based), and compute for your applications (usage-based)" ([Render pricing](https://render.com/pricing)). Compute is per service and prorated to the second, on top of the workspace fee.

Instance types for web services, private services, and background workers, as of 15 July 2026. The Free tier is web services only; private services and background workers start at Starter.

| Instance type | Price | RAM | CPU |
|---|---|---|---|
| Free | $0/month | 512 MB | 0.1 |
| Starter | $7/month | 512 MB | 0.5 |
| Standard | $25/month | 2 GB | 1 |
| Pro | $85/month | 4 GB | 2 |
| Pro Plus | $175/month | 8 GB | 4 |
| Pro Max | $225/month | 16 GB | 4 |
| Pro Ultra | $450/month | 32 GB | 8 |
| Custom | Contact sales | Up to 512 GB | Up to 64 |

Postgres moved to flexible plans, where the instance type buys compute only and storage is billed separately at "$0.30 per GB per month, prorated to the second" ([Render docs](https://render.com/docs/postgresql-refresh)). A selection from the 24 published tiers, as of 15 July 2026:

| Tier | Instance type | Price | CPU | RAM |
|---|---|---|---|---|
| Free | Free | $0 (30-day limit) | 0.1 | 256 MB |
| Basic | Basic-256mb | $6/month | 0.1 | 256 MB |
| Basic | Basic-1gb | $19/month | 0.5 | 1 GB |
| Basic | Basic-4gb | $75/month | 2 | 4 GB |
| Pro | Pro-4gb | $55/month | 1 | 4 GB |
| Pro | Pro-8gb | $100/month | 2 | 8 GB |
| Accelerated | Accelerated-16gb | $160/month | 2 | 16 GB |

That Basic-4gb at $75 costs more than Pro-4gb at $55 is not a typo. The tiers are CPU-to-RAM ratios, not a ladder: Pro is 1:4, Accelerated is 1:8. Two storage rules bite later. You can only increase storage "to any multiple of 5 GB", and "you can't reduce storage for a database". Ever.

Two worked bills, computed from those numbers on 15 July 2026. Render publishes no default or minimum storage for a new paid database, so the storage lines are my assumptions, not quotes.

| Example A: side project, Hobby workspace | Cost |
|---|---|
| Hobby workspace | $0.00 |
| Web Service Starter (512 MB, 0.5 CPU) | $7.00 |
| Postgres Basic-256mb | $6.00 |
| Postgres storage, 5 GB assumed, at $0.30/GB | $1.50 |
| Bandwidth, within the 5 GB included | $0.00 |
| **Total** | **$14.50/month** |

| Example B: small production app, Pro workspace, 50 GB egress | Cost |
|---|---|
| Pro workspace (flat, unlimited seats) | $25.00 |
| Web Service Standard (2 GB, 1 CPU) | $25.00 |
| Postgres Basic-1gb | $19.00 |
| Postgres storage, 10 GB assumed, at $0.30/GB | $3.00 |
| Bandwidth: 50 GB used less 25 GB included, at $0.15 | $3.75 |
| **Total** | **$75.75/month** |

Two things stand out. The workspace fee is a third of Example B before a single request is served. And 50 GB of egress, which is nothing for a site with images, already triggers overage on Pro.

One billing shape here is genuinely good: cron jobs bill per minute, from $0.00016/minute on Starter, and you pay only while the job runs. Pennies for a nightly script beats $7 a month for an always-on box to run it.

## The price cliff is not where people say it is

The received wisdom is that Render gets expensive when you leave Starter. Do the arithmetic and that is wrong. Ratios computed from the instance table above, as of 15 July 2026:

| Step | Ratio |
|---|---|
| Starter $7 (512 MB) to Standard $25 (2 GB) | 3.57x price for 4x RAM, proportionate |
| **Standard $25 (2 GB, 1 CPU) to Pro $85 (4 GB, 2 CPU)** | **3.40x price for 2x RAM. This is the cliff.** |
| Pro $85 to Pro Plus $175 (8 GB) | 2.06x for 2x RAM |
| Pro Plus $175 to Pro Max $225 (16 GB) | 1.29x for 2x RAM, the best step on the board |
| Pro Max $225 to Pro Ultra $450 (32 GB) | 2.00x for 2x RAM |

Starter to Standard is fine value. The real problem there is that nothing exists between 512 MB and 2 GB, so an app that needs 700 MB pays for 2 GB. The bad step is Standard to Pro: 3.4x the money for 2x the machine. If your app is about to outgrow 2 GB, that is the number to plan around.

## The free tier and its two footguns

Render's free tier is real, and unusually honest about its own limits. The following is verbatim from [Render's Deploy for Free doc](https://render.com/docs/free), as of mid-2026.

Spin-down: "Render spins down a Free web service that goes 15 minutes without receiving any inbound traffic." Spin-up: "This process takes about one minute." Note that number. The figure repeated everywhere online is 30 seconds; Render's own docs say about a minute, and the docs win. You also get 750 free instance hours per workspace per calendar month, which do not roll over.

Then the footgun that eats side projects. "Free Render Postgres databases expire 30 days after creation." After that, "you have a grace period of 14 days to upgrade it to a paid instance type. After the grace period, Render deletes the database (along with all of its data)." This is why older articles are wrong: the expiry was cut from 90 days to 30 effective 20 May 2024, with existing databases grandfathered ([Render changelog](https://render.com/changelog/free-postgresql-instances-now-expire-after-30-days-previously-90)). Free databases get no backups and no point-in-time recovery either. So the free tier is $0 but it self-destructs, and Example A's $14.50 is the real floor for anything you intend to keep.

Free web services also have an ephemeral filesystem, cannot attach a disk, and get no edge caching, no SSH, and no scaling. Free Key Value is in-memory only and loses everything on restart, including when you upgrade it.

For contrast: Vercel's Hobby plan "restricts users to non-commercial, personal use only" ([Vercel docs](https://vercel.com/docs/plans/hobby)). Render's free docs state no equivalent prohibition, but I did not read its Terms of Use, so read that as an absence of a documented restriction rather than as permission.

## The limits that will actually bite you

**Disks kill your deploy story.** The biggest practitioner gotcha on the platform, and the docs state it plainly: "Adding a disk to a service prevents zero-downtime deploys", because "When you redeploy your service, Render stops the existing instance before bringing up the new instance." And separately: "You can't scale a service to multiple instances if it has a disk attached" ([Render docs, Persistent Disks](https://render.com/docs/disks)). The moment you need local state, you lose both graceful rollouts and horizontal scaling. Disks are $0.25/GB/month and can grow but never shrink.

**Five regions, and you cannot change your mind.** Oregon, Ohio, Virginia, Frankfurt, and Singapore. That is the list. "Render doesn't currently support changing the region for an existing service or database" ([Render docs, Regions](https://render.com/docs/regions)). Pick wrong and you migrate by hand. Services in different regions cannot talk over the private network.

**There is no edge compute.** Render's edge caching is a CDN response cache, not a runtime, and "Edge caching is not available for free web services" ([Render docs](https://render.com/docs/web-service-caching)). Your code does not run at the edge. If that is what you need, this is the wrong platform, not a cheaper one.

**Previews cost money and need Pro.** "Preview environments require a Pro plan or higher", and "Preview resources are billed just like regular Render services and are prorated by the second" ([Render docs](https://render.com/docs/preview-environments)). Horizontal autoscaling, HTTP request logs, and the OpenTelemetry metrics stream are Pro and above too. Hobby does get community and email support; Pro unlocks chat.

## Reliability, measured rather than asserted

Rather than repeat folklore about Render's build queues, I pulled the Statuspage API on 15 July 2026 and counted ([status.render.com](https://status.render.com/api/v2/incidents.json)).

| Metric | Value |
|---|---|
| Incidents in feed | 50 |
| Date range | 2 December 2025 to 15 July 2026 |
| Average | ~6.6 per month |
| Impact breakdown | 28 minor, 20 major, 1 critical, 1 none |
| Deploy, build, or queue related | 15 of 50 |
| Datastore related | 6 of 50 |
| Per month, Dec 2025 to Jul 2026 | 6, 5, 5, 6, 8, 6, 10, 4 (July partial) |

Two caveats before anyone quotes this. The feed appears capped at 50 entries, so 2 December 2025 is an API limit, not the start of Render's history. And incident count is not uptime: I did not pull component-level availability, and many of these were regional or dashboard-only.

What the data does support is the build-queue reputation. Fifteen of fifty incidents are deploy-related: "Stuck queued deploys" (11 June 2026), "Degraded builds/deploys (all regions)" (11 May 2026), "Delayed/missing autodeploys" (9 June 2026). On 11 June alone there were three separate deploy incidents, plus a platform-latency incident the same day. Six touched datastores, including "HA Postgres Unavailability" on 7 May 2026, which is the high-availability feature you pay roughly double for having an outage. What I cannot give you is a typical build queue time. Nobody publishes one, and incidents are not latency.

## A render.yaml that actually parses

Render's Blueprint spec has moved and most samples online have not. Two traps: the field is now `autoDeployTrigger` with a quoted value, replacing the deprecated `autoDeploy`, and `postgresMajorVersion` must be quoted or YAML coerces it to an integer. Both are quoted in Render's own reference example ([Blueprint YAML reference](https://render.com/docs/blueprint-spec)).

{% raw %}
```yaml
services:
  - type: web
    name: my-app
    runtime: node
    plan: starter
    region: oregon
    branch: main
    buildCommand: npm ci && npm run build
    startCommand: npm start
    healthCheckPath: /healthz
    envVars:
      - key: NODE_ENV
        value: production
      - key: SESSION_SECRET
        generateValue: true
      - key: STRIPE_API_KEY
        sync: false
      - key: DATABASE_URL
        fromDatabase:
          name: my-app-db
          property: connectionString

databases:
  - name: my-app-db
    plan: basic-1gb
    region: oregon
    postgresMajorVersion: "18"
```
{% endraw %}

The env var forms are the useful part. `generateValue: true` generates a base64-encoded 256-bit value. `sync: false` prompts you for the secret in the dashboard instead of committing it, which is where every API key belongs. `fromDatabase` wires the connection string without either of you typing it. That Blueprint costs $7 plus $19 plus storage at $0.30/GB per month, at mid-2026 prices.

## The PaaS premium, quantified

This is the section that decides it. Render Standard is 2 GB and 1 CPU for $25/month, plus the workspace fee, with no bandwidth of its own. A DigitalOcean Basic Droplet with 2 GB, 1 vCPU, 50 GB SSD, and 2 TB of transfer is $12/month ([DigitalOcean pricing](https://www.digitalocean.com/pricing/droplets), read 15 July 2026). A Hetzner CX23 is €5.49 / $6.49/month with 20 TB of traffic ([Hetzner's pricing data](https://www.hetzner.com/_resources/app/data/bench/cloud_data.json), read 15 July 2026; that file carries prices but no specs, so I am comparing on price and bandwidth only).

So Render costs roughly two to four times a raw VPS for the same shape of box. What you buy for that: git-push deploys, zero-downtime rollouts, health checks, managed TLS, managed Postgres with point-in-time recovery, and not being a sysadmin at 2 a.m. Whether that is worth $15 to $60 a month is the actual decision, and for plenty of people it obviously is.

Egress is where it stops being close. Cost of 1 TB outbound, computed from each vendor's published rate on 15 July 2026:

| Platform | 1 TB outbound |
|---|---|
| Render, over the included pool at $0.15/GB | $150.00 |
| Netlify, 20 credits/GB | up to ~$200 on the smallest top-up pack, far less on higher Pro tiers |
| Railway, $0.05/GB | $50.00 |
| Fly.io, $0.02/GB in North America and Europe | $20.00 |
| Hetzner, within a 20 TB allowance | $0.00 |
| DigitalOcean, within the droplet allowance | $0.00 |

Render is 7.5x Fly.io on egress. If the workload is bandwidth-heavy, Render is the wrong shape at almost any scale, full stop. (The Netlify figure is a derivation, not a published rate: Netlify prices bandwidth at 20 credits per GB and sells add-on credits at $5 per 500, so the per-GB number depends on your tier. See [Netlify pricing](https://www.netlify.com/pricing/).)

One distinction worth naming: Railway meters actual consumption rather than allocated capacity ([Railway pricing](https://railway.com/pricing), read 15 July 2026). That, not the headline rate, is the real Render-versus-Railway split, because a mostly-idle app on Railway costs far less than sticker math suggests while Render bills the full instance price regardless.

## About Heroku, accurately

Render is usually pitched as the modern Heroku, and the 2026 chapter of that story is being overclaimed badly. Here is what the primary sources actually say.

Heroku killed its free plans, with free dynos and data services shutting down on 28 November 2022, because, per Bob Wise's "Heroku's Next Chapter" post, "our product, engineering, and security teams are spending an extraordinary amount of effort to manage fraud and abuse of the Heroku free product plans" ([Heroku blog](https://www.heroku.com/blog/next-chapter/)). That is the vacuum Render grew into.

Then on 6 February 2026 Heroku announced it is "transitioning to a sustaining engineering model focused on stability, security, reliability, and support", with "an emphasis on maintaining quality and operational excellence rather than introducing new features" ([Heroku blog](https://www.heroku.com/blog/an-update-on-heroku)). What stops: "Enterprise Account contracts will no longer be offered to new customers." What does not: pricing, billing, the core platform, production support, and existing Enterprise subscriptions. The post sets no end-of-life date and says outright, "There is no change for customers using Heroku today." Trade press calling this an imminent death is interpretation. Believe the announcement, not the migration vendors quoting it.

Be equally careful with Render's marketing in the other direction. Render's docs say "a web service on Render with 2GB of RAM is $25/mo. A Heroku dyno with 2.5GB of RAM is $250/mo" ([Render docs](https://render.com/docs/render-vs-heroku-comparison)). Both halves are literally true against [Heroku's published prices](https://www.heroku.com/pricing/), and the comparison is cherry-picked: Performance-M at $250 is a dedicated-CPU dyno, while Render Standard is a shared 1-CPU instance. The fair analogue is Heroku Standard-2X at $50 for 1 GB. At $50.00/GB against Render's $12.50/GB, Render is about 4x cheaper per GB as of mid-2026. Real, but not the 10x the framing implies.

## The verdict

Render is the right host when your workload is a long-running process with a database, your team is more than one person, your traffic is requests rather than bytes, and your time is worth more than $20 a month. The seat-fee removal makes it meaningfully better for teams than it was in March, and managed Postgres with automatic point-in-time recovery, per-second cron billing, and the zero-downtime deploy machinery are all things you would otherwise build badly yourself.

Render is the wrong host when you serve a lot of bytes, when you need edge compute, when you need a region it does not have, when you need a persistent disk and horizontal scaling at once, or when your app is fundamentally static.

That last one describes this site, so I should say it plainly. jwatte.com is Eleventy plus Netlify plus a handful of functions. Render has no edge runtime and no serverless product; the closest thing it sells is a $7/month always-on process to do what a static host does for nothing. Its static sites are free, but they draw from the same workspace pool, since "web services and static sites count against your monthly included amounts of outbound bandwidth and pipeline minutes" ([Render docs](https://render.com/docs/free)). On a new Hobby plan that pool is 5 GB. My own site is the counter-example to my own recommendation, and I would rather say so than pretend the tool fits every hand.

If you want the whole map of picking infrastructure that does not quietly meter you, that argument is the spine of [The $97 Launch](https://the97dollarlaunch.com/).

## Related reading

- [The Cloudflare Developer Platform, Explained Like You're Going to Ship on It](/blog/cloudflare-developer-platform/): the edge-compute platform Render has no answer to, and the contrast that decides a lot of these calls.
- [Where Should a Small Business Host Its Website and Apps?](/blog/blog-smb-web-platform-choice/): the same decision framed for a brochure site, a booking app, and an agency.
- [NeonDB: Serverless Postgres for Side Projects and Scaling](/blog/blog-neondb-serverless-postgres/): the managed-Postgres alternative if you like Render's app layer but not its database bill.
- [Netlify Database, in Practice](/blog/blog-netlify-database-deploy-preview-branches/): what a database branch per deploy preview buys you, versus Render's Pro-gated preview environments.
- [Static Site Generators Compared in 2026](/blog/blog-ssg-comparison-2026/): if your app is actually static, start here instead.

## Fact-check notes and sources

All prices, quotas, and tier limits below were read on 15 July 2026 and change frequently. Verify anything load-bearing against the live pages.

- **The plan change and the bandwidth cut**: [Render Docs, New Workspace Plans](https://render.com/docs/new-workspace-plans) (legacy vs new tables, the 1 August 2026 auto-migration, the "no" on moving back) and the [changelog entry](https://render.com/changelog/updated-plans-for-render-workspaces) dated 23 April 2026. Bandwidth is billed per workspace, not per service: [Outbound Bandwidth](https://render.com/docs/outbound-bandwidth).
- **Pricing**: [render.com/pricing](https://render.com/pricing) for all instance tables, workspace fees, disk and Postgres storage rates, cron per-minute pricing, and the three-part billing FAQ. Postgres flexible plans and the storage rules: [Flexible Plans for Render Postgres](https://render.com/docs/postgresql-refresh). Instance types by service type: [Render Instance Types](https://render.com/docs/compute-plans). Backups and PITR: [Postgres Recovery and Backups](https://render.com/docs/postgresql-backups).
- **Free tier**: [Deploy for Free](https://render.com/docs/free) for the 15-minute spin-down, the "about one minute" spin-up, 750 instance hours, the 30-day Postgres expiry plus 14-day grace, the ephemeral filesystem, and the static-site bandwidth note. The 90-to-30-day change: [Render changelog, 20 May 2024](https://render.com/changelog/free-postgresql-instances-now-expire-after-30-days-previously-90).
- **Limits**: [Persistent Disks](https://render.com/docs/disks) (disks prevent zero-downtime deploys and block multi-instance scaling), [Regions](https://render.com/docs/regions) (five regions, no changing after creation), [Edge Caching](https://render.com/docs/web-service-caching) (a response cache, not a runtime), [Preview Environments](https://render.com/docs/preview-environments) (Pro or higher, billed like real services), [Deploys](https://render.com/docs/deploys), [Service Types](https://render.com/docs/service-types).
- **Reliability**: counted directly from [status.render.com/api/v2/incidents.json](https://status.render.com/api/v2/incidents.json) on 15 July 2026. Fifty incidents is the feed's cap, not Render's total history, and incident counts are not an uptime figure.
- **Blueprints**: [Blueprint YAML Reference](https://render.com/docs/blueprint-spec) for `autoDeployTrigger`, the quoted `postgresMajorVersion`, and the env var forms. Key Value now runs Valkey: [Render changelog](https://render.com/changelog/new-render-key-value-instances-run-valkey-8).
- **Company**: [Render, About](https://render.com/about); [Series C extension](https://render.com/blog/series-c-extension) (17 February 2026, $100M, $1.5B valuation, $258M total, self-reported 4.5M+ developers); [Series C](https://render.com/blog/series-c); [TechCrunch on the seed round](https://techcrunch.com/2019/04/25/render-gets-2-25m-seed-round-as-infrastructure-alternative-to-biggest-names-in-tech/). The founding year is genuinely contested between 2018 and 2019 and I have not resolved it.
- **Heroku**: [Heroku's Next Chapter](https://www.heroku.com/blog/next-chapter/) (free-plan removal, 28 November 2022 shutdown, the fraud-and-abuse quote); [An Update on Heroku](https://www.heroku.com/blog/an-update-on-heroku), 6 February 2026 (sustaining engineering model, Enterprise contracts for new customers only, no EOL date); [Heroku pricing](https://www.heroku.com/pricing/). Render's own comparison, treated as vendor marketing: [Render vs Heroku](https://render.com/docs/render-vs-heroku-comparison).
- **Competitors**: [Railway pricing](https://railway.com/pricing), [Fly.io pricing](https://fly.io/docs/about/pricing/) (Amsterdam reference region; Fly's rates vary by region), [Vercel Hobby](https://vercel.com/docs/plans/hobby) and [Vercel Pro](https://vercel.com/docs/plans/pro), [Netlify pricing](https://www.netlify.com/pricing/), [Cloudflare Workers pricing](https://developers.cloudflare.com/workers/platform/pricing/), [DigitalOcean droplets](https://www.digitalocean.com/pricing/droplets), [Hetzner Cloud pricing data](https://www.hetzner.com/_resources/app/data/bench/cloud_data.json).

*This post is informational, not engineering or purchasing advice. I have no affiliation with Render, Heroku, Railway, Fly.io, Vercel, Netlify, Cloudflare, DigitalOcean, Hetzner, or any other product or organization named here, and mentions are nominative fair use. Prices, quotas, tier limits, and product details are current as of mid-2026 and change; verify against the live pages before you build on them.*


---

Canonical HTML: https://jwatte.com/blog/render-com-platform-review/
RSS: https://jwatte.com/feed.xml
JSON Feed: https://jwatte.com/feed.json
Hero image: https://jwatte.com/images/render-com-platform-review.webp