Source: https://www.hype-stack.dev/stacks/web-app-example

# Web App Example: From a Calculator to a Marketplace

> A website is something you read. A web application is something you use. The line is not about technology, it is about
> whether the thing has state that belongs to you.

People searching for web app examples are usually trying to settle a definition before making a decision: what counts as
a web application, how it differs from a website, and what it would take to build one. This page answers that, with
examples, and leaves the product part to the end.

## The distinction that actually holds

|  | Website | Web application |
| --- | --- | --- |
| What the visitor does | Reads, and maybe submits a form | Creates and changes things that persist |
| State | The same for everyone | Per user, and it is the point |
| Accounts | Usually none | Nearly always, because state needs an owner |
| How it is judged | Was it found, was it read | Do people come back and complete tasks |
| What it costs to run | Hosting | Hosting, a database, backups, and support |

The row about accounts is the practical tell. As soon as something needs to remember who you are in order to be useful,
it is an application, and everything about how it is built and run changes.

## Examples, from simplest to hardest

**Web applications, and what makes each one hard**

- **A calculator or converter** Interactive but stateless. No account, no database, nothing to back up. This is the easiest thing that still deserves the name, and it can be a single page with no server at all.
- **A todo or notes app** The canonical example because it introduces the real requirement: data that belongs to a person and survives them closing the tab. That means accounts, a database, and everything that follows.
- **A booking or scheduling tool** Adds a constraint between users. Two people must not book the same slot, which is a correctness problem rather than a feature, and it is where naive implementations first go wrong.
- **A team tool with shared data** Adds organisations and permissions. Who can see what, who can change it, and what happens when somebody leaves. Retrofitting this is one of the hardest changes to make later.
- **A marketplace or multi-tenant product** Adds isolation between customers, billing, and the requirement that a bug never shows one customer another's data. This is where most of the engineering is invisible to the user.

_The difficulty is not in the interface. It moves from none to substantial as soon as data is shared between people._

## Web app, mobile app, or desktop app

These are delivery choices rather than different kinds of software. The same application can be reached through a
browser, wrapped for an app store, or packaged for a desktop, and increasingly is all three.

What actually differs is capability and distribution. A browser cannot use every device feature, and it cannot be found
in an app store. A native app can do both and costs considerably more to build and maintain per platform. For most
business software the browser is enough, which is why so much of the software people use at work is a web application.

The useful architectural consequence is to keep the API separate from the interface. An application whose data comes
from a typed API can grow a mobile client later; one where the server renders everything has to be partly rebuilt for
it.

## What a web application is made of

Beneath any of the examples above, roughly the same list: a way to sign in, a database with a schema for the data, an
API between the interface and that data, permissions deciding who sees what, an interface, and the operational layer of
backups, error reporting, and somewhere to look when a customer reports a problem.

Only one of those is specific to your idea. That is worth knowing before estimating, because the specific part is
usually the part people estimate and the rest is what takes the time.

## Where this stack fits

If the example you have in mind is the third, fourth, or fifth in the list above, the parts you would otherwise write
first are the ones you can start from: accounts and sign-in, organizations, roles and invitations, a Hono backend with
Prisma and Kysely on Postgres, a React frontend with a typed client between them, an admin app, and Stripe billing.

There is no todo app, booking tool, or marketplace in the box. The templates are starting points for those shapes rather
than finished versions of them, and what makes each one yours is exactly the part not included.

If you are building the first or second example, this is more than you need and a much smaller setup will serve you
better. Below are the templates and packs for the cases where it is not.



To build one of these, start with [How to Build a Web App, Decision by Decision](/stacks/how-to-build-a-web-app), and
for the shell and screens, [How to Design a Web App](/stacks/how-to-design-a-web-app).
