My studio site has a guide on internal tools and admin dashboards. It tells clients three things I believe: build the tool around the job, not the database; add permissions and an audit trail from day one; and decide which system owns each piece of data before two of them disagree.

Then I looked at the back office of my own product, VoiceDash, a white-label client portal for voice AI agencies. There is no /admin route. My entire operator tooling is two emails I added on 2 November, plus one log table that agencies can see. This post is what I found when I held them up against my own checklist.

The admin panel I actually built

Stripe sends no email when someone starts a $0 trial. For a while that meant a new agency could sign up and I would only notice by opening the Stripe dashboard. So the platform webhook now emails me after it sends the customer their welcome email:

// Tell VoiceDash's owner about the signup. Stripe sends nothing for a $0 trial start. await sendEmail({ to: SIGNUP_ALERT_EMAIL, ...newSignupAlertEmail({ agencyName: workspace.name, adminEmail: email, planName, billingCycle: cycle, price: formatPrice(price), trialEndsAt: isTrial ? trialEndsAt : null, stripeCustomerUrl: await stripeCustomerUrl(stripe, session.customer as string, event.livemode), livemode: event.livemode, }), }); 

Eleven minutes later I added a second one on invoice.paid. The subject line tells me what kind of money it is, and test-mode events are prefixed [Test] so they never look like revenue:

subject: `${payment.livemode ? "" : "[Test] "}${kind}: ${payment.agencyName} paid ${payment.amount} for ${payment.planName}`, 

Two details here I am still happy with.

The Stripe link names the account. I moved VoiceDash between Stripe accounts once (that story is here), and my Stripe login can see more than one. A bare /customers/cus_123 link opens whichever account was last active, which is how you end up staring at "No such customer" for someone who definitely paid:

async function stripeCustomerUrl(stripe: Stripe, customerId: string, livemode: boolean) { const account = await stripe.accounts.retrieveCurrent().catch(() => null); return `https://dashboard.stripe.com/${account ? `${account.id}/` : ""}${livemode ? "" : "test/"}customers/${customerId}`; } 

And the label errs toward the boring answer. To tell a first payment from a renewal, the handler lists the customer's recent paid invoices. If that Stripe call fails, it assumes the customer has paid before:

const paidBefore = await stripe.invoices .list({ customer: invoice.customer as string, status: "paid", limit: 10 }) .then((list) => list.data.some((i) => i.id !== invoice.id && i.amount_paid > 0)) .catch(() => true); 

A false "Renewal" is a mild annoyance. A false "First payment" is a trial conversion I would celebrate that never happened. When a label drives how you feel about your business, pick the failure that underclaims.

That is the good part. Here is the rest.

My inbox only hears about money coming in

The webhook handles six Stripe events. The owner alert fires on two of them:

Event Customer gets an email I get an email
checkout.session.completed yes yes (new trial / subscription)
customer.subscription.created / updated on plan change no
customer.subscription.deleted yes no
invoice.paid yes (if over $0) yes (unless it is the checkout invoice)
invoice.payment_failed yes no

So my "dashboard" is a feed of good news. A cancellation sends the agency a polite email and drops their workspace to Starter, and I hear nothing. A failed renewal marks the subscription past_due and emails the agency a billing portal link, and I hear nothing. If an agency churns quietly, the first sign is a renewal email that does not arrive, and nobody notices an email that does not arrive.

My own guide says the person who uses the tool every day should shape it. I am that person, and I built the version that feels nice to receive rather than the one I would act on. A cancellation is the alert I can do something about: reply, ask why, offer help. A payment received is the one I can do nothing about except smile.

An alert that fails is indistinguishable from no signup

Every email in VoiceDash goes through one helper, and it never throws:

export async function sendEmail({ to, subject, html }) { if (!process.env.RESEND_API_KEY) { console.warn("RESEND_API_KEY not set, skipping email:", subject); return; } try { const res = await fetch("https://api.resend.com/emails", { /* ... */ }); if (!res.ok) console.error("Failed to send email:", await res.text()); } catch (err) { console.error("Email send error:", err); } } 

For customer email that is a defensible choice: a flaky email provider should not make Stripe retry the whole webhook and double-write the database. For an operator alert it means the absence of an email has two meanings. Either nobody signed up, or the alert failed and the only record is a log line in Vercel that I do not read. I wrote a whole post about a cron job that returns 200 when every fetch fails, and here is the same shape again, one repo over.

An inbox is a fine notification channel. It is a bad system of record, because it cannot tell you what it never received.

The one audit trail I have always says success

VoiceDash does have something that looks like an audit trail. Agencies get a "Webhook logs" tab in settings showing the last 50 events from Retell and Vapi, with a success or failure badge on each. This is the code that writes a row, in the Retell webhook handler:

await prisma.webhookLog.create({ data: { workspaceId: agent.workspaceId, agentId: agent.id, event: event || "call_ended", platformCallId: call.call_id, importResult: "success", }, }); 

It runs right after the agent lookup and before the transcript is stored. importResult is the string "success" before any importing has happened, and nothing ever updates it. The schema also has forwardResult and payload columns, and a search of the codebase finds no code that writes either. The tab decides the badge like this:

const isSuccess = (log: any) => log.importResult === "success" || log.importResult?.success === true; 

So every row is green. The one case the log can catch is a webhook for an agent VoiceDash does not know, and that returns 404 before a row is written, so it is not in the log at all. The tab was built in March, in commits I titled "lots of stuff" and "fixes", and I think it was scaffolded with the intention of filling in the result later. Later never came, and the UI shipped with a column that cannot fail.

This is worse than having no log. An agency debugging a missing call opens the tab, sees a green row for that call, and reasonably concludes the problem is on Retell's side.

Who owns the plan

The guide's last rule is to decide which system owns each piece of data. In VoiceDash, Stripe owns the subscription and Workspace.plan is a copy that the webhook keeps in sync. That is the right shape. What is missing is any record of the changes. When customer.subscription.deleted arrives, the handler sets plan: "STARTER" on the workspace and flips the WorkspaceSubscription row to canceled. That row keeps the last plan, but it is updated in place, so an upgrade followed by a downgrade leaves only the final state. There is no table of Stripe events I have processed, so I cannot answer "when did this workspace change plans?" from my own database. The answer lives in Stripe's event log, which is exactly the kind of "go look in the other system" step my guide tells clients to engineer away.

What I would change, in order

None of this is shipped yet. It is the list I am taking back to the repo:

  1. Alert on the bad news. Add owner alerts for customer.subscription.deleted and invoice.payment_failed, using the same layout and the same [Test] prefix. This is maybe twenty lines.
  2. Write the log after the work, not before. Create the WebhookLog row with the real outcome of the import and the forward, or create it as pending and update it. A log that can only say success should not render a success badge.
  3. Keep a small table of processed Stripe events. Event id, type, workspace, previous and new plan, timestamp. It doubles as an audit trail and as an idempotency check, since the handler currently has no way to notice Stripe delivering the same event twice.
  4. One read-only ops page before any write actions. Workspaces, plan, trial end, last call synced, last alert sent. No buttons yet. Permissions and buttons come after I know what I click most.

The lesson I keep relearning

The emails were two small commits and they genuinely changed how I run the product: I now know about every trial the minute it starts. But an internal tool is judged by whether it tells you about the thing you need to act on, and whether it can tell you when it failed. Mine covers the happy path in my inbox and paints the unhappy path green in a log tab.

If you run a small SaaS without an admin panel, what is your back office actually made of? Emails, a Slack channel, a saved SQL query, the Stripe dashboard? I am curious which one people trust enough to act on.

This builds on a guide I wrote for my studio, Internal Tools and Admin Dashboards: When to Build Custom Back-Office Software, which covers the client-side version of these decisions.