Elements vs Netlify
Netlify is a cloud hosting company. It builds web apps from your Git repository on its own build machines, serves the result from its CDN, and runs server code as Netlify Functions and Edge Functions. Around the hosting it sells platform services: form handling, blob storage, an image CDN, a Postgres database, and Agent Runners that run AI coding agents from its dashboard. Its revenue is hosting. Each plan includes a monthly allotment of credits, which production deploys, compute, requests and bandwidth spend, and more credits are sold in packs (Netlify pricing).
Elements sells no hosting and no credits. It is an integrated app environment for building web apps, for people and their agents, and the system you install covers the default framework, the database, the tests and the deploy that Netlify splits across its build network, Functions and add-on services. Where a Netlify site runs on Netlify, an Elements app runs on a plain Ubuntu server you rent from whoever you like and reach over SSH. The price is per machine for the tooling, and no usage is counted against it (pricing).
The business models point in opposite directions. Netlify meters your app's usage, so every deploy and every visitor draws down a monthly balance of credits. When the balance runs out, either you buy more or every site on the team goes offline. Elements has no balance to run out. You pay a known price for the tooling, and the server, database and CDN are bought separately from vendors who compete on them, so no usage balance decides whether your sites stay up.
At a Glance
| Elements | Netlify | |
|---|---|---|
| What it is | An app environment you install; hosting is any server you rent | A hosting company |
| What you pay for | Tooling, per machine, per month (pricing) | A plan with monthly credits, spent on deploys, compute, requests and bandwidth (pricing) |
| When usage passes the plan | Your app keeps serving; nothing is metered | Every site on the team is paused, unless you buy more credits |
| Where your app runs | An Ubuntu server you rent from any provider | Netlify's CDN, with server code as Netlify Functions |
| A deploy | Changed files only, usually under a second | A build on Netlify's build machines, allowed 15 minutes by default |
| What a deploy checks | Compiles, runs your tests against the new schema, then migrates the app database; any failure stops the release | Runs the build command you configure, then applies database migrations |
| Database | Bundled Postgres, or any Postgres host | Netlify Database, billed in credits |
| Leaving | Change a server address and deploy | Rewrite what uses Netlify's own APIs |
Netlify Meters Your Usage in Credits
Netlify's pricing is a two-part tariff. You pay a monthly fee for a plan, and the plan comes with a set number of credits. Everything your app does spends them: each production deploy costs credits, and functions and database compute are charged by the gigabyte-hour, requests by the ten thousand, and bandwidth by the gigabyte (credit-based plans). The more your app is used, the more credits it spends.
When the credits run out, every site on the team goes down. Netlify's billing FAQ says that "if one site/web project exceeds its limits, all sites/projects on your account will be paused." Visitors see a Site not available page, the sites receive no requests or form submissions, and you cannot deploy a fix until the next billing cycle, unless you upgrade or turn on auto recharge, which buys credit packs as you go (billing FAQ).
Elements charges up front, per machine, for the tooling (pricing, licenses). Nothing is metered: requests, bandwidth and deploys never appear on an Elements bill, and nothing pauses your app. The server bill is whatever your provider lists, and an Elements app fits on a small VPS (deploy, DigitalOcean pricing).
Agents Need Standards, Not a Platform
Netlify's case for agents is its platform: agent skills and an MCP server that teach an agent Netlify's own primitives, and Agent Runners that run agents from the Netlify dashboard, with model usage paid in credits (Netlify AI docs, credit-based plans). Every primitive is one more thing to teach. Functions, Edge Functions, Blobs, Forms and netlify.toml each have their own API and their own rules, and each is a seam between the app and the host. A platform service is worth learning only past what an agent writes quickly from standards, and past that point each extra one costs more to learn and get right than it saves. What an agent gains from is correction: finding out what it got wrong the moment it gets it wrong.
An agent working on an Elements app has no host primitives to learn. The app is TypeScript, HTML, CSS and SQL with Node and Postgres underneath, and it ships to Ubuntu over SSH. The plumbing every app needs, routes, server functions, sessions and sql(), comes in the default framework, and Elements puts the rest of its engineering into the check. Because the project server, the framework and the deploy are one coherent system, one build covers the code, the tests and the migrations, and it runs locally, through a project server that runs while you work and holds the build graph and build state in memory. On every save the build state is updated almost instantly; it builds in milliseconds and answers agents and humans in microseconds (build). After an edit, the agent runs elements build -json on your laptop and reads every build error, from failing tests and migration problems to mistakes found by type checking and program analysis, in one reply, with no credits spent.
Hosting Is a Commodity. Buy Each Piece on Its Own.
Netlify bundles the server, the database and the CDN into one account, and adds services of its own on top: Netlify Blobs for storage, Netlify Forms, an image CDN, and Netlify Database, which spends credits for its compute and bandwidth (Netlify Database). Your server code runs as Netlify Functions on Netlify's infrastructure, with no machine of yours to log in to (functions overview).
Elements leaves each of those to a vendor you pick and pay directly:
- Servers: instead of Netlify Functions, an Ubuntu machine with SSH from DigitalOcean, Hetzner, AWS or anyone else, watched by that provider's monitoring (setup).
- Database: in place of Netlify Database, either Postgres installed by Elements on your server or, through
DB_HOST, a managed Postgres such as DigitalOcean Managed PostgreSQL or Amazon RDS, billed by that provider and never in credits (setup). - CDN: your choice of CloudFront, Cloudflare, Fastly, Bunny or another. Browser files from Elements have content-hashed URLs and long cache lifetimes, so any CDN can sit in front of them (load balancer).
You can get onto that machine whenever you need to. elements ssh -remote=production drops you into a shell in the app, elements db -remote=production starts psql against its database, and apt packages named in the deploy config get installed for you (operations).
Deploys Usually Take Under a Second, With No Build Queue
A Netlify deploy from Git is a build on Netlify's build network. Netlify's support guide tells you to "count on your builds having only 15 minutes to complete their build command" (Netlify support). When more builds are running across your team than your plan allows, new ones wait in a team queue marked "Enqueued: Awaiting Capacity" (build troubleshooting), and a team's build capacity is set by its plan (pricing). Each production deploy also spends credits.
Elements has no build network to wait for. The build already exists on your laptop, where the project server keeps it current, so a deploy sends only what changed: that project server and the one on your server compare file manifests, only the changed files cross the wire, and the server compiles only what they touch. A fresh machine is ready in a few seconds, and routine deploys usually take less than one (what deploy does). An agent can deploy fifty times in an afternoon and none of it costs a credit, or anything else.
Every Deploy Runs Your Tests and Migrations
Code and schema change together, so they have to be checked together. Netlify runs the build command you configure, so your tests run only if you add them to it. Netlify Database applies migrations after the build finishes, "immediately before the deploy is published" (Netlify Database migrations), so a test in the build command runs before the migration it depends on, against the schema as it was rather than the schema the release will use.
Elements orders the steps so the tests see the schema they will run against. Each machine compiles the release; the first machine migrates a test database; each machine then tests the release against that new schema; and only after all of that does the first machine migrate the production database, in one transaction, followed by an atomic swap to the new release. Should compiling, testing or migrating fail, the swap never happens and visitors keep the current release (deploy, tests, migrations).
For an agent, elements deploy -json lists each result from your laptop and each server, marked by machine, in the format it already knows from builds.
A Long-Running Process Keeps Connections Open
A chat or a live dashboard holds an open connection to each browser for as long as the page is up. An Elements app is a Node process that keeps running between requests, so those connections last as long as they need to. Typed server functions, sessions that update the page when a user signs in, database rows that stay in sync in every browser, and server-to-browser channels all run over WebSockets, with Postgres carrying messages between machines (rpc, session, livetable, channel).
Netlify runs server code as functions with a time limit: 60 seconds for a synchronous function, 30 seconds for a scheduled one, and 15 minutes for a background one, none of them configurable (functions configuration), so no function holds a browser connection past its limit.
Background jobs and cron schedules run on your server too, and Elements sends email, renews TLS certificates and runs the load balancer there (jobs, email, load balancer).
Leaving Is a Config Change
An Elements app calls no provider's API, so a move is a new server address in config.jsoc and one elements deploy. The packages the app imports at runtime, @elements/app among them, carry the MIT license (licenses).
The services Netlify sells are Netlify's own APIs: Netlify Functions and Edge Functions for server code, Netlify Blobs for storage, Netlify Forms for form handling, and netlify.toml for build and routing (functions API, file-based configuration). An app that uses them has to replace each one to leave.
Where to Run an Elements App
Pick any host that rents Ubuntu machines with SSH (DigitalOcean, Hetzner and AWS all do), list the server IPs in config.jsoc, and run the deploy (walkthrough):
elements deploy # production
elements deploy staging # a named environment
elements ssh -remote=production # open a shell on the machine
One server is a complete deployment: the app, the load balancer, TLS certificates and Postgres (deploy), which suits a prototype or a single-server app. To grow past one machine, or to hand backups and scaling to a provider, list more servers in the config and point them at a hosted Postgres such as DigitalOcean Managed PostgreSQL or Amazon RDS, and the load balancer on each server spreads requests across all of them (load balancer).
Questions
What is the difference between Elements and Netlify?
Netlify is a hosting company: it builds and runs your app on its infrastructure and meters usage in credits. Elements is not a host. It is an app environment you run yourself: it builds and tests your app and ships it to whichever server you rent, and its per-machine price has no credits to spend.
Is Elements a Netlify alternative?
Yes. Pair it with a rented Ubuntu server and it replaces Netlify's builds, functions, database and deploys: the build, the tests and the deploy happen in Elements, server code runs in your app's own Node process, and the server gets Postgres, a load balancer and TLS certificates from it, with no credits involved.
How much does Elements cost compared to Netlify?
Netlify sells plans with a monthly allotment of credits, which deploys, compute, requests and bandwidth spend, and more credits are sold in packs (Netlify pricing). Elements is priced per machine, per month, and nothing is metered (Elements pricing).
What happens when a Netlify site runs out of credits?
Netlify pauses every site on the team until the next billing cycle, and visitors see a Site not available page, unless you upgrade or turn on auto recharge (Netlify billing FAQ). An Elements app runs on your own server, and nothing about its usage is metered.
How fast is an Elements deploy?
Usually under a second once a machine is set up, and a few seconds the first time. Nothing queues. Only changed files are synced and compiled, then tests and migrations run as part of the deploy.
Where do I host an Elements app?
On a rented Ubuntu machine you can reach by SSH, from DigitalOcean, Hetzner, AWS or another host. To start, that one machine carries the app, Postgres and the load balancer together.