Solution · Internal dashboard
An internal dashboard for your Stripe revenue
Describe the numbers your team cares about and get a private dashboard — revenue, growth and customers — with sign-in, built without touching a line of code.
For anyone · describe it → live, hosted app
At a glance
Is this the right pattern for you?
The short version, before the detail — who this is written for, what you start from, and what exists at the end.
| This solution | |
|---|---|
| Written for | Anyone who can describe what they want |
| You start from | A sentence describing the thing you want to exist |
| You end up with | A live, hosted application on a real URL |
| The path runs | Scope → build → preview → refine → Go Live |
| Built on | Prompt to app · Managed backend · Live preview · Go Live |
| Plan needed | Free to build and preview · Starter for a custom domain |
No timings are quoted anywhere on this page, because how long a build takes depends entirely on what you asked for.
The challenge
Why this is usually hard
Worth understanding before the how — because the reason this is difficult is not the reason most people assume.
Stripe's own dashboard is built to serve every business on Stripe, which means it is excellent at the general case and structurally unable to answer your specific one. The view a team actually argues over in a Monday meeting — this quarter against last, split by plan, with the ten accounts that matter named on the same screen — is almost never one click away. So it gets assembled by hand: an export, a spreadsheet, a chart pasted into a doc, repeated every month by whoever drew the short straw.
The alternative is to build the internal tool, and internal tools are where the economics get strange. Nobody outside the company will ever see it, yet it still needs authentication so revenue figures are not public, a place to run, a way to read the payment data, charting, and a deploy path. That is a real week of engineering for a page whose entire purpose is to save other people twenty minutes.
This pattern exists because the plumbing is the whole cost. When sign-in and the Stripe plumbing come out of vetted bricks and the place it runs is already there, an internal dashboard stops being a project and becomes a description of the numbers you want to look at — including the ones you will want next quarter, which is the part a hand-built tool always handles worst.
How it works
From a sentence to a live app
Every stage in order, including the ones that happen without you asking.
- 1
Describe the numbers, not the interface
An internal dashboard that shows our Stripe revenueSay what the team checks: monthly revenue, growth against last month, revenue split by plan, the accounts contributing most. You are specifying questions rather than components, and the layout is produced to answer them.
- 2
Agree the blueprint in chat
BlueprintA new project starts as a chat rather than a set of tabs. The agent asks what it cannot infer — who is allowed to sign in, what needs storing, which figures are the point — and assembles a blueprint you confirm before the build begins. For an internal tool this is where "who can see this" gets decided deliberately instead of by accident.
- 3
The Stripe connection is part of the stack
Stripe is one of the services the agent writes first-party code against, so the dashboard reads your payment data to populate the charts and totals rather than you exporting a CSV and uploading it. The account it reads is your own Stripe account, connected once. Payments capability is included from the Pro plan.
- 4
Put it behind sign-in before it has any data in it
Authentication is wired in with the rest of the backend, so the dashboard is private from the start. This is the step most hand-rolled internal tools postpone, and postponing it is how revenue figures end up on a public URL that someone shared for convenience.
- 5
Shape the view against real numbers
promptWith your actual data on screen, the gaps become obvious in a way they never are in a planning document. Ask for a date-range filter, a breakdown by product, a churn tile, a comparison against the same month last year. Click a chart in the preview to refine it in place.
- 6
Go Live
Go LivePublish to a real hosted URL the team can bookmark, over HTTPS, sitting behind the sign-in you set up. Connect an internal subdomain from settings on a paid plan if you want it to live under your own name.
- 7
Change it when the question changes
The reason internal dashboards rot is that the metric people care about moves and the person who built it has moved on too. Here the next question is asked the same way the first one was, by anybody on the team, without a ticket.
Why code-anything
What you get out of the box
Not a feature list — the specific things this pattern removes from your side of the work.
The view you actually argue about
Revenue, growth and the specific breakdowns your team checks, on one screen, in the arrangement that answers your question — rather than spread across general-purpose reports built for every business at once.
Private from the first version
Authentication is wired in with the backend, so the dashboard sits behind sign-in before it ever holds a number. Financial data does not spend a week on an unlisted URL while somebody gets around to adding a login.
Reading your real payment data
Stripe is part of the built-in stack, so figures and trends come from your actual payments instead of a spreadsheet someone exported last Tuesday. Payments are included from the Pro plan.
The next metric is a sentence
Need a new tile, a different cut, or last year as a comparison? Ask for it. The usual half-life of an internal dashboard comes from nobody being able to change it; that failure mode is removed.
Usable by the people who need it
Because sign-in is built in, the people who read the numbers each open the same private dashboard with their own login rather than passing a link around.
Room to combine sources
A Postgres schema and access layer are written in when the app needs to store something of its own — notes against an account, a target to compare against, a cached roll-up. The dashboard is a real application, so it is not limited to what one API returns.
In practice
What it looks like
The third line of that prompt is the one worth noticing. "Keep it behind a login" is a whole authentication system in a hand-built internal tool, and it is the step that gets deferred until the dashboard has been informally shared twice.
Here it is a clause, because the auth brick goes in with the rest of the backend code — session handling, a login form and a route guard, already written. The Stripe wiring arrives the same way, pointed at your own Stripe account, and the place it runs is already there. What is left for you to think about is the only part that was ever interesting: which numbers belong on the screen.
An internal dashboard that shows our Stripe revenue.
Monthly revenue, growth vs last month, and our top 10 customers.
Keep it behind a login so only our team can see it.✓ built revenue, growth and top-customer views
✓ connected to Stripe payment data
✓ put the dashboard behind sign-in
✓ running in the live previewWhat you ship
- A dashboard of revenue, growth and top customers, arranged around your questions
- Charts and totals driven by your real Stripe payment data
- Sign-in protection in place from the first version, not added later
- A live hosted URL your team can bookmark, over HTTPS
- A managed Postgres database available when the dashboard needs data of its own
- The ability for anyone on the team to add the next metric by asking for it
What it involves
The honest shape of the path
Stage by stage: what the platform does, and what is genuinely still asked of you.
| Stage | What actually happens | What is asked of you |
|---|---|---|
| Scope | A new project opens in chat before any tabs appear. The agent asks about the parts it cannot guess and fills in a blueprint. | Answer the questions and confirm the blueprint. Nothing is permanent — you can change anything after the first build. |
| Build | The agent plans the work, writes the code and runs it, reaching for the data, auth, email or payments bricks only where the app actually needs them. | Nothing. You can pick a build quality — Prototype, Standard or Best — if you want fewer checks or more review. |
| Preview | A live preview mirrors the real running app, updating as it takes shape. | Look at it properly, including at phone width. This is where problems are cheapest to catch. |
| Refine | Click an element to target an edit, describe the change in chat, or attach a screenshot as a reference to match. | Judgement. This is the part that is genuinely yours, and pointing beats describing. |
| Go Live | The same app you previewed is published to a public URL over HTTPS on managed hosting. | One decision, plus a domain if you want one. Custom domains are included from the Starter plan upwards. |
The path is short because the writing, hosting and deploy steps are not yours to make. The time this takes depends on what you are building, so no page on this site quotes a number.
Describing an app and refining it in the live preview starts on the Free plan, which includes one active project and a managed database, auth and email. Publishing to your own custom domain is included from Starter upwards, and payments are a Pro-plan capability. See the full plan comparison.
What you own
What you are left holding
The thing this pattern produces is an application, not a document inside a builder. That distinction is easy to skip past and it decides what your options look like a year from now — so it is worth being concrete about what exists at the end.
What exists when you are done
- A real codebase, running on managed infrastructure rather than rendered inside a proprietary editor
- A live, public URL served over HTTPS on Cloudflare, with a custom domain available on a paid plan
- A managed Postgres database on Supabase if your app stores anything — standard Postgres, so the data stays queryable and portable
- Authentication, transactional email and payments already connected where the app calls for them
- A version history of build checkpoints on Repository → Changes that you can rewind to
What stays in your hands
- The next change is the same conversation as the first one — no separate CMS and no developer to book
- Nothing is written in speculatively, so a simple page stays a simple page
- A rewind snapshots the current state before it runs, so trying something is not a one-way door
- The preview is the app that ships — there is no export step and no gap between what you approved and what visitors get
FAQ
Common questions
Keep looking
Other reference patterns
Every solution is a worked end-to-end example. If this one is not quite your situation, one of these probably is.
Bakery website
Describe your shop in plain English and watch a real website build itself in a live preview — complete with a contact form that emails you every enquiry.
For anyoneBooking app
Describe the booking flow you want and get a working app — a calendar customers book into and an email confirmation sent on every appointment, all wired up for you.
For anyoneOr the other way of working — connect a repository and get changes as reviewed pull requests:
Add dark mode
Connect your GitHub repo and ask for dark mode. The agent indexes the code, makes the change in a sandbox, verifies it builds, and opens a pull request for you to review.
For developersFix failing tests
Connect your repo and point at the broken test. The agent reproduces the failure, finds the cause, fixes it, re-runs the suite green, and opens a pull request.
For developersJS to TypeScript
Connect your repo and name the components to convert. The agent adds real types, fixes the fallout, verifies the build, and opens a pull request you can review.
For developersBuild stripe dashboard the way it should have been.
Start free. A managed database, authentication and transactional email come wired in, and Go Live puts the app you previewed on a real URL.