Discovery, Architecture
& Prototype
Three forces work against a clean build
The next several slides walk through each one. They're worth reading slowly — they're why this contract is structured the way it is.
Apricot's permanence
Several design decisions, once made in Apricot, cannot be undone without rebuilding the system from scratch.
Underestimation is normal
Almost every major system implementation underestimates the work. It's a structural feature of complex projects meeting limited time — the shape of the trap is the same everywhere.
Hidden complexity
UHO's operations look clean on a flowchart. The technical work behind each box on that flowchart is substantial.
Apricot locks in decisions made early
Apricot is a powerful platform for HIPAA-compliant case management. But it's also structurally rigid: several decisions you make in the first weeks of a build are essentially permanent.
"Permanent" doesn't mean "hard to change." It means: changing them requires deleting the affected structure and rebuilding it, which destroys the data inside and breaks any workflow that was already running. Bonterra support cannot reverse some of these without significant data loss.
The next slide lists the six rules that lock in. Each one shapes what UHO's system can and cannot do later.
Six Apricot decisions that lock in
Each rule shapes architectural choices. Getting them wrong on first build is the most common cause of expensive Apricot rebuilds.
What it costs when these decisions go wrong
A wrong build doesn't just cost the rebuild. It costs everything that was layered on top of the broken structure.
Direct rebuild cost
Building Apricot the right way the second time takes longer than the first. You're paying for the new architecture AND for migrating all the data trapped in the broken structure AND for cleaning up corrupted relationships.
Retraining cost
Every staff member who learned the broken system has to learn the new one. Months of operational muscle memory get thrown out. Documentation gets rewritten. Reports get rebuilt.
Lost reporting cycles
If a grant report needs data that the broken system didn't capture cleanly, that reporting period is compromised. Grants depend on these reports. Renewals depend on these reports.
Operational drift
While the rebuild happens, UHO is either running on the broken system or running on spreadsheets. Either path costs staff time and risks data quality.
This is why Foundation Phase exists: to make these decisions once, correctly — before anything is locked in.
This isn't theoretical — UHO has lived this pattern
UHO has already attempted to set up Apricot through Apricot's onboarding program. That attempt did not produce the system UHO needed.
What happened
- Apricot's onboarding has a clock. A fixed window in which the customer must come prepared with their full system design.
- UHO didn't have the design ready. The vision existed; the architectural decisions and the operational mapping that translate vision into structure didn't.
- The clock ran out before the design was right. What got built into Apricot was therefore the system UHO could decide on in the time available — not the system UHO actually needs.
- The result is not expandable. Adding the four-stream operating system Marina has drawn requires going around — or undoing — what's currently configured.
This is exactly the pattern Foundation Phase prevents. No clock. No shipping under pressure. Design first, build second.
Underestimation is normal — and protectable
Almost every nonprofit attempting a major system implementation underestimates the work. It isn't a UHO problem; it's a structural feature of complex projects meeting limited time.
The shape of the trap
The flowchart looks clean. The vision is clear. So the work to translate vision into a working system is assumed to be straightforward. It isn't. Every box on the flowchart hides forms, fields, validation rules, conditional logic, and reporting needs.
By the time the complexity becomes visible, budget and time are usually already committed — and pressured decisions get made that lock in the wrong architecture.
How Foundation Phase breaks it
Two short working sessions per week, plus structured homework, let UHO see the complexity gradually — while there is still time to design around it. Decisions are made informed, not rushed.
Marina and Marta troubleshoot their own operational logic during the homework — every pack is also a training exercise. By the time architecture is locked in, UHO understands exactly what's being locked in and why.
The flowchart looks clean. The work behind it isn't.
Marina's flowchart shows the what — what UHO wants the system to do. The technical work is the how — how every box on that flowchart becomes a structure that actually runs in Apricot.
The next two slides do this concretely: first, the full flowchart with one row highlighted; then, the same row unpacked to show what's actually inside.
Marina's flowchart, with one row marked
The Onboarding Gate row contains four sub-rows — Client, Staff, Training, Partner. Each is one box. Each hides a system of forms, fields, logic, and validation. Next slide: let's pick the Client gate and unpack it.
What's inside "Client Onboarding Gate"
Important: the 8 forms above are illustrative — an example of what a Client gate may need. Homework Pack #2 is what nails down what UHO's Client gate actually contains, and Packs #2–#4 do the same for the Staff, Training, and Partner gates. Each gate gets its own confirmed definition during Foundation Phase.
Reports decide what every form has to capture
Marina has named this directly: reporting needs to match industry standards, grant requirements, and funder expectations. That requirement reaches all the way down into form design.
The chain
- A grant requires a specific report.
- The report needs specific data points.
- Those data points must be captured in specific fields.
- Those fields have to live on specific forms.
- Those forms have to fit Apricot's structural rules.
Skip step 1 — design forms without knowing the reports — and the system can't produce required outputs. Grants get jeopardized.
How Homework Pack #4 handles this
Pack #4 collects every report UHO needs to produce — board, funder, grant, internal, compliance. It works backwards from each report to the data needed to the fields needed to the forms needed.
By the end, every form in Apricot is designed to populate the reports UHO is actually required to file. Nothing missing, nothing wasted.
What UHO is — and isn't — committing to today
Yes — committed today
- Apricot as the platform. That decision is already made. The work ahead is using it correctly.
- A Foundation Phase to learn how to design and operate it — for Marina, Marta, and future staff.
- Migration analysis of the 150–190 existing records on the current platform. UHO doesn't yet know what moving them takes. This contract finds out.
- A working example prototype in Apricot to prove the architecture before the production build.
No — not committed today
- The production build. Contract 2 is a separate agreement, signed only after Foundation Phase closes — and only if UHO wants to continue.
- Continuation if it isn't working. Either party can stop. UHO pays only for deliverables completed.
- Unlimited scope. Every deliverable is named, priced, invoiced individually. Nothing is open-ended.
The architecture, mapped — top down
Foundation Phase designs from the data layer downward. Each layer enables the ones below it.
Two contracts, one project
Three things, in order — and Marina + Marta learn as we go
Every deliverable doubles as training. Homework teaches vocabulary. Working sessions teach decisions in plain English. The sample migration teaches what UHO's own data looks like in Apricot. The sandbox walkthrough teaches operation. By Contract 2, Marina + Marta have operated the system — by go-live, no separate training crash course is needed.
The Contract 1 prototype is example-level, not production-level. It proves "this architecture works." Contract 2 builds the full production system that handles all 4 streams and all 20 client scenarios at scale.
Five Homework Packs
Marina and Marta complete these on their own schedule. Each pack opens with a plain-English concept primer — no database background required.
UHO keeps every pack. They train current staff and future hires. They outlast this engagement.
How we work together
Two working sessions per week
Between 30 and 90 minutes each, depending on agenda. Marina + Marta + Eric. We review homework in progress, troubleshoot UHO's own operational logic, and translate decisions into Apricot architecture.
Homework on UHO's schedule
Marina and Marta complete packs between sessions, on their own time. Bring questions to the next working session.
Modest weekly load on UHO
Sessions plus homework total a manageable weekly commitment. The work fits around UHO's existing operations, not on top of them.
Everything is written
Homework packs, session notes, architectural decisions — all documented and owned by UHO. Nothing lives only in someone's head.
The 20-client framework
Twenty hypothetical clients are designed in Pack #3 to cover the operational range UHO actually sees. They become a permanent test suite — first for the prototype, then for the production system.
In Contract 1 (prototype)
All 20 scenarios are designed in Pack #3 — the journey each client takes, what UHO captures, what reports they appear in.
A subset (5–10) is walked through the sandbox as live records, proving the architecture handles the real range of cases. The remaining scenarios stay as design documentation, ready for Contract 2.
In Contract 2 (production)
All 20 scenarios run against the full production build as the operational QA suite. They confirm every stream, every workflow, every report works at production scale before go-live.
Same 20 scenarios continue as the regression test suite for any future changes UHO makes — long after this engagement closes.
Migration analysis — what fits in each contract
UHO's current records live on another platform. Contract 1 figures out exactly how to move them and proves the plan on a small batch — before committing to the full move.
About 3.5 months · 14 working weeks
Phased so that no decisions get rushed and UHO sees value in every week.
The five Homework Packs
Each pack's hours cover the full cycle — designing the pack, delivering it, reviewing Marina + Marta's submitted responses, asking follow-up questions, and translating their answers into Apricot architecture decisions. The pack is the catalyst; review and synthesis are where the architecture gets built.
Foundation support items
Foundation total (Pt 1 + Pt 2): 50 hrs · $3,500 — bundled and invoiced as the deposit on signing.
What gets delivered in Architecture
Architecture and sandbox testing happen together — not in sequence. Proposing a schema in writing, then validating it lives in Apricot before committing it to the Decision Memo, is the only way to avoid theorycrafted choices that don't survive contact with the platform. The deliverables on this slide are produced alongside hands-on sandbox experimentation.
Total: 25 hrs · $1,750. UHO ends this phase with an architecture proven in the sandbox, not just on paper.
Building the polished sandbox example
Phase 1A already validated these patterns in the sandbox. Phase 1B is the clean, complete reference example built on top of that validated ground — not a fresh start. The work here is to assemble the proven pieces into a working end-to-end demonstration UHO can walk through and Vadim can review.
Migration preparation & sample import
What gets delivered in Presentation
Contract 1 — $10,500 across two equal phases
Phase 1A — Foundation + Architecture
$5,250 · 75 hrs · Weeks 1–8 · ~9 hrs/week
- Foundation (5 homework packs + kickoff + source audit + sessions): 50 hrs · $3,500
- Architecture (options brief + decision memo + synthesis): 25 hrs · $1,750
Phase 1B — Prototype + Migration + Presentation
$5,250 · 75 hrs · Weeks 9–14 · ~12 hrs/week
- Sandbox build (Universal Intake + workflows + records): 28 hrs · $1,960
- Migration prep (field mapping + sample import + data quality): 20 hrs · $1,400
- Presentation + handoff (deck + live + Contract 2 playbook): 27 hrs · $1,890
Option to phase the commitment. If UHO would rather start with just Phase 1A ($5,250) and decide on Phase 1B at the Week 8 architecture sign-off, that's available. The two phases are designed to flow together — but they can be contracted in sequence if the funding rhythm calls for it.
$70/hr · rate context on the next slide.
Rate context
For comparable database / case-management implementation work, published US hourly rates fall in the following ranges.
| Comparable role | Typical US hourly |
|---|---|
| Database Consultant — US average | ~$54 |
| Data Architect Consultant — US average | ~$78 |
| Freelance Data Architect — worldwide average | ~$127 |
| Salesforce / CRM consultant — mid-level (3–7 yrs) | $80 – $150 |
| Salesforce / CRM consultant — senior (7+ yrs) | $150 – $250 |
| Nonprofit consulting (general) | $85 – $150 |
| Enterprise architecture / digital transformation | $120 – $300+ |
| Ta-Da Studios — UHO Contract 1 | $70 |
What this means. $70/hr sits below typical mid-level consulting rates for this category of work — significantly below freelance and senior database/architecture rates. It reflects working-relationship pricing, not a smaller scope of work. The work itself meets the same standard as higher-priced engagements.
Sources: ZipRecruiter — Database Consultant Salary (2026) · Salary.com — Data Architect Consultant · ContractRates.fyi — Data Architect · RevCodex — Salesforce Consultant Cost (2026) · Cloud Trailz — Salesforce Consulting Pricing · Paperbell — Consulting Rate Analysis · Kody Technolab — IT Consulting Rates 2026. Bonterra does not publish Apricot consulting rates publicly.
Invoicing
- Net 15 from invoice date.
- Deposit invoiced on countersignature. Covers the entire Foundation phase — all 8 deliverables across Months 1–2 (5 homework packs, kickoff + instructions, Source Platform Audit, and Foundation-weeks working sessions + PM).
- Each subsequent deliverable invoices individually when its completion trigger is met (PDF emailed, sandbox confirmed by screenshots, presentation conducted).
- Completion is the trigger — not formal sign-off. Keeps things simple, prevents stalling.
- If funding or priorities shift, we pause. Either party can request a pause at any deliverable boundary. Work resumes when both sides are ready. No penalty for either side.
- If an invoice runs 14 days past due, subsequent work pauses until it's caught up.
UHO's commitments
Small and specific. The goal isn't to overload Marina and Marta — it's to keep the work flowing.
- Apricot sandbox access within 5 business days of kickoff (or Ta-Da Studios provisions a new sandbox via Bonterra — confirmed at kickoff).
- Source platform access within 10 business days (read access sufficient to audit the existing records).
- Marina and Marta availability for two working sessions per week (30–90 minutes each), plus homework completion between sessions on UHO's own schedule.
- Decision-making clarity: Marina confirms at kickoff whether she decides during working sessions or defers to Vadim. Prevents stalls on unclear sign-off.
- One-week target on homework turnaround to keep the engagement on schedule. Delays are accommodated via the pause clause if needed.
How the engagement can end or pause
- Delays are normal. Holidays, illness, staff input awaited, other work — we keep each other informed and the timeline extends without penalty. Deliverable values are unaffected.
- Pause on funding or priority shifts. If UHO's funding situation or board priorities change mid-engagement, the work pauses at the next deliverable boundary. No penalty. Work resumes when UHO is ready.
- Either party can stop. If Ta-Da Studios or UHO decides we cannot continue, the contract terminates. UHO pays only for deliverables already completed and invoiced.
- Scope changes require a written amendment. No surprise additions. Anything beyond the named deliverables gets a signed amendment with the matching fee.
- If Apricot turns out to be wrong: the discovery work, homework packs, architecture analysis, and the system literacy Marina and Marta have built are all still yours. UHO walks away informed and capable.
If UHO chooses to continue: Contract 2
After Contract 1 closes, if UHO wants to proceed, Contract 2 carries the system to production. Final pricing lands within ±10% of this indicative once Contract 1's outputs are in hand.
Build
Production build of all four stream workflows (Client, Workforce, Training, Partner) in Apricot. Onboarding Gate enforcement for each stream. Dashboard / Control Tower built to the architecture spec from Contract 1.
Migrate
Full migration of the 150–190 records from the source platform, executed against the field mapping spec from Contract 1. Plus a source-platform deep audit that extends the C1 feasibility check.
Quality & Assurance
Post-migration quality assurance and reconciliation. All 20 client scenarios from Pack #3 run as the operational test suite against the full production build.
Train + Launch
Staff training sessions for Marina, Marta, and admins on the configured environment. Four weeks of go-live support: on-call bug fixes, quick-turnaround tweaks, real-use issue resolution.
Indicative total: ~$19,000. Total project commitment (C1 + indicative C2): ~$29,500. Signing Contract 1 does not commit UHO to Contract 2.