nihal mishra

building dfy ai systems for accounting firms

[nihal mishra @_niihhhall]

everyone makes client knowledge sound 10x more complicated than it is.

here's key-person risk for dummies:

every client has rules. the rules live in one place, and that place is a person.

one person knows which card to ignore.
one person knows the rent gets reclassed.
one person knows payroll splits by location.

when that person leaves, the rules leave with them.

that's it.

normal month-end on a client whose rules live in one head:

message from the new bookkeeper:

“the march rent is posted to office expense. is that right?”

without the person who knew, the new hire has to work through something like:

“rent sits in office expense.
that looks normal.

could it be wrong? maybe.
could it be on purpose? probably not.

nobody wrote it down.
so the safest move is to leave it.”

then:

answer: leave it

that whole process is a guess, when the only real choices are:

> reclass to rent
> leave as posted
> ask the client
> ask the person who left
> hold the close

a client record is basically:

client: “march rent, posted to office expense.”

and the standing rule is already written next to it:

> reclass to rent: the rule for this client
> ignore the second card: the rule for this client
> split payroll by location: the rule for this client

no guessing. the rule comes up with the client.

the person who knew only has to say it once.

once it is written, it stays with the firm.

think:

“which card does this client want ignored?”
ignore / keep

“does the rent get reclassed?”
yes / no

“how is payroll split?”
by location / one lump

“who approves this client's close?”
owner / controller / partner

“does this client send receipts as photos?”
yes / no

“is this the same vendor under a different name?”
yes / no

it is really good for:

> client rules
> close checklists
> who to ask
> how this client works
> the contacts and the tools
> the notes from last year
> handovers when someone leaves
> training the next hire

basically:
the ledger = holds the numbers.

the client record = holds how this client works while the numbers get made.

now build it.

start with your five hardest clients.

write down what only one person knows: the cards, the rent, the split, the quirks.

ask that person once:

“what would a new hire get wrong on this client in the first month?”

put the answer on the client's record, where the whole team can see it.

if you want the record used every month, add it to the close checklist:

“read the client's rules before posting anything. update them when the client changes how it works.”

now nobody has to ask:

“how does this client do it again?”

every month-end.

the record teaches the next hire how each client works. the checklist says when to look.

the team prepares the work. people sign off.

that's it, simple.

[nihal mishra @_niihhhall]

how to answer "where did this number come from?" in seconds, starting this week:

- take the last number a client or an auditor questioned, and trace how long it took your team to find the file, the page and the line behind it

- stop letting the answer live in an inbox, because a figure that depends on someone remembering which email it came from is not a source

- label every file by client, period, type, account and owner when it arrives, so it can be found without asking the person who saved it

- link each figure in a report to its file, its page and its line, so the proof sits beside the number it supports

- put a search over those files that finds the data first and answers only from it, so a missing source shows up as a clear "not found"

- test it with a question you know the answer to, and check that the system shows the same file you would have opened yourself

- give your staff one rule, which is to open the source before they reply, so the speed does not cost you accuracy

- make no claim about audit readiness or compliance from it, "no source, no answer", and let your people decide what a client or an auditor is told

[nihal mishra @_niihhhall]

how to keep up with tech-first firms without replacing your ledger or your team:

stop trying to copy what automated firms look like from outside.

become the firm where intake, cleaning, matching and reporting run on automation built around your current ledger and your current process, and where your people review the exceptions.

build the system and the review every single day.

1. build the foundation

start with where your firm is slower than a tech-first one. be honest about it.

not the vision. the places where someone has actually:

- waited for a client's email to start a close
- built a report from a spreadsheet
- sent a monthly pdf by hand
- chased files with the same note again
- matched statement rows to the ledger by eye
- answered a client question from memory

ask the people who do the work. learn exactly where days go, which clients get slower service, what they say about firms that answer faster, and which tools they have already tried.

then write all of it down.

for every gap record:

- where in the month it appears
- which clients feel it
- what a faster firm does instead
- what it would take to match
- what must stay the same
- who checks the result
- when a person has to decide
- what you will not change

that becomes your catch-up map.

now you need somewhere useful to start.

2. build the fit

do not start by asking for:

"a new ledger"
"a different practice platform"
"a rebuild from scratch"

nobody needs any of that. your ledger and your process stay.

build the automation around them. files in through one door, cleaned and matched, the short list of exceptions in front of your staff, and reports that start from a draft.

illustrative example, not a client:

a firm runs from email and spreadsheets. another firm in the same town closes faster and sends live numbers. clients notice, even if they don't say it, and the first one to leave rarely announces why.

the offer to yourself is not:

"we should be more like them."

the offer is:

"we keep our ledger and our team, and we add the layer that does the file work."

you don't have to become a different firm. you have to remove the work that slows the one you are.

on the planning call you ask:

- where do clients wait on us?
- which part of a close is purely file work?
- which reports start from scratch?
- what do we do by hand every month?
- who knows the client's rules?
- what happens when they leave?
- which clients compare us to others?
- what would a faster close change?
- what do we never want to automate?

map it live:

intake, clean, match, show, ask

then pick the smallest layer responsible for the largest delay.

maybe it is intake, or the month-end matching, or the live numbers.

do not end the call with "we'll keep an eye on the market."

prescribe the next micro-step:

take one client's last close, mark every step that was file work, and agree on which one the system should take first.

then you run it beside your current process and compare.

the client does not need to know what runs underneath.

they want a firm that answers fast and shows its work. the automation just happens to be the mechanism.

your job is to own:

- which clients go first
- how the system fits your ledger
- what a person approves
- how exceptions look
- what the portal shows
- how access works
- how answers cite sources
- what the system never does

the automation owns the repetition.

you own the judgment and the relationship.

this is not a bet that technology fixes a weak firm. you still own the quality, the review and the answer when something breaks.

do this across your clients and you are no longer the firm that others are quietly outrunning.

you become the firm that keeps its clients because it keeps up.

firms built on automation will keep getting faster.

the only open question is whether yours is built the same way.

[nihal mishra @_niihhhall]

@unik_47 @thebaldogarza rgtt.

[nihal mishra @_niihhhall]

@criszzzqq you got it rgt.

[nihal mishra @_niihhhall]

steal the 6-step build order for automating a accounting firm without replacing the ledger it already runs:

(read. bookmark. use it before you pick any tool.)

step 1: the door

skip the new software, the new ledger and the "digital transformation" line.

open with 1 door. every file the firm receives, from every client, enters through the same place: a portal upload, a forwarding email per client, a shared folder.

example:

"a client emails the card csv. it lands in the same place as the bank statement and the payroll register."

clients notice the firms that answer first. the door is where answering first starts.

step 2: the reader

simple input and output. a pdf table goes in. rows and fields come out, each with a confidence score.

a low score goes to a person. a high score moves on. nobody retypes a table because nobody has to.

step 3: the filter

one date format. one name per vendor. duplicates linked. periods and balances checked.

this step is why the ledger can stay as it is. the cleaning happens before the numbers reach it, which means the firm's current process keeps working.

step 4: the match

clean lines get matched against the ledger by exact, close and split rules.

what does not match becomes a short list. staff review the list instead of scanning the whole month.

step 5: the window

a dashboard for the firm. a private portal for each client, showing their company and nothing else.

the client who used to get 1 pdf a month now sees cash, profit and bills as the data arrives. a firm that sends files by email looks like every other firm. a firm with a window looks different.

step 6: the librarian

ask a question, get an answer from the firm's own documents, with the file and page shown.

no source, no answer. the system does not guess, and it does not use public chat tools that never see the firm's files.

each step works on its own, so a firm can start with the door and add the rest as it goes. nothing has to be switched off to begin.

the ledger keeps doing what it does today. the new layers feed it cleaner numbers and read from it, and your team keeps its own process.

that's it. 6 steps.

6, rather than a new platform, a new ledger and a year of migration.

everything else is a bigger project than the problem needs.

what to remove from your plan immediately:

the idea that you must replace your ledger. you do not. build around it.

the one-size product bought off the shelf. your process is yours, and the system should follow it.

the pitch about the other firms. never worry about who is faster this year. build the door.

the plan that skips the sign-off. a person approves any step that involves money or a client.

the wait for a perfect moment. start with 1 client's files and widen from there.

the fear that automation means giving up control. each step keeps a person at the checkpoint.

the meta-principle behind all of this:

technology should fit the firm rather than the firm fitting the technology.

instead of rebuilding how you work, you add layers on top of the ledger and the process you already trust. the same team then handles more, and the client sees a firm that keeps up.

the system prepares the work. people sign off.

6 steps. 6 layers. 1 firm that keeps its own way of working.

that's the build that lasts.

which of these 6 steps does your firm already run by hand?

[nihal mishra @_niihhhall]

some accounting firms look slow to their own clients, so i pulled apart how that happens.

one habit explains almost all of the gap...

and it costs nothing to copy.

the firms that keep up build automation around their current ledger before anything else happens, and the structure is the part worth stealing

the build gets split by layer and added one at a time:

→ month one the single door for files → month two the cleaning rules → month three the dashboards and answers

then whatever is the slowest step that quarter.
the logic underneath is the bit almost nobody gets.

every part of a manual process falls behind independently.

a firm never gets slow all at once. intake by email drags first, then the close takes longer than it used to, then reports go out later than the client expects.

review the whole firm once a year and you catch none of it until a client asks why it takes so long.

by then they have already noticed.

split what to automate from what to keep, hard

the ledger and the sign-off carry the weight. the repeated steps around them move into a system built for this firm.

here is the trap sitting inside every tool purchase:

→ the firm buys a one-size product → the process bends to fit it → the team stops using it

the fix is a system built around your own ledger and process, with a person approving each step.

fix speed in the process instead of in the ledger
keep what already works. add layers on top of it, and leave the ledger as the record.
better for staff, better for clients.

none of the three is a secret.

all three are a build added in layers instead of a replacement, which is why you have read this and will still run month-end from email.

[nihal mishra @_niihhhall]

@unik_47 fr.

[nihal mishra @_niihhhall]

@coldemailchris copy

[nihal mishra @_niihhhall]

this week i mapped a full data-safety system for accounting firms whose staff already use public chat tools

from the paste to the answer to the source, all inside the firm's own walls.

and now client data stays inside the firm:

every:

statement pasted

client email pasted

p&l pasted

payroll report pasted

answer with no source

quiet leak

here's exactly what sits inside:

→ the reason people paste

(staff want a fast answer, and the public tool is the fastest thing in reach. most professionals use such tools at work. blame helps nobody, and a ban without an alternative just moves the paste out of sight)

→ the role based access

(each role sees only what it needs, and a client sees only their own company, so a question from one person cannot surface another's data, and nobody sees more than the job requires)

→ the firm's own library

(every statement, invoice and report is stored and labeled where the firm controls it)

→ the grounded answer

(replies come only from the firm's documents, so the answer has a file behind it and the team is not left to trust a confident paragraph)

→ the source line

(every answer shows its file, page and row. no source, no answer)

→ the honest gap

(when the data is not there, the system says so rather than guessing)

→ the review checkpoint

(a person approves anything that goes to a client, so the system supports the firm's judgment and never replaces it, and nothing leaves without a name behind it)

→ the open question

(security and compliance details are confirmed per firm before anything is built. nothing here is a promise of either)

same system built from:

the questions staff already ask

the files the firm already holds

the access the firm already grants

what do your staff paste into a public tool today?

[nihal mishra @_niihhhall]

how to stop chasing clients for documents without sending another email by hand

most accounting firms chase the same clients for the same documents every month, and the chase lives in a spreadsheet or in someone's head

the statement is due on the 3rd, it is the 8th, and a staff member writes the same polite email they wrote last month. the client replies "will send today" and then doesn't

a reminder schedule is a list of what each client owes, by which date, with a message that goes out on its own at set points and stops when the file arrives. the firm approves the message. the system sends it and tracks it

here's how to set that up:

1. write down what each client owes

start with one client and list what the month needs from them:

> bank statements, all pages
> card statements or card exports
> payroll reports
> receipts for the period
> any note from the owner about unusual items

add a due date for each. these become the rows of a client checklist, and every arrival is checked against it

keep the list per client, not per firm. a client with two cards owes two statements, and a client with no payroll owes none

2. give clients one place to send

a reminder that says "reply with the file" gets a reply with half the file. a reminder with an upload link gets the whole thing in one place

each link ties the upload to the client and the period, so nobody has to figure out whose file it is

let the old routes work during the first month, then watch which clients still use email and ask them once to switch

3. write the message once

draft three messages: a first notice before the due date, a nudge after it, and a final note that names exactly what is still missing

a good reminder:

> says which file, by name
> says which period it covers
> includes the upload link
> is short enough to read on a phone
> sounds like the firm, not a system

the firm approves the template. nothing goes out that a person has not signed off on

read each message as the client would, on a phone, between two meetings. if it takes more than ten seconds to understand what is being asked, shorten it again

keep one template per document type, so a missing payroll report and a missing card statement each get a message that fits

4. set the schedule from the checklist

tie each message to a point in the month: three days before the due date, the day after, a week after

the schedule reads the checklist. a client who already sent everything never gets a reminder, and a client who sent two of three gets a message that names the third

that last part matters. "please send your documents" is a reminder clients ignore. "page 4 of the checking statement is missing" is one they answer

5. stop the reminders when the file arrives

the quickest way to annoy a client is to remind them about something they sent yesterday

the checklist updates when a file lands, and the schedule stops for that row. if the file arrives and turns out to be incomplete, the checklist reopens the row and names what is wrong

6. send the hard cases to a person

some clients won't respond to a schedule. after the final note, flag the client for a person to call

> the same file missing for a third month in a row
> a client who answers but never sends
> a file that arrives unreadable twice
> a request that involves money or a decision

the system prepares the list. a person decides who gets a call and what to say

7. review what the schedule shows

at the end of the month, look at which clients needed the most reminders and which documents were late most often

that tells you where to change the checklist, the due dates or the way you ask. a client who is always late on one document may need a different due date, not a stricter message

keep the notes about each client in their record, so a new team member can see how that client usually behaves

if a client always sends on the 12th no matter what you write, move their due date to the 10th and stop treating them as late

the schedule should fit the client, not the other way round. a month-end that works for a firm with forty clients is built on forty small agreements, not one rule

the reminders still go to the same clients each month. the difference is that nobody writes them, tracks them or forgets them, and staff time goes to the calls that need a person

[nihal mishra @_niihhhall]

@KevinSeney_com exactly. the real test is whether someone else can close the books using that checklist without calling the person who wrote it.

[nihal mishra @_niihhhall]

this will make your best bookkeeper a little nervous:

every firm has one person who knows how each client really works. reclass the rent. ignore the second card. split payroll by location. none of it is written down anywhere, and all of it walks out the door on the day that person resigns.

the fix is a client record, a single place where the rules live with the firm and not in one head.

here is what goes in it: the entities, the contacts, the tools, the close checklist, the documents and a plain list called "how this client works."

this is basically an insurance policy against a resignation, if you know how to fill it in.

heres exactly how:

1. start with the clients that would hurt most

dont try to document every client. pick the ones where:

- a mistake would cost you the client
- the rules are unusual or the books are messy
- only one person has ever touched the file
- the work repeats every month
- someone else could realistically take it over

important: this list is a starting point. ask your team which clients they would hate to hand over, because the answer is usually different from the revenue ranking.

2. list what only one person knows

for each client, ask the person who does the work to finish these sentences:

- "every month i have to remember to..."
- "never touch..."
- "this vendor is really..."
- "the owner always sends..."
- "if this is missing, i..."

dont ask them to write a manual. ask for the sentences they say to themselves while they work.

3. write each rule as one line

turn the answers into short rules a stranger could follow:

- reclass the monthly rent from office supplies to rent
- ignore the second card, it is the owner's personal spending
- split payroll across the two locations by headcount
- the owner's notes arrive on page 2 of a word file

a rule that needs a paragraph is really two rules. split it until each line can be checked on its own.

keep the wording in the person's own voice where you can. a rule they recognize is a rule they will keep up to date.

4. send this message to the person who holds the knowledge

subject: {{clientName}}, three minutes?

"{{firstName}}, you know how {{clientName}} works better than anyone here. i would like to put the rules you follow into the client record so they stay with the firm.

can you read the list i drafted and fix whatever i got wrong? i will not ask you to write anything from scratch."

thats it.

you are asking them to correct a draft, not to give up their expertise. a correction takes three minutes. a blank page never gets filled.

the part most firms get wrong comes after they say yes.

5. make the record useful the same day

show them where the rules appear. when a file for that client arrives, the record applies the rules and a person checks the result.

a rule that only sits in a document is a rule nobody reads. a rule that is applied to the next month's files gets tested immediately.

6. test it on the next close

run the next month for that client with the record. compare what the system did with what the person would have done.

look closely at every difference:

- a rule that was too vague
- a rule that had an exception nobody mentioned
- a rule that changed since it was written
- a rule the person forgot to say

fix the record each time. a record that is checked once a month stays alive.

7. ask the person, then ask someone else

have a second team member use the record to do a small piece of the client's work.

"hey {{firstName}}, you followed the record for {{clientName}} last month. did anything feel unclear or missing?"

now the knowledge is no longer a secret. a second person has used it, and you know where it breaks.

8. attach the rest of the client's history

put the entities, contacts, tools, the close checklist, document requests and a timeline of what happened in the record, next to the rules.

- who signs
- which ledger the client uses
- which files arrive late
- which questions the owner asks every month
- what was decided and why

a handover now starts with a record, not a conversation in a hallway.

9. keep a person at the checkpoint

the record prepares the work. people review it, decide and sign off.

the system does not approve anything, file anything or send money. it makes sure the person doing the review starts from the same rules the last person used.

this is where the key-person risk shrinks, if the rules are accurate and the team keeps them current.

10. review it every quarter

every quarter, look at each record again:

- rules added
- rules removed
- clients that changed how they work
- records nobody has opened

after a while you dont have a folder of notes. you have a living record of how every client works, who touched it and what changed.

the client already taught your team how they work. your job is to make sure the firm keeps what it learned.

hell of a lot easier to hand over than "ask her, she knows."

[nihal mishra @_niihhhall]

@unik_47 grt one.

[nihal mishra @_niihhhall]

@Isaac_Dev0 fr.

[nihal mishra @_niihhhall]

accounting firms built on automation are not waiting for anyone to catch up:

they close faster, report better and answer questions sooner. firms still run from email and spreadsheets feel that gap each month, and clients notice it before the firm does.

the fix is not to copy anyone. it is to build the same kind of automation around your own ledger and your own process.

this is basically a gap audit, if you know how to read it.

heres exactly how:

1. describe your month-end honestly

write down what happens from the first file to the last review:

- where files arrive
- who opens them
- what gets retyped
- how missing items are found
- how clients get their numbers

dont clean it up. the messy version is the useful one.

ask the people who do the work to read it. they will tell you what you left out, and it is usually the step that costs the most time.

write how long each stage takes in your own words, even if it is a guess. you will replace the guesses with your own measurements later.

2. mark every step a person repeats

draw a line under each step that is the same every month: downloading, renaming, retyping, fixing dates, comparing rows, chasing files.

those are the steps a system can take on.

most firms are surprised by how long this list is. the time goes in small steps that nobody counts: a rename here, a date fix there, a table retyped from a pdf.

count them by hand for one client. the number is usually bigger than anyone guessed.

3. mark every step that needs judgment

reclass decisions. unusual items. client conversations. sign-off.

these stay with people. the aim is to give them more time, not less authority.

4. look at what clients can see

how does a client learn where their books stand? a pdf by email once a month, or a page they can open any day?

this is the gap clients feel first. firms with portals and live numbers look different.

nothing in this step is about attacking anyone. it is about seeing your own firm the way a client does when they compare notes with a friend.

ask two or three clients what they wish they could see sooner. their answers are cheaper than any survey.

5. list what you would build

for the repeated steps, one system that does them:

- one door for files
- a reader that turns files into rows
- cleaning and checks
- matching to the ledger
- a short list of exceptions
- a view for the firm and a page for each client

6. start with one client

dont rebuild the firm. pick one client and one month.

run it side by side with your current process and compare the exception list with what your team found by hand.

look at what the system caught that the team missed, and what the team caught that the system missed. both lists teach you something.

keep the pilot small enough that one person can review every line.

7. send this note to the client

subject: {{clientName}} {{month}} pilot

"{{firstName}}, we are testing a faster way to prepare your month-end, with a private page that shows your numbers as they arrive.

can we use your next month as the pilot?"

thats it.

you are asking one client to test something that makes their own month better. nobody gets promised a result.

the part most firms skip comes after the pilot.

8. measure what you actually see

how many files? how long did the exceptions take? what did the team still do by hand? what did the client say?

no measured hours exist until you measure them. write down your own numbers.

use the same clock for the old process and the new one. a comparison that changes the rules halfway is not a comparison.

share the result with your team first. they will tell you which parts they trust and which parts they are still checking twice.

9. keep people at every checkpoint

the system prepares. people review, decide and sign off.

it does not replace your ledger, your judgment or your review. it removes the repeated work around them.

write down who approves each checkpoint. a system that prepares work nobody owns is a new way to lose track of it.

10. build around what you have

the same automation can sit around the ledger and process the firm already uses. you dont have to move everyone to a new tool.

if the first pilot goes well, add the next client and keep the same side-by-side check for a few months. trust comes from comparing results, not from a demo.

after a while you dont have a firm that is catching up. you have a firm whose month-end runs on a system built for it.

a gap you can see is a gap you can close. one client, one month and one honest comparison is enough to start.

the firms that moved first already showed clients what faster looks like. your job is to build yours around your own books.

hell of a lot easier to start now than to explain later why you didn't.

[nihal mishra @_niihhhall]

is there a workflow i don't see slowing down this year?

running many companies' numbers in one view

a fractional cfo works across companies that each have their own files and habits.

every board report starts from scratch because the data sits in different places and formats.

clean data from every company in one view means each report starts from a draft, and the cfo reviews it.

here is a short guide on how to set this up.

you'll get

how to give every company the same door for its files
how to clean each company's data into the same shape
how to keep each company's rules in its own separate record

what a one-view dashboard should show first

how to draft a board report from the data, with sources

how to review each draft before it goes out.

there's also a simple way to start two companies, one report, and a review before it goes out.

which report would you rebuild from a draft first?

[nihal mishra @_niihhhall]

if you run a small accounting firm, the first thing you should hand to a system is the file work, not the fancy stuff...

month-end goes to downloading, renaming & retyping, and it's the most fixable leak in any firm

the goal is simple, no client starts the close from 70 raw files

all you need is one upload door, a list of what each client owes & one system that can read the files and the ledger

> one door for every file. a client upload page or a forwarding email with the client, period & source attached. every statement, csv & receipt photo goes there, nowhere else

> a client checklist. what you expect on day 1, day 5 & day 8 of the close, and who chases what. add two real months of files so it copies what yours look like

> a morning check. the system reads the new files, fixes dates & vendor names, matches the lines to the ledger & lists what is left over

> a human sign-off. the system only prepares, you read the exception list & approve. a wrong balance costs you more than a slow close

> a friday look back. which clients send late, which files cause the most exceptions. change the checklist based on that, not gut feel

two more once that runs

> every receipt photo becomes a row with a date & a vendor, and the unsure ones get flagged
> every vendor spelled three ways becomes one name, with the old spellings kept

don't build all of it at once

the door & the exception list alone beat what most firms do today