Receipt accounting

Receipt Accounting

What it is: Money received, allocated to the right account, and reconciled to cash or bank.

Overview

Works out the smallest useful Receipt Accounting setup for the business in front of it, then builds it only when asked. The default output is a short recommendation, not a spreadsheet. Artifacts - CSV, SQL DDL, JSON Schema, Notion mapping - are produced on request, from one field list so they cannot drift apart.

Layer: Layer 3: Record. Fits: Starter stage. Table code: n/a.

The rule this table exists to enforce: a receipt is not sales income. Money can arrive as collection of an existing receivable, as an advance from a customer, as a loan received, or as capital contribution. Each of those lands in a different ledger, and only one of them is income. This is why Receipt Type and Treats as Sale Income are fields and not conventions, and why Amount Allocated and Unapplied Amount are both captured - the difference between the gross received and the part that clears an invoice stays visible instead of quietly inflating revenue.

When to Use This Skill

• receipt register
• receipt voucher book
• money received log
• collections tracker
• bank receipt reconciliation sheet

Also use it when the user says "money received, allocated to the right account, and reconciled to cash or bank", or describes the same process happening in a spreadsheet, a document or someone inboxes.

Do not use it for: raising sales invoices, making payments, tax filing, or legal advice. This skill produces empty templates only - it never holds or processes real employee or customer data.

How It Works

Follow the shared execution contract. The module-specific rules below define only domain fields, decisions, calculations, and safety constraints.

Step 1 - Identify intent

Read the request and pick the intent before asking anything.

• "set up" or "build" or "create" -> the user wants artifacts; go to Step 2.
• "our process is ..." or "it is in a sheet" -> the user wants to move an existing process; capture it, then Step 2.
• "is this right" or "review" or "audit" -> the user wants a check, not a build; answer from what they share.
• "how do I ..." -> advice question; answer directly and offer the build only if it helps.

Ask only if this is the highest-value missing fact; otherwise proceed without an opener:

Q: How do you record money received today?

Step 2 - Ask only what is missing

Treat ambiguous replies as unanswered and ask which explicit option the user means. Record unknown values as Unknown; Unknown is not zero. A record must not be Done when a required check fails.

Skip anything the user already answered, in any earlier message. Ask the rest one at a time, and stop as soon as the remaining answers would not change the output.

• Receipts - How many in a month? / Cash, bank, cheque or digital? / Any part-payments?
• Allocation - Allocated to invoices? / Advances or loans mixed in? / Who allocates it?
• Evidence - Receipt voucher or bank advice? / Issued to the customer? / Filed where?
• Reconciliation - Bank reconciled how often? / Cash counted? / Differences handled how?
• Outcome - What do you need? / A receipts register, a reconciliation view or both?

Never invent an answer. If the user does not know, record it as unknown and carry on.

Step 3 - Hold the internal context

Hold the answers in this shape. It stays internal - it is not shown to the user unless they ask, and it never carries a value the user did not give.

module: receipt-accounting
intent: null            # setup | advice | review | fix | build | convert | export
scale: null             # Starter | Growth | Scale, only if the answer changes it
areas:
  "Receipts": null
  "Allocation": null
  "Evidence": null
  "Reconciliation": null
  "Outcome": null
requested_outputs: []   # csv | sql | json | notion | xlsx - requested formats only
confirmed_facts: []     # only what the user actually said
open_questions: []      # the unanswered ones, in the order worth asking

Step 4 - Recommend the smallest workflow

Build an already requested artifact without asking again. For advice-only requests, give a short recommendation and offer the relevant artifact.

Recommended approach: One receipt record carrying the mode, the gross received, the receipt type, the invoice it clears and the unapplied balance, and post it to income only when the type says it is a sale.

Why this one: The trap on this table is that money in gets treated as revenue out. Forcing the type and the allocation before the entry closes is what keeps an advance or a loan out of the sales book.

Workflow: Money received → Mode and source recorded → Typed as collection, advance, loan or capital → Allocated to an invoice or held unapplied → Reconciled to bank or cash

Step 5 - Build only on request

Once the user asks for it, derive the fields from the confirmed context and emit the requested artifacts. For machine-readable text, keep prose outside the data; for files, provide a usable link. Report material validation failures or limitations separately.

A selected Notion output is rendered by notion-manual-import, so route the Notion step there. When the user selects Notion, hand that step to @notion-manual-import: it holds the CSV, the property mapping, the import steps and the verification checklist, and it renders the Field Reference below instead of defining a table of its own. Do not restate the mapping here and do not improvise the import steps. Manual CSV and mapping outputs need no connection. For requested workspace changes, follow the shared contract: verify actual tool access and the target before writing. A user saying "connected" is not tool evidence. Never ask for a Notion password or token.

Receipt Number,Receipt Date,Received From,Receipt Mode,Cash/Bank Account,Reference (Cheque/UTR/ID),Gross Amount Received,Receipt Type,Treats as Sale Income,Sales Invoice Allocated,Amount Allocated,Unapplied Amount,Adjust Against,TDS Collected on Receipt,Voucher Number,Ledger Account,Source Document,Reconciliation Status,Prepared By,Verified By,Entry Verified,Notes,Receipt ID
RCP-2026-0312,2026-08-19,Greyson Foods,Bank,HDFC Current ****0042,UTR-2026-0819,140000.00,Receivable Collection,No,SAL-2026-0033,130712.40,9287.60,Customer Advance - Greyson Foods,1307.12,VCH-2026-1027,Bank - HDFC Current,DOC-2026-0461,Unreconciled,Ananya Rao,Sneha Iyer,In progress,"Part collected against INV-2026-0733; TDS of 1307.12 remitted from this receipt; balance held as advance, not income.",

CREATE TABLE receipt_accounting (
  receipt_number VARCHAR(255),
  receipt_date DATE NOT NULL,
  received_from VARCHAR(255),
  receipt_mode VARCHAR(100) NOT NULL,
  cash_bank_account VARCHAR(255),
  reference_cheque_utr_id VARCHAR(255),
  gross_amount_received NUMERIC(14,2) NOT NULL,
  receipt_type VARCHAR(100) NOT NULL,
  treats_as_sale_income VARCHAR(100) NOT NULL,
  sales_invoice_allocated VARCHAR(255),  -- relation -> target record
  amount_allocated NUMERIC(14,2) NOT NULL,
  unapplied_amount NUMERIC(14,2) NOT NULL,
  adjust_against VARCHAR(255),
  tds_collected_on_receipt NUMERIC(14,2) NOT NULL,
  voucher_number VARCHAR(255),
  ledger_account VARCHAR(255),
  source_document VARCHAR(255),  -- relation -> target record
  reconciliation_status VARCHAR(100) NOT NULL,
  prepared_by VARCHAR(255),
  verified_by VARCHAR(255),
  entry_verified VARCHAR(100) NOT NULL,
  notes TEXT,
  receipt_id SERIAL PRIMARY KEY,
  created_at TIMESTAMP DEFAULT NOW(),
  updated_at TIMESTAMP DEFAULT NOW()
);

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "title": "Receipt Accounting",
  "type": "object",
  "additionalProperties": false,
  "properties": {
      "Receipt Number": { "type": "string" },
      "Receipt Date": { "type": "string", "format": "date" },
      "Received From": { "type": "string" },
      "Receipt Mode": { "type": "string" },
      "Cash/Bank Account": { "type": "string" },
      "Reference (Cheque/UTR/ID)": { "type": "string" },
      "Gross Amount Received": { "type": "number" },
      "Receipt Type": { "type": "string" },
      "Treats as Sale Income": { "type": "string" },
      "Sales Invoice Allocated": { "type": "string" },
      "Amount Allocated": { "type": "number" },
      "Unapplied Amount": { "type": "number" },
      "Adjust Against": { "type": "string" },
      "TDS Collected on Receipt": { "type": "number" },
      "Voucher Number": { "type": "string" },
      "Ledger Account": { "type": "string" },
      "Source Document": { "type": "string" },
      "Reconciliation Status": { "type": "string" },
      "Prepared By": { "type": "string" },
      "Verified By": { "type": "string" },
      "Entry Verified": { "type": "string" },
      "Notes": { "type": "string" },
      "Receipt ID": { "type": "integer" }
  },
  "required": [
      "Receipt Date",
      "Receipt Mode",
      "Gross Amount Received",
      "Receipt Type",
      "Treats as Sale Income",
      "Amount Allocated",
      "Unapplied Amount",
      "TDS Collected on Receipt",
      "Reconciliation Status",
      "Entry Verified"
  ]
}

| CSV column | Notion property | Set after import |
|---|---|---|
| Receipt Number | Title | Use as the database title |
| Receipt Date | Date | Convert to Date |
| Received From | Text | Leave as Text |
| Receipt Mode | Select (add options after import) | Convert to Select, add options: "Cash", "Bank", "Cheque", "Fonepay/QR", "Other Digital Payment" |
| Cash/Bank Account | Text | Leave as Text |
| Reference (Cheque/UTR/ID) | Text | Leave as Text |
| Gross Amount Received | Number (format: currency) | Convert to Number, set format to Currency |
| Receipt Type | Select (add options after import) | Convert to Select, add options: "Sale Collection", "Receivable Collection", "Advance from Customer", "Loan Received", "Capital Contribution", "Other" |
| Treats as Sale Income | Select (add options after import) | Convert to Select, add options: "Yes", "No" |
| Sales Invoice Allocated | Relation (link to the target database) | Convert to Relation, link to the target database |
| Amount Allocated | Number (format: currency) | Convert to Number, set format to Currency |
| Unapplied Amount | Number (format: currency) | Convert to Number, set format to Currency |
| Adjust Against | Text | Leave as Text |
| TDS Collected on Receipt | Number (format: currency) | Convert to Number, set format to Currency |
| Voucher Number | Text | Leave as Text |
| Ledger Account | Text | Leave as Text |
| Source Document | Relation (link to the target database) | Convert to Relation, link to the target database |
| Reconciliation Status | Select (add options after import) | Convert to Select, add options: "Unreconciled", "Reconciled", "Difference" |
| Prepared By | Text | Leave as Text |
| Verified By | Text | Leave as Text |
| Entry Verified | Select (add options after import) | Convert to Select, add options: "Not started", "In progress", "Blocked", "Done", "Cancelled" |
| Notes | Text | Leave as Text |
| Receipt ID | Text (preserve source ID) | Keep imported IDs as Text; optionally add a separate Unique ID property |

The rows above are documentation examples only. Emit empty templates unless the user explicitly requests examples. Money stays currency, dates stay date, and anything pointing at another table stays relation.

Field Reference

#	Field	Type	SQL	JSON Schema	Notion	CSV example
1	Receipt Number	text	VARCHAR(255)	string	Text	RCP-2026-0312
2	Receipt Date	date	DATE	string, format: date	Date	2026-08-19
3	Received From	text	VARCHAR(255)	string	Text	Greyson Foods
4	Receipt Mode	select	VARCHAR(100)	string	Select (add options after import)	Bank
5	Cash/Bank Account	text	VARCHAR(255)	string	Text	HDFC Current ****0042
6	Reference (Cheque/UTR/ID)	text	VARCHAR(255)	string	Text	UTR-2026-0819
7	Gross Amount Received	currency	NUMERIC(14,2)	number	Number (format: currency)	140000.00
8	Receipt Type	select	VARCHAR(100)	string	Select (add options after import)	Receivable Collection
9	Treats as Sale Income	select	VARCHAR(100)	string	Select (add options after import)	No
10	Sales Invoice Allocated	relation	VARCHAR(255)	string	Relation (link to the target database)	SAL-2026-0033
11	Amount Allocated	currency	NUMERIC(14,2)	number	Number (format: currency)	130712.40
12	Unapplied Amount	currency	NUMERIC(14,2)	number	Number (format: currency)	9287.60
13	Adjust Against	text	VARCHAR(255)	string	Text	Customer Advance - Greyson Foods
14	TDS Collected on Receipt	currency	NUMERIC(14,2)	number	Number (format: currency)	1307.12
15	Voucher Number	text	VARCHAR(255)	string	Text	VCH-2026-1027
16	Ledger Account	text	VARCHAR(255)	string	Text	Bank - HDFC Current
17	Source Document	relation	VARCHAR(255)	string	Relation (link to the target database)	DOC-2026-0461
18	Reconciliation Status	select	VARCHAR(100)	string	Select (add options after import)	Unreconciled
19	Prepared By	text	VARCHAR(255)	string	Text	Ananya Rao
20	Verified By	text	VARCHAR(255)	string	Text	Sneha Iyer
21	Entry Verified	select	VARCHAR(100)	string	Select (add options after import)	In progress
22	Notes	long_text	TEXT	string	Text	Part collected against INV-2026-0733; TDS of 1307.12 remitted from this receipt; balance held as advance, not income.
23	Receipt ID	id	SERIAL PRIMARY KEY	integer	Text (preserve source ID)	(blank)

Select Options

Receipt Mode

Cash | Bank | Cheque | Fonepay/QR | Other Digital Payment

Receipt Type

Sale Collection | Receivable Collection | Advance from Customer | Loan Received | Capital Contribution | Other

Treats as Sale Income

Yes | No

Reconciliation Status

Unreconciled | Reconciled | Difference

Entry Verified

Not started | In progress | Blocked | Done | Cancelled

Relations

Link fields: Sales Invoice Allocated, Source Document

Sales Invoice Allocated points at the sales book, so the receipt and the invoice it clears can be read side by side. Source Document points at the filing register, so the bank advice or receipt voucher is one lookup away. Neither link substitutes for Receipt Type - a receipt can be fully allocated and still be an advance.

Examples

Prompt

Money comes in and we post all of it as sales. At month end the numbers never agree
with the bank.

Context first - one question per message, nothing already answered:

Q: How many receipts in a month?

A: About forty.

Q: Cash, bank, digital?

A: Mostly bank. Some Fonepay.

Q: Do you allocate receipts to invoices?

A: Sometimes. The rest we just leave.

Recommended next step - offered, not built:

One receipt record carrying the mode, the gross received, the receipt type, the invoice it clears and the unapplied balance, and post it to income only when the type says it is a sale.

Workflow: Money received → Mode and source recorded → Typed as collection, advance, loan or capital → Allocated to an invoice or held unapplied → Reconciled to bank or cash

Want the CSV, SQL, JSON Schema and Notion mapping for this?

Best Practices

• Build when requested; recommend and offer a build for advice-only requests.
• One question per message. A batched intake reads as a form and gets guessed at.
• Never let a receipt become income on the strength of money arriving. Set Receipt Type

first, then Treats as Sale Income, then allocate.

• Keep the arithmetic visible: gross received = amount allocated + unapplied amount, every

row. A row that will not balance means the allocation is still open.

• TDS Collected on Receipt is a slice of the money received, not an addition to it. It is

the part of the allocation that is remitted to the government, so gross received still equals amount allocated plus unapplied amount.

• An unapplied amount is a live question, not a rounding item. Carry it forward until it is

identified as an advance, a loan, capital or an error.

• Record the mode on every receipt. Cash, bank, cheque and digital reconcile through

different routes and a mixed-up mode is the most common source of differences.

• Record Cash/Bank Account masked - the bank and the last four digits is all a register

needs, and the full number is what turns a register into a target.

• Keep display names identical across CSV and JSON; document normalized SQL identifiers.
• Use relation for anything that points at another table, text only for free text.
• Money fields are currency, never text. Dates are date, never free text.
• If the user requests an example row, keep it obviously fake so nobody imports it as real data.

Limitations

• Empty template only. It does not post entries, raise invoices or compute tax.
• The type fields do not decide the accounting treatment for you. The ledger, the tax

position and the period all matter, and a qualified accountant confirms that.

• Unapplied amounts need a follow-up process. This table records them; it does not chase

them.

• Notion relations need both databases imported before the link column resolves.
• Select options are a starting set. Rename them to match how the business talks.
• No automation, reminders or sync. Those need the integration layer.
• Does not connect to a bank feed or move money.
• Legal, tax and HR review is still required before this drives real decisions.

Security & Safety Notes

• Never fill in real names, bank details or customer financials. Placeholders only.
• Label example rows as synthetic, and keep bank details masked.
• A receipt register is a target for fraud and for someone asking for a copy of a

customer's bank reference. Do not paste live UTR or cheque images into a chat.

• Local reads, generation commands, and validation are part of a requested artifact build.

External writes, messages, provisioning, and publication require authorization for that action and target; existing explicit authorization does not need to be repeated.

• If sensitive data is supplied, avoid repeating unnecessary identifiers. Use only what

the requested review needs; keep generated templates empty. Do not claim deletion from the conversation or service storage.

• Privacy, legal and disciplinary cases need a qualified human reviewer before anything

is acted on.

Common Pitfalls

• Problem: a static mapping is described as a completed workspace build.

Solution: deliver manual mappings without a connection; claim a live change only after the authorized tool operation succeeds.

• Problem: asked all six questions in one message.

Solution: ask one, wait, and drop any the first answer already covered.

• Problem: every receipt posted as sales because the money arrived.

Solution: Receipt Type and Treats as Sale Income are fields, not assumptions. Fill them before the entry, not at month end.

• Problem: the unapplied balance is quietly dropped so the row balances.

Solution: hold it in Unapplied Amount and carry it forward until it is identified.

• Problem: the mode is left blank, so cash and bank never reconcile separately.

Solution: Receipt Mode is required; a receipt with no mode cannot be reconciled.

• Problem: all four artifacts drift apart.

Solution: derive all four from the field list in this file, never by hand.

• Problem: Notion import shows every column as Text.

Solution: that is expected. Apply the property mapping table once, after import.

Related Skills

• @accounting-audit-system-builder - routes to this skill and the other 15 modules.
• @sales-accounting - the invoice side of Sales Invoice Allocated.
• @payment-accounting - the other half of the cash and bank movement.
• @source-document-filing - holds the Source Document target.
• @party-ledger-reconciliation - proves the debtor balance after allocation.
• @day-book - the daily book these receipts land in.
• @tds-booking-payment - carries TDS Collected on Receipt through to the return.
• @petty-cash-management - the same receipt-versus-income question in cash.
• @monthly-closing-statements - where the unapplied balance either clears or gets written off.
• @credit-cycle-analysis - uses the unallocated balance to age the debtors.
• @audit-preparation - the receipt register is an audit-trail item.
• @expense-accounting - the receipt side that is not income at all.

Reusable Prompt

I want to set up receipt accounting - every rupee received, its mode, its type, its
allocation against an invoice and its reconciliation to cash or bank - for my company.
Ask me one short question at a time, and only about what I have not already told you.
Then recommend the smallest setup that fits, and wait for me to ask before you build it.
When I ask, output CSV, SQL DDL, JSON Schema and a Notion property mapping. Data only.