One file, one command,
your first service.

Ninety seconds

1. Get it. Two roads, both one step. With Ring installed, its package manager does everything — the guides and both example applications come with it:

   $ ringpm install ringserv from mayouni
   $ ringpm run ringserv

   Without Ring — and you do not need it — pick your platform on the releases page, put the file somewhere on your path, and on Linux or macOS make it executable (chmod +x ringserv). That is the entire installation either way.
2. Write ordinary functions. Create a file — say calc.ring — containing nothing but functions:

   func add a, b
       return a + b
   
   func hello name
       return "Ahlan, " + name + "!"

3. Serve them. ringserv serve calc.ring — and every function in the file is callable over the web, its parameters matched to your payload by name:

   $ curl -X POST localhost:8080/api/v1 \
       -d '{"service":"calc","action":"hello",
            "payload":{"name":"Sara"}}'
   {"code":0,"message":"OK","data":"Ahlan, Sara!"}

Not sure what you just published? ringserv serve --explain calc.ring prints exactly which functions became callable — and which stayed private (any name starting with _) — then exits without serving anything. The tool states it, so you never have to guess.

Or scaffold it

Two scaffolds, for two moods. ringserv new myapp --gesture creates the pair you just met — a file of functions and a small ringserv.yaml for the port and workers. Plain ringserv new myapp creates the fuller shape: an app.ring with a declared service and a table, a web page that calls its own API, and a test that already passes.

$ ringserv new myapp
$ cd myapp
$ ringserv dev        # serve, watch, reload on save
$ ringserv test       # run its tests against a scratch database

ringserv dev is the daily loop: edit, save, and the server reloads itself. When you want to see everything you are running in one place, ringserv panel . opens a small admin page in your browser that starts, stops and watches your applications.

Where each next step lives

The tutorial arc sequences the whole journey — six runnable steps with a time on each. In brief:

1. Tables and contracts. Declare your data and what each request must contain; bad requests are refused before your code runs. Getting started builds a whole application this way.
2. A JavaScript service. Point a service at a .js file and it runs inside the same binary, under the same rules, calling your Ring services by name — the JS guest.
3. A record nobody can edit. For sales, audits and anything the law says must stay whole: the journal, where a cancellation is an event, never a deletion.
4. Place it. Declare which pieces run in the page, which on the server, and which sync — the unified model with RingScript.