Client Handover Kit — five documents for handing over a project
Five client-ready documents for handing over a finished project, in one consistent style, each checked against your real code, data and running app.
Finishing the code is half the delivery. The client also needs to know what's in the database, that it works, how to use it, where their data goes, and which accounts, renewals and backups they now own. This kit writes all five, ready to send as HTML or PDF.
- DB Handover: "What's in our database?"
- Test Handover: "Is everything really done?" (with a sign-off page)
- Manual Handover: "How do my staff use it?" (real screenshots)
- Dataflow Handover: "Where does our customers' data go?"
- Handover Sheet: "What do we own, what renews when, and where are the backups?"
They tell one consistent story. In the included example (a fictional coffee shop) the same refund issue appears as defect #3 in the test report, as a note in the user manual, and as a traced flow with an action in the data flow; the 759 orders counted in the database report are the same 759 the handover sheet's restore test brought back.
Same rules in all five: nothing reported that wasn't actually checked; anything uncertain is settled with you before writing, so the client reads facts and decided actions; no passwords, secrets or real customer data; no developer jargon in the client's copy.
Works with any agent that signs in to Agensi, such as Claude, ChatGPT, Claude Code, Cursor and Codex CLI.
One payment, lifetime access. 5 skills unlock instantly in your library.
What's included
5 skillsA business-level data flow from your code: where data comes in, what happens to it, where it's stored, who sees it and where it leaves, every arrow traced to code and every gap settled with you before writing.
Turns your project's database into a plain-language handover document for the client: what each table holds, how they connect (ER diagram), what the statuses mean, where personal data lives, and the agreed actions.
Scans your project for the services it depends on, checks real certificate and domain expiry dates, settles ownership with you, and writes the operations sheet your client keeps: who owns each account, who pays, when it renews, where the backups are, and what still has to move.
Walks your running app role by role, one action per step, captures real screenshots, and writes the manual your client's staff can follow alone, without passwords, customer data or developer jargon.
Maps every agreed feature to tests that were actually run, records expected vs actual with evidence, re-verifies fixes, and ends with a sign-off page your client can accept feature by feature.
See it in action
Dataflow Handover — where your client's data actually goes
Example session with this skill installed
Make a data flow document for my client from this project: where does customer data go?
- Read your context and instructions
- Compiled the dataflow handover
Bean & Kettle back office: Data flow
Version 2026-11-09 · Source project code and database schema, 2026-11-09 · For the shop owner
Fictional example. Every solid arrow is traced to the included code; dashed arrows are steps handled outside this project, as stated by the developer.
Overview
flowchart LR
Customer([Customer])
Owner([Owner])
Staff([Staff])
Store{{Online store platform}}
Pay{{Payment provider}}
subgraph System["Bean & Kettle back office (this project)"]
BO[Back-office page]
DB[(Shop database)]
Report[Revenue calculation]
end
Customer -. "name, email, order" .-> Store
Store -. "payment" .-> Pay
Store -. "writes orders" .-> DB
Owner --> BO
Staff --> BO
Owner --> Report
DB --> Report
In one sentence: orders and payments are handled by the online store platform; this project holds the shop database and the back office, which lets staff view orders and the owner refund orders and check revenue.
Process 1: An order comes in
| # | What happens | Data | Stored in | Who |
|---|---|---|---|---|
| 1 | Customer checks out in the online store | 🔒 name, email; products, quantities | online store platform | customer |
| 2 | Payment is taken | 🔒 payment details | payment provider (never in the shop database) | payment provider |
| 3 | Store writes the order into the shop database | 🔒 name, email; order, lines | customers, orders, order_items | online store platform |
Watch out: order confirmation emails are not sent in this version; they are part of phase 2.
Process 2: Owner refunds an order
| # | What happens | Data | Stored in | Who |
|---|---|---|---|---|
| 1 | Owner opens an order and clicks Refund order | order number, total | — | owner only |
| 2 | Owner confirms; the page shows status refunded and lowers that month's revenue | order status | the open page only | owner |
| 3 | Owner returns the money in the payment provider's dashboard | amount | payment provider | owner |
Watch out (important): the refunded status is
not saved to the shop database in this version: it disappears when the page is reloaded. Saving refunds is scheduled before go-live. The back office does not contact the payment provider; the money is returned by hand in step 3.
Process 3: Owner checks monthly revenue
| # | What happens | Data | Stored in | Who |
|---|---|---|---|---|
| 1 | Revenue calculation reads paid and shipped orders, leaving out test accounts | orders, customers' test flag | read only | owner only (staff refused) |
| 2 | Owner opens Revenue in the back office | month, orders, revenue | figures built into the page | owner only |
Watch out: the revenue page shows figures written into the page itself; connecting it to the revenue calculation is scheduled before go-live.
Process 4: Signing in
Watch out (security): in this version the account list is readable by anyone who opens the page and any password is accepted. It is replaced by server sign-in before go-live.
Where personal data lives and travels
| Data | Enters at | Stored in | Leaves to | Who can see it |
|---|---|---|---|---|
| 🔒 Customer name | online store platform | customers.name | — | owner, staff |
| 🔒 Customer email | online store platform | customers.email | — | not shown in the back office |
| 🔒 Payment details | online store platform | payment provider only | payment provider | — |
| Staff/owner email | sign-in page | inside the page code | — | anyone who opens the page (until server sign-in) |
This project's own code sends nothing outside the system: no web requests, email sending or payment calls.
Recommended actions
| Current state | Action | Who | When |
|---|---|---|---|
| Refunds are shown on the page but not saved | Save the refunded status to the shop database | developer | before go-live |
| Revenue page shows figures built into the page | Connect the page to the revenue calculation | developer | before go-live |
| This version's sign-in accepts any password | Replace with server sign-in and stored, hashed passwords | developer | before go-live |
| Money is returned by hand in the payment provider | Record the provider's refund reference on the order | owner | from go-live |
| No order confirmation emails | Add confirmation emails | developer | phase 2 |
| Revenue months follow UTC time | Group revenue by the shop's local time | developer | phase 2 |
Delivered as dataflow.md plus a print-ready HTML (diagrams drawn); the developer appendix traces every step to file and function.
How to use
- 1
Connect your agent to the Agensi MCP
Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup
- 2
Sign in to Agensi
Your agent shows a sign-in link. Sign in and click Allow.
- 3
Ask for what you need
Your agent loads these skills and uses them on your task. It always asks before any payment.
Reviews
No reviews yet
Be one of the first to try it. Every skill in this bundle goes through our trust checks.
Security scanned
Checked by our 8-point scan before listing
Fresh listing
Recently published to Agensi
Money-back guarantee
Doesn't do what its page promises? You get your money back.