We can't find the internet
Attempting to reconnect
Something went wrong!
Hang in there while we get back on track
19 guides · 331 minutes · free core, no account
Every guide here is a working product, built line by line, with the reasoning said out loud. Start with the long one and you will finish with a Phoenix app that counts what customers use, stops them at their plan's limit, shows them the numbers live and puts the overage on a Stripe invoice.
Start here
One long walkthrough: a brand new Phoenix app that counts what customers use, stops them at their plan's limit, shows them the numbers live, takes their money through Stripe and bills what they went over. Every step, nothing skipped.
What you have when you finish
The chapters
The words, once
Picking the wrong one is the mistake that costs the most to undo, and it is always made on day one. This is the whole decision, on one screen.
| You write | It means | check/2 answers | Money |
|---|---|---|---|
feature :pdf_export, true
|
A switch On, or off. | :ok, or {:error, :not_entitled} | None |
feature :seats, 5
|
A number A figure the plan carries, which you read yourself. | :ok | None |
limit :runs, 50, :hard
|
A wall They are stopped at the line. | :ok until 50, then {:error, :limit_exceeded} | None |
metered :runs, included: 1_000, unit_price: 2
|
An allowance They may pass the line and are charged for it. | Always :ok | Billed after 1,000 |
counter :runs
|
Just counting Measured, never blocked, never billed. | Always :ok | Never |
# nothing declared
|
Not on the plan The plan says nothing about it. From 1.0 that is a refusal by default. | {:error, :not_entitled} | None |
The last row is a setting, undeclared_feature_policy, with four values: :allow answers as though the feature were declared, :warn does the same and logs once per feature per node, :deny refuses, and :raise raises. The default is :warn in the transition release and :deny from 1.0. Counting is outside the policy: an undeclared feature is still tracked, because losing the measurement is not a useful way to punish a typo.
The long version, with the reason each one exists, is in Every word, explained once .
Start from your pricing
There are three shapes. Pick yours and the guide that builds it is one click away. Using two of them at once is fine; they do not interfere.
A flat monthly price per tier. Cheap tiers have features switched off and caps that stop. Nobody is ever surprised by an invoice.
A project tool: 2 projects on Free, 50 on Team, 1,000 on Business.
plan :team do
price 4_900
feature :seats, 20
limit :projects, 50, :hard
endA monthly price that includes a generous amount. Going over still works and lands on the next invoice, so nobody is stopped mid sentence.
An AI writer: $29 includes 1,000 generations, then 2 cents each.
plan :writer do
price 2_900
metered :generations, included: 1_000, unit_price: 2
endNo monthly fee. Customers buy credit up front and every request spends some. You are paid before you do the work, and nobody can run up a bill.
A parsing API: $25 of credit, a fraction of a cent per page.
Credits.with_credits(org, estimate, "doc:#{doc.id}", fn ->
{:ok, text, pages} = Parser.run(doc)
{:ok, text, pages * 1_500}
end)Every guide
One guide that builds the whole thing. If you only read one, read this one.
One long walkthrough: a brand new Phoenix app that counts what customers use, stops them at their plan's limit, shows them the numbers live, takes their money through Stripe and bills what they went over. Every step, nothing skipped.
A complete Phoenix application that meters a fake AI product, runs with no API key and no card, and breaks itself eight different ways on demand so you can read what each failure actually leaves behind.
Counting, plans, limits and screens. Everything here works with the MIT package and no card.
Tenant, feature, period, plan, and the five kinds of thing you can put on a plan. Ten minutes here saves you from the one mistake everybody makes: picking the wrong kind.
The one line you put on your hot path, where the number actually goes, what happens when a server dies mid count, and how to read the totals back for a dashboard or a chart.
The handful of things you bill one by one deserve a row, an identity and a way to change your mind. Recording an event, what a duplicate and a conflict each return, and why a correction is a second fact rather than a smaller number.
Three tiers in one small module, switches that turn features off, seat counts, and the one function that makes a hard limit exact on a node when two customers click at the same moment.
What happens to the customers already on a plan when you edit its definition, how a fingerprint catches you doing it by accident, and how to move one customer on purpose with a preview you can put in an email first.
One call fills a dashboard card. One subscribe makes it live. Plus the two rules that keep a usage page honest, and the charts that need no gap handling.
A plug that refuses a request with the right status and your own body, a LiveView hook that keeps a page live and switches tenant without leaking a subscription, the four components and the one rule that decides whether a usage bar ever moves, and the installer flags.
The two pricing shapes, and the Stripe wiring that turns a number into an invoice.
The pricing shape where 1,000 are included and the 1,001st still works and costs two cents. How to count it, how to show it honestly, and how it becomes a line on a Stripe invoice.
A real money ledger: grants, holds, settlements, refunds and free trial credit that expires. The pricing shape for anything priced per unit, like AI tokens or API calls.
A balance made of lots answers the questions one number cannot: which money expires first, which money a refund takes back, and whether a customer who owes you can spend the credit you gave them. Plus allowances that arrive once per period and roll over by a capped amount.
The round trip. A customer clicks Upgrade, pays at Stripe, and comes back with the plan already live. Later they cancel, and the plan goes away on its own.
What to build in the Stripe dashboard, what to schedule in your app, and what the reporter does when a send times out and nobody knows whether Stripe got it.
Every export is a row in your own database before it is a network call. The seven states, the lease that is two mechanisms and only one clock, the key that makes a retry safe, and what a person does with an outcome nobody knows.
Selling prepaid credit through Stripe Checkout, charging a saved card when the balance runs low, and handling the two events everybody forgets: refunds and chargebacks.
Clusters, durability, alarms and tests. The part you want done before the first real customer.
Six optional workers, what each does, and how to pause one at three in the morning without a deploy. Why nothing here is promised a single run and why that is fine. Credit holds nobody closed, retention that refuses to delete your ledger, and rebuilding a projection from the event log.
Running across more than one server, deciding what may never be lost, the metrics worth an alarm at 3am, the audit log, and tests that can actually fail.
Going from 0.4.0 straight to 1.0: what 1.0 starts refusing, the two settings that keep 0.4 answers while you read the logs, the schema steps that have an order, the wallet migration that has no rollback, and the four things that do not change at all.
While you read
The core is MIT, on Hex, and needs no account. Pro is a drop-in add-on for the Stripe half, and every plan starts with a free trial, so nothing in these guides is gated behind a card.
def deps do
[
{:aurora_meter, "~> 1.0"},
# optional, for Stripe billing
{:aurora_meter_pro, "~> 1.2", repo: "aurorameter"}
]
endBefore you start
Something still unclear? Ask us and the answer usually becomes a guide.