Back to Discover
Ethereum logo

Ethereum

StartupLaunched August 2026

Screenshots

The Story

Ethereum is a public blockchain whose distinguishing feature is that it executes general-purpose programs. A smart contract is code deployed to the network, and any account can call it, which turns the chain from a payments ledger into a platform other applications are built on.

The network is maintained by validators who stake ether and are rewarded for proposing and attesting to blocks, with penalties for misbehaviour. Because every node verifies every transaction, the state of the chain is agreed without a central operator. Fees are paid in ether and scale with the computational work a transaction requires.

The tradeoffs are the reason alternative chains exist. Throughput is limited by the requirement that every node process every transaction, so fees rise when demand is high. Contracts are immutable once deployed unless written to be upgradeable, which means a bug can be permanent. And the account model puts the burden of key management on the user, where a lost key means lost funds.

Overview

Ethereum's contribution was to make the blockchain a general computation platform, which is what allows applications to be built on it.

A smart contract is code deployed to the network with its own address. Any account can call it, and the call executes deterministically on every node, so the result is agreed without an intermediary. That generalises the ledger from recording who paid whom into running whatever logic the contract encodes.

Consensus is maintained by validators. They stake ether, propose and attest to blocks, and are rewarded for honest participation and penalised for provable misbehaviour. Because every node verifies every transaction, the chain's state is not dependent on trusting an operator, which is the property the applications built on it inherit.

The costs are structural. Requiring every node to process every transaction caps throughput, so fees rise when demand does. A deployed contract is immutable unless it was written to be upgradeable, so an error can be permanent. And because accounts are controlled by keys rather than by a recovery process, a lost key means lost funds.

Key Features

  • General-purpose smart contracts

    Deployed code executes deterministically on every node, so applications inherit the chain's guarantees.

  • Proof-of-stake consensus

    Validators stake ether to propose and attest to blocks, with penalties for provable misbehaviour.

  • Open participation

    Anyone can run a node, deploy a contract, or submit a transaction without permission.

  • Composable contracts

    Contracts can call each other, which is what lets applications be assembled from existing protocols.

Where Ethereum is a strong choice, and where it is not

Choose Ethereum when an application needs a public, verifiable state that no single operator controls, and the cost per transaction is acceptable for the use case.

Look elsewhere if the application needs high throughput at low cost, or if the data does not need to be publicly verifiable. A conventional database is faster and cheaper for most software.

Getting started

Reading the chain is free; a first transaction needs a wallet and gas.

  • ~15 min
    Time to first transaction

    Set up a wallet, fund it, and send. A testnet removes the cost while learning.

  • Gas per transaction
    Cost to start

    Every transaction pays a fee in ether that scales with the computational work required.

  • A wallet
    Prerequisites

    A self-custody wallet and some ether for gas.

Known limitations

Constraints confirmed from the network's documentation.

  • Throughput is capped by design. Requiring every node to process every transaction means fees rise when demand does.
  • Deployed contracts are immutable unless written to be upgradeable, so a bug can be permanent.
  • A lost key means lost funds. There is no recovery process and no support to appeal to.
  • Gas is unpredictable. A fee estimated at one moment can change before the transaction confirms.
OUR VERDICT

Pick Ethereum when the state must be publicly verifiable

It runs general-purpose programs that any account can call, which is what allows applications to be built without a trusted operator.

The differentiator is verifiability: every node checks every transaction, so the result does not depend on trusting a company.

If the application needs high throughput at low cost, or the data does not need to be publicly verifiable, a conventional database is faster and cheaper.

FAQ

What is Ethereum?

Ethereum is a public blockchain that executes general-purpose smart contracts, secured by validators who stake ether.

Is Ethereum free to use?

The network is open, but every transaction pays a gas fee in ether that scales with the computational work required.

What is a smart contract?

Code deployed to the network with its own address that any account can call, executing deterministically on every node.

How is the network secured?

Validators stake ether to propose and attest to blocks, earning rewards for honest participation and penalties for misbehaviour.

What stack is Ethereum built with?

CompassPad records Ethereum clients implemented in Go, Rust, and other languages, with Solidity as the dominant contract language.

What we checked

  • LIVE
    Site and primary link

    The marketing site resolved and the primary product link reached the application.

  • PRICING
    Pricing page

    The network is open and permissionless; transaction fees are paid in ether and scale with computational work.

  • DOCS
    Documentation

    Developer documentation is public and covers contracts, consensus, and nodes.

  • FRESHNESS
    Changelog

    A dated public history page records network upgrades and is reachable without an account.

Discussion

No comments yet. Be the first.

Join the conversation. Sign up to comment.

Sign up free

Similar But Scrappier

Vercel

Trending

Deploy frontend projects from a Git push, with a preview URL for every branch.

Developer ToolsCCompassPad editorial

Vercel is a hosting platform built around the frontend workflow. A project connects to a Git repository, and every push produces a deployment: production builds from the main branch, and preview builds from every other branch and pull request. The platform is best known for Next.js, the React framework its parent company maintains, but it builds and serves other frameworks and static output too. Deployments run on a global edge network, and build configuration lives in a checked-in file rather than only in a dashboard, so settings travel with the code. Beyond hosting, Vercel sells the surrounding primitives: serverless and edge functions, image optimization, and storage through marketplace partners. Teams that want one vendor for the frontend path consolidate here; teams with long-running backend workloads usually keep those elsewhere.

Supabase

FeaturedTrending

Open-source Postgres backend with auth, storage, and realtime built in.

Developer ToolsCCompassPad editorial

Supabase is a backend platform built on PostgreSQL. It packages the pieces most applications need at the start - a database, authentication, file storage, and realtime subscriptions - behind one dashboard and one set of client libraries. The database is the center of the product, not a hidden implementation detail. Tables are ordinary Postgres tables, row-level security policies are ordinary Postgres policies, and the dashboard exposes the SQL. A team can connect with any Postgres client, run migrations with any migration tool, and leave with its data intact. Around the database, Supabase adds services that would otherwise be separate vendors: authentication with social providers and row-level-security-aware sessions, object storage with access policies, edge functions for server-side code, and realtime channels for broadcasting row changes to connected clients. The open-source core is published in a public repository, and the hosted service and self-hosted deployment are documented side by side.

Neon

Serverless Postgres with database branches that fork like code.

Developer ToolsCCompassPad editorial

Neon is a managed Postgres service built on a storage layer that separates compute from data. Because the data layer is copy-on-write, the service can create a full database branch in seconds, and that branch starts as a pointer into the parent's history rather than a physical copy. The practical result is a database workflow that resembles Git. A team can branch production for a preview environment, run migrations against the branch, and throw it away without touching the parent. Point-in-time restore uses the same mechanism, so recovering to a moment before a bad migration does not require replaying a backup. Compute scales to zero when idle, which suits development and preview environments that sit unused most of the day. The tradeoff is cold-start latency on the first query after a suspend, and a connection model that expects a pooler for serverless clients.