Most camps that care about data have already picked their metrics: returning-camper rate, fill rate by session, staff ratio compliance, outstanding balances, incident counts, maybe a scholarship utilization number the board likes. If you haven't done that part yet, start with a prioritized KPI framework to measure camp operational health across a season. Everything below assumes you already have a list.
The trouble starts after the list exists. A metric gets reported, a decision gets made because of it, and a few months later someone recomputes it and gets a different answer. Or a trigger meant to flag unpaid balances fires on the wrong families, and the registrar quietly stops trusting it. Or a board member asks why retention changed between the spring and fall meetings, and nobody can explain it without two weeks of digging.
That isn't a KPI problem. It's an operating model problem. Nobody owns the definitions. Nothing tests the numbers before they go out. Nothing stops a bad refresh from feeding a live alert. And nobody wrote down that the registration form changed in January and broke three metrics.
This article covers the system that closes those gaps: data stewards, acceptance tests, quality gates, metric SLAs, change control, and a way to build all of it over a few seasons. It is not a six-week project.
Start with the failure: trace one bad number backwards
The pieces make more sense if you take one realistic failure and follow it upstream.
A mid-sized overnight camp tells its board in November that the returning-camper rate is 58%. The board reacts the way boards do. They approve a returning-family discount and a re-enrollment outreach push, roughly $8k–$9k in discount cost and staff time combined. In February the new registrar rebuilds the report for a grant application and gets closer to 68%.
Four things went wrong, and none of them is exotic:
-
The denominator included campers who had aged out. Somewhere around 35–40 of last year's ~410 campers were too old to return. Nobody had written down whether "eligible to return" excluded them, so the original query counted them.
-
Sibling records were duplicated. When the camp switched registration platforms two seasons earlier, about a dozen kids ended up with two profiles each. The prior-year list counted them twice, and the current-year match missed them.
-
Late deposits were missed. The report ran off a snapshot taken the day before a deposit deadline. Six families paid the next morning.
-
Nobody could rerun the original number. Whoever built the November report used a spreadsheet filter that wasn't saved anywhere.
Each of those maps to a missing piece of the operating model:
| What went wrong | Missing piece | What would have caught it |
|---|---|---|
| Aged-out campers in denominator | Definition ownership | A named owner who signed off on "eligible = age-eligible + attended prior year" |
| Duplicate sibling profiles | Data stewardship + quality gate | A nightly duplicate check on name + DOB + household |
| Snapshot timing | Metric SLA | A rule that board metrics use a snapshot taken X days after a deposit deadline, never before |
| Couldn't reproduce the number | Acceptance test + change control | A saved query, a frozen snapshot ID, and a known-answer test |
The decision itself wasn't dumb. If retention really were 58%, spending money on it would be reasonable. The failure was that an unvalidated number went straight into a spending decision with no checkpoint in between. The rest of this article is about building that checkpoint.
Why camps get this wrong more than other small businesses
Plenty of small businesses have messy data. Camps have a few structural quirks that make it worse, and the fixes depend on them.
Simplify camp operations with centralized control.
Campyly empowers you to manage registrations, staff, and activities seamlessly—all from one platform.
- Integrated camper and staff management
- Automated notifications and alerts
- Dynamic scheduling and resource allocation
No credit card required
Most camp metrics produce one data point per year. A restaurant that miscounts covers will notice by Thursday, because the number is computed daily and someone sees it drift. Returning-camper rate, cost per camper-week, and scholarship utilization get computed once or twice a season. An error in an annual metric can survive three or four years, because nobody sees enough repetitions to spot the pattern. By the time someone catches it, the history is polluted too.
The people who know the definitions are often seasonal. The assistant director who figured out how to count transfers between sessions might not be back next summer. Year-round staff at a lot of camps is three to six people, and any of them can leave. Definitions that live in someone's head leave with them.
Systems change between seasons. Camps swap registration platforms, rebuild forms, add session types, change price tiers. Every change is a chance for a field to shift meaning while the metrics depending on it stay the same. If your data runs through several disconnected tools, your registration system is probably lying to you in ways that compound, and an operating model can't repair the architecture underneath. It can catch the lies before they reach a decision, though.
Boards bring expectations from their day jobs. A board member in finance or healthcare is used to numbers that reconcile and get formally restated when they change. When a camp's number moves between meetings with no explanation, that person doesn't just distrust the one number. They distrust all of them, and that costs more than the bad metric did.
A lot of camps respond by hiring a part-time analyst or buying a dashboard tool. That helps with presentation and does nothing for trust. A dashboard fed by unowned, untested data just shows wrong numbers more attractively.
What breaks as the camp grows
What you need depends heavily on size and complexity. A single-session day camp with 150 kids can get away with things a multi-site organization can't.
| Stage | Who computes metrics | Where definitions live | Typical failure | What you actually need |
|---|---|---|---|---|
| Single site, 1–3 sessions, under ~250 campers | Director, in a spreadsheet | Director's head | Numbers can't be reproduced after staff turnover | Written definitions + a saved query for each board metric |
| Single site, 5+ sessions, 400–900 campers | Registrar + director, some exports | Scattered docs, maybe a shared drive | Session transfers, siblings, and partial-week enrollments counted differently by different people | Named stewards, acceptance tests for the top 8–12 metrics |
| Multiple programs (day + overnight + family camp) | Each program lead runs their own numbers | Each program has its own version | Same metric name, different meaning across programs; board sees totals that don't add up | Central metric registry, change control, publication gate |
| Multi-site or partnerships | Mix of staff, partners, sometimes a contractor | Contracts, partner reports, spreadsheets | Partner data arrives late or in different formats; nobody owns reconciliation | Metric SLAs with partners, data-quality dashboard, formal restatement process |
The jump from row two to row three is where most camps get hurt. Running a day camp and an overnight camp under one organization feels like one operation, but the two programs often define "camper" differently. A day camper attending three non-consecutive weeks might count as one camper, three enrollments, or three camper-weeks, depending on who ran the report. Add those together and the board sees a total that means nothing.
The usual mistake at this stage is letting each program lead keep their own definitions "because their program is different." Sometimes it really is different. Fine, then give the metric a different name. Just don't publish two different things under one label.
The operating model, piece by piece
There are five parts, and they lean on each other. Ownership without tests is just someone to blame. Tests without gates still let bad data through. Gates without change control break every time somebody edits a form.
Data stewards: ownership that matches how camps actually run
"Data steward" sounds corporate, but in a camp it's usually someone already on payroll who gets explicit responsibility for one slice of data. Two roles tend to get blurred, so separate them:
-
Metric owner decides what a metric means. Signs off on the definition, the exclusions, and the thresholds that turn it into a trigger. Usually the director or a senior leader.
-
Data steward keeps the source data clean enough for the metric to be computed correctly. Fixes duplicates, chases missing fields, knows which system is the source of truth. Usually whoever handles that data day to day.
At a typical overnight camp it might split like this. The registrar stewards enrollment, household, and payment data. The health center lead stewards medical forms and incident data, with clear limits on what gets shared. The program director stewards attendance and activity data. The business manager stewards anything that reconciles to the general ledger.
The most common mistake is making the director the steward of everything. Directors make good metric owners because they decide what matters. They make bad stewards because in season they don't have twenty minutes a day to look at duplicate records. If the director is the steward, stewardship effectively ends in mid-June.
Handing stewardship to the IT person or an outside contractor is almost as common, and it goes wrong too. They can fix technical issues, but they won't know that a family listed under the grandmother's name is the same household as the one under the mother's. Stewardship needs operational context more than technical skill.
Write it down as a one-page steward register: each data domain, the steward, the backup steward, and the source system.
Seasonal staff turn over, so backups matter more here than in most businesses.
Acceptance tests: proving a metric is right before anyone uses it
Most camps skip this, and it does the most good. An acceptance test is a short written check a metric has to pass before it counts as valid. Software teams do this for code. You're doing it for numbers.
This template works for camp metrics. Keep one per metric, stored wherever your team actually looks, whether that's a shared doc, a wiki page, or a field in your operational platform.
METRIC ACCEPTANCE TEST Metric ID: RET-01 Metric name: Returning camper rate Metric owner: Executive Director Data steward: Registrar Version: v3 (effective 2025-09-15) DEFINITION Numerator: Campers enrolled (deposit received) in current season who attended ≥1 full session in prior season Denominator: Campers who attended ≥1 full session in prior season AND are age-eligible for current season Exclusions: Staff children on comp registrations; campers withdrawn for medical/safety reasons in prior season Unit of count: Unique camper (deduplicated by DOB + legal name + household) Snapshot rule: Computed from snapshot taken 7 days after final early-registration deposit deadline SOURCE OF TRUTH Enrollment: Registration platform, enrollment table Deposits: Payment processor export, reconciled to ledger TESTS (all must pass) T1 Known-answer: Recompute prior season using frozen snapshot SNAP-2024-11-08 → must equal 61.4% (±0.1) T2 Duplicate check: Zero unique campers sharing DOB + household + similar name in denominator T3 Age eligibility: Zero campers in denominator above max age for current season T4 Reconciliation: Count of deposits in numerator within ±2 of payment processor deposit count for same population T5 Edge cases: Sibling transfer case, mid-session withdrawal case, and scholarship comp case each produce expected result (see test records TR-14, TR-15, TR-16) TOLERANCE / STATUS Pass: All tests pass Warn: T4 off by 3–5 → publish with footnote Fail: Any of T1–T3 or T5 fail, or T4 off by >5 → do not publish LAST RUN: _ RESULT: RUN BY: _
A few parts of this matter more than they look.
The known-answer test (T1) catches silent breakage. You freeze a past snapshot and record what the metric should be for it. Any time someone changes the query, the form, or the source system, rerun the metric against that frozen data. If the answer moved, something in the logic changed, intentionally or not. Without it, you won't find out a platform update broke your numbers until a board member does.
The edge-case records (T5) are small hand-built test records for the weird situations your camp actually has. One kid transfers from Session 2 to Session 4. A camper withdraws on day two because of homesickness. A scholarship family has a $0 deposit. Each record has a written expected result. Building them takes maybe an hour per metric, and it forces the metric owner to decide what should happen in each case instead of accepting whatever the query does by default.
The warn tier is what makes the whole thing livable. If every small discrepancy blocks publication, people will route around the tests. A middle state where you publish with a footnote keeps things honest without turning the process into a bottleneck.
You don't need this for every metric. Do it for anything that goes to the board, anything that triggers an automated action, and anything tied to money. For most camps that's somewhere between 8 and 15 metrics.
Quality gates: where bad data gets stopped
Acceptance tests check whether a metric's logic is right. Quality gates check whether today's incoming data is fit to use. Those are different questions, and camps that only answer one get burned by the other.
Three gates matter for camps.
Gate 1, at entry. Form validation and required fields at the moment data is created: registration forms, health forms, incident reports, attendance check-ins. Stopping a bad date of birth at entry is far cheaper than hunting for it later. Most registration platforms support more validation than camps ever configure.
Gate 2, at refresh. Every time data gets pulled or synced (nightly, or hourly in season), run a few automatic checks before any metric or trigger touches it:
-
Freshness did the sync actually run?
-
Volume is today's record count roughly in line with yesterday's?
-
Completeness what share of required fields are filled?
-
Duplicates did new duplicate profiles appear?
Gate 3, at publication. Before a number goes to the board, to parents, or into a grant report, a human confirms the acceptance tests passed and signs off.
Gate 2 is where triggers and alerts live, and it's where a quiet trust-killer shows up. Say a camp sets up an automated alert: notify the cabin counselor when a camper's medical form is incomplete three days before arrival. Then a sync duplicates about 40 profiles. Each duplicate has a blank medical form, because the real one is attached to the original. Counselors get 40 false alerts. Most of them stop reading the alerts, and three weeks later they're still ignoring them when a real gap shows up.
A trigger running on unvalidated data is worse than no trigger, because it teaches people to ignore the channel. So when Gate 2 fails, triggers should be suppressed or flagged as unreliable, not fired as usual. The rule can be simple: if the refresh fails the duplicate or volume check, hold all automated parent- and staff-facing alerts and notify the steward instead.
Metric SLAs: agreeing on what "current" and "correct" mean
A metric SLA is a written promise about a metric: how fresh it'll be, how accurate, and how fast someone responds when it breaks. Without one, every conversation about data quality turns into an argument about expectations.
This is roughly what a set of camp SLAs looks like. The specifics will differ by camp, but the shape is common:
| Metric | Freshness | Accuracy tolerance | Steward | Response when breached |
|---|---|---|---|---|
| Daily headcount (in season) | By 9:30am each day | Exact; reconciles to rollcall | Program director | Fix before lunch; director notified |
| Outstanding balance by family | Updated nightly | Within $1 of ledger | Registrar | Within 1 business day |
| Session fill rate | Updated nightly | ±1 seat | Registrar | Within 1 business day |
| Medical form completeness | Updated nightly, pre-season | Exact per camper | Health center lead | Same day during the 2 weeks before arrival |
| Staff ratio compliance (in season) | Each activity block | Exact | Program director | Immediate |
| Returning camper rate | At board snapshot dates only | Passes acceptance test | Registrar / ED | Before board pack is finalized |
| Cost per camper-week | Monthly, after ledger close | Reconciles to ledger | Business manager | Within 1 week of close |
Freshness needs vary a lot between metrics, and that's correct. Ratio compliance during program hours has to be live. Returning-camper rate only matters a few times a year. Pushing everything toward "real-time" is a classic mistake, because it creates pressure to compute annual metrics daily from incomplete data, which is exactly how the 58% problem happens.
Also notice the response column is about people, not tools. "Nightly refresh" means nothing if nobody's responsible for checking that it ran.
Change control: the piece everyone skips until it bites them
Every camp changes things between seasons. A new session type, a renamed field, a merged price tier, a new registration form, a new partner program. Any of these can quietly redefine a metric.
At camp scale, change control doesn't need a committee. It needs a log and a rule. The log records:
-
What changed and when
-
Why
-
Which metrics it affects, which you can find by checking which acceptance tests reference the changed field or table
-
Whether historical numbers need restating
-
Who approved it
The rule: no metric definition changes silently. If the definition of "camper" changes because you added a weekend family-camp program, you either restate prior years under the new definition or footnote every report showing the series. Boards are fine with restatements when they're explained. What they can't handle is numbers that move for no stated reason.
When a field changes in the registration platform, rerun the known-answer tests for every metric that touches it. Still passing? Log it and move on. Failing? You just found the problem in January instead of at the November board meeting.
Most camps are surprised by how many unlogged changes they've already made. The first time you build a change log, go back through the last two seasons of platform changes, form edits, and new programs. It's usually longer than anyone expected, and it explains several numbers that never quite made sense.
How the pieces connect: one flow from form to decision
Seeing the whole flow in order makes it clearer how one gap undermines everything downstream.
A parent fills out the registration form, and Gate 1 catches the obviously bad entries: impossible birthdates, missing emergency contacts, an age outside the session range. The record lands in the registration platform, the source of truth for enrollment. Overnight, data syncs to wherever metrics get computed, which might be the same platform, a separate reporting tool, or a spreadsheet pulled from exports. Gate 2 runs on that sync, checking freshness, volume, completeness, and duplicates. If Gate 2 fails, triggers are held and the steward gets a note. If it passes, metrics are computed, and any metric with a threshold-based trigger evaluates it. The outstanding-balance trigger, for example, builds tomorrow's call list for the registrar.
This workflow diagram shows the flow from form entry through gates, syncs, metric computation, acceptance tests, and publication.
When a trigger fires, the action is logged with the metric value, the data snapshot it ran against, the threshold, and what was done. Board metrics are computed only at scheduled snapshot dates and then run against their acceptance tests. If they pass, Gate 3 sign-off happens and the number goes into the board pack with its version and snapshot ID. If anything upstream changed during the season, the change log shows it, and any affected metric gets footnoted or restated.
People underrate the trigger log, and it's what makes decisions reproducible. Say a family disputes being sent to collections. You can show the balance on the date the trigger fired, the snapshot it used, and the rule that applied. Say the board asks why you cut a session. You can show the fill rate on the decision date, the acceptance test result, and the threshold you agreed on in advance. That's the difference between "we looked at the numbers" and a decision you can actually audit.
Turning a KPI into a trigger without breaking trust
A KPI is something you look at. A trigger makes something happen. Most KPI lists jump from the first to the second with nothing in between, and that's where the false alarms come from.
This is the sequence for promoting a metric from "reported" to "trigger." Do it one metric at a time.
-
Confirm the metric has passed its acceptance test for at least one full cycle. If it's never been tested, it's not ready to drive actions.
-
Write the threshold and the action together. "Balance over $500 within 21 days of session start → registrar calls family within 2 business days." A threshold without an action is just a red cell on a dashboard.
-
Name who receives the trigger and who can override it. The registrar gets the call list, and the director can mark a family as having an approved payment plan so they drop off the list.
-
Set the Gate 2 dependency. Decide which quality checks must pass for this trigger to fire. For balance triggers, that's the payment sync freshness check and reconciliation to the ledger.
-
Run it in shadow mode for two to three weeks. The trigger computes and logs, but nobody acts on it. The steward reviews what it would have flagged and checks for false positives.
-
Go live, and log every firing. Record the value, the snapshot, the action taken, and any override.
-
Review false positives monthly at first, then each season. If more than a handful of firings were wrong, go back to step 2 and fix the threshold or the logic.
Shadow mode is the step people want to skip, and the one that saves them. Run a balance trigger in shadow for a couple of weeks before opening day and you'll almost always turn up a category nobody thought about: scholarship families with a technical balance due, families who paid by check that hasn't been entered yet, families with a credit from a prior cancellation sitting in a different field.
Finding those in shadow mode costs nothing. Finding them after an automated reminder goes to a scholarship family costs you that family's trust.
The data-quality dashboard: watching the plumbing, not the metrics
Most camps that build dashboards build them for the metrics: fill rates, balances, headcounts. That's useful, but you also want a second, smaller view showing the health of the data behind those metrics.
It doesn't need to be elaborate. At a glance, it should answer:
-
Did last night's sync run, and when?
-
Did any Gate 2 checks fail (freshness, volume, completeness, duplicates)?
-
Which acceptance tests passed on their last run, and when was that?
-
How many open data exceptions exist per steward?
-
How old is the oldest unresolved exception?
-
Which triggers are currently suppressed because of a failed gate?
-
Were any changes logged in the past week that touch a tested metric?
The age of the oldest exception tells you the most. A camp might have 30 open exceptions and be fine if they're all from this week. If the oldest is from March, stewardship has stopped happening, and the metrics depending on that data are drifting.
In season, the director should spend about two minutes on this view every morning, before looking at the actual metrics. Off-season, weekly is enough. You're not fixing things from the dashboard. You're deciding whether today's numbers deserve trust before you act on them.
Real scenario: a multi-program camp fixing its board pack
Business type: A nonprofit running a day camp and an overnight camp on one property, with about 850 unique campers across seven overnight sessions and nine day-camp weeks, plus a small family-camp weekend program added two seasons ago.
The problem: Preparing the board pack took about three weeks of part-time effort, roughly 35–45 hours spread across the director, registrar, and business manager. Numbers had been restated between meetings twice in one year without a clear explanation. The day camp counted campers per week and the overnight program counted per session, and the board saw a combined "campers served" figure that mixed both. The outstanding-balance reminder, set up in their registration platform, kept going out to scholarship families, so the registrar had stopped trusting it entirely. She rebuilt the list by hand every Monday.
What they changed: They picked the 11 metrics that went to the board or drove an automated action and wrote acceptance tests for each, starting with the four the board asked about most. The registrar became steward for enrollment and payments, with the day-camp coordinator as backup. They split "campers served" into "unique campers" and "camper-weeks," restated the prior two years under the new definitions, and footnoted the change in the next board pack.
The balance trigger ran in shadow mode for about three weeks, which turned up two categories of false positives: scholarship balances and families with unapplied credits. Both got excluded in the trigger logic. They also started a change log, which immediately explained one of the earlier unexplained restatements. A form field for session preference had been repurposed mid-season.
Before vs. after, over roughly one season:
-
Board pack prep dropped from around 40 hours to somewhere in the 12–15 hour range, mostly because numbers no longer needed re-checking by hand
-
Unexplained restatements went from two in a year to zero. There was one planned restatement, explained up front
-
Balance-trigger false positives went from "enough that nobody used it" to a few per month, and the registrar stopped her Monday rebuild
-
The board approved the next season's budget in one meeting instead of the usual two, and the treasurer specifically noted the footnoted definitions
None of this needed new software. Their existing registration platform supported most of it. The hard part was deciding on definitions and writing them down.
The maturity roadmap: building this over seasons, not weeks
Trying to stand up the whole model in one off-season is a reliable way to end up with half-finished documentation and nothing actually running. Build it in stages, each useful on its own.
Stage 1: Reproducible. Every board metric has a written definition, a saved query or report, and a named owner. You can rerun last meeting's number and get the same answer. For most camps that's one off-season of focused work, and it alone eliminates a large share of board-meeting surprises. If you're not here yet, getting here matters more than anything else in this article.
Stage 2: Tested. Your top 8–15 metrics have acceptance tests with known-answer snapshots and edge-case records. A steward register exists with backups. A Gate 3 publication sign-off happens before every board pack. Most camps with a full-time registrar can get here in the second off-season.
Stage 3: Gated. Nightly Gate 2 checks run automatically. A simple data-quality dashboard exists. Triggers are suppressed when gates fail. The change log is in active use, and platform or form changes trigger known-answer reruns. This is where automation starts paying off, because nobody wants to run duplicate checks by hand every night in July.
Stage 4: Auditable. Every trigger firing is logged with its snapshot. Metric SLAs are written and reviewed each season. Restatements follow a defined process. Partner or multi-site data comes in under agreed SLAs. Decisions tied to metrics can be reconstructed months later. Few small camps need to go fully here. Multi-site organizations and camps with significant grant or public funding usually do.
The trap is jumping to Stage 3 because the tooling looks appealing. Automated quality checks on undefined metrics just tell you, very efficiently, that something looks off, without telling you what "right" is supposed to be.
Where AI-assisted operational software actually helps
Software is useful here, but mostly for the repetitive middle of the process, not the judgment calls at either end.
Deciding what "returning camper" means is a human decision. So is choosing which edge cases matter and whether to restate history. No tool should make those choices for you.
Operational platforms with AI automation earn their keep in the tedious nightly work in between: running Gate 2 checks on every sync, flagging likely duplicate profiles for the steward with a confidence score instead of merging them automatically, holding triggers when a gate fails, rerunning known-answer tests when a field changes, and logging each trigger firing with its snapshot. Some platforms can also draft a change-log entry when they detect a form or field change, or summarize the morning's open exceptions per steward. That saves the director from opening four screens before breakfast in the middle of session.
Look for tools that keep a human in the loop on anything that changes a definition or merges records. That matters more than automation speed. A system that silently "fixes" duplicates is just another source of unlogged change.
Pre-publication checklist for any board pack
Use this at Gate 3, before numbers leave the building:
-
Every metric in the pack has a current acceptance test, and the last run passed or warned
-
Every warned metric carries a footnote explaining the discrepancy
-
Every metric shows its version and the snapshot date it was computed from
-
The change log has been checked for anything since the last pack that affects these metrics
-
Any definition changes are restated or footnoted, never silently applied
-
Totals that combine programs use consistent units (unique campers vs. camper-weeks vs. enrollments)
-
Numbers that appeared in the last pack and changed have a one-line explanation
-
The metric owner has signed off, not just the person who ran the report
-
Snapshots used for this pack are frozen and stored so these numbers can be reproduced later
For how to structure the pack itself, including what to show, how to frame trends, and how to keep it readable for volunteer board members, see board-ready reporting for camp boards and directors with KPIs. The checklist above is about whether the numbers are trustworthy. That post is about presenting them well.
When this actually makes sense
A formal camp data operating model earns its keep when numbers drive money, safety, or reputation decisions, and when more than one or two people touch the data. Specifically:
-
Your board approves spending or pricing based on metrics you report
-
You run more than one program type and report combined totals
-
You have, or plan to have, automated triggers that contact parents or staff
-
You report to grantors, funders, accreditors, or partner organizations who might audit the numbers
-
You've had at least one embarrassing restatement or "where did this number come from" moment
If two or more of those are true, Stage 1 and Stage 2 are almost certainly worth the off-season time.
When this is a bad idea
Don't stop operations to build documentation in the six weeks before opening day. Every steward is underwater then, and anything you write will be half-done and ignored. Do this work between September and February.
It's also a bad idea to build acceptance tests for metrics nobody acts on. If a number sits on a dashboard and no decision has ever depended on it, either drop the metric or leave it untested. Testing everything spreads attention thin and makes the whole process feel like bureaucracy.
Third, if your underlying data architecture is genuinely broken, with multiple systems disagreeing on basic enrollment counts and no clear source of truth, fix that first. Quality gates on top of a broken architecture will fail every night, and people will learn to ignore the dashboard.
Who should NOT do this (yet)
A single-session day camp under about 150 campers, run by a director who does their own registration and reports to a small, informal board, doesn't need stewards, SLAs, or a change-control log. Write down your definitions, save your queries, and keep a note of what changed each year. That's Stage 1, and it's enough.
Camps in their first or second season shouldn't build this either. You don't yet know which metrics matter or what your edge cases look like. Run a season or two, keep notes on what confused you, then formalize.
And if no one on staff will own stewardship as part of their actual job, with real time allocated, don't create the role on paper. An unstaffed steward register is worse than none, because it gives the board false confidence that someone is watching the data.
Where to start next week
Pick the one metric your board questioned most at its last meeting. Write its definition, including the exclusions, the unit of count, and the snapshot rule. Find a past snapshot you can freeze and record what the metric should equal for it. Build two or three edge-case records for the weird situations your camp actually has. Assign a steward and a backup. Then rerun the number.
You'll probably find something, because most camps do the first time: an exclusion nobody agreed on, a duplicate pattern left over from an old migration, a field that changed meaning two seasons ago. Write it in the change log, decide whether to restate, and tell the board before they find out on their own.
Once one metric has been through that process, the other ten go a lot faster. The definitions, the stewards, the known-answer snapshot, and the change log all carry over, and each new metric mostly costs you the hour it takes to write its edge cases.
The payoff shows up the next time someone asks where a number came from. You'll have an actual answer, with a version, a snapshot, and an owner behind it, instead of a two-week project to reconstruct what happened.
Ready to elevate your camp management?
Join 500+ camps using Campyly to save administrative time, enhance camper experiences, and streamline daily operations.