Most early-stage companies don't really have an expense process. They have an arrangement.
Someone pays from a card, pings the invoice on Slack and someone else packages everything for the accountant before the month ends. If the company card works, great. If not, someone uses their personal card and deals with the reimbursement later. A vendor sends an invoice over WhatsApp. A contractor gets paid directly from a founder's account because that was what was available that day.
This works fine when there are three people and four vendors. Then you hire a contractor. Someone books travel. A vendor sends the wrong tax ID. A founder pays rent from the wrong account because the company card hit its limit.
None of these feel like real problems. That's exactly why they keep happening. By the time someone sits down to actually understand where the money went, they're not just doing accounting. They're doing archaeology.
The work is not hard, but the details are everywhere
Nothing about expense management is technically difficult. Checking whether an invoice has the right GST number is straightforward. Figuring out which card a payment came from is straightforward. Asking a vendor for their PAN before the first payment is straightforward.
The problem is that all of it lives in different places at once. The invoice is in Gmail. The payment is in the bank statement. The vendor's tax details are in an email thread from six weeks ago. The note about what a payment was for exists only in someone's memory, or a Slack message that nobody thought to save.
If you're registered for GST, every business purchase is also a tax event. You may be able to claim Input Tax Credit on it, but only if the invoice has all the right details. Miss one field and the expense is still real, but you cannot use it cleanly in your filings.
TDS is similar. Before paying certain vendors, you need their PAN, a call on whether to deduct at source and a certificate issued afterwards. Each step has to happen in order, and none of it can be fixed once the payment is done.
None of this makes it onto the roadmap or the weekly sync. So it quietly accumulates until someone has to deal with all of it at once.
Payroll brings its own details
Payroll looks like one number until you actually have to process it every month. A salary is base pay, allowances, deductions, employer contributions, tax withheld, reimbursements and leave adjustments. All of that has to be right before a payslip goes out.
The dependencies aren't complicated, but they're everywhere. Each one depends on something collected earlier. A tax ID from onboarding, a declaration submitted in time, leave tracked in the right place. When something slips, reconstructing the month means going back through the spreadsheet, the bank statement and several messages, usually when an employee urgently needs the payslip for something else.
The accountant is not the bottleneck
It's tempting to think this is just something the accountant should handle. In practice, they can only work with what you give them.
If a payment has no note, they have to ask what it was for. If an invoice landed in someone's personal inbox, they have to wait for it. If a reimbursement has no document, they have to decide whether to chase it or classify it imperfectly. At some point, the back and forth becomes the actual process.
The real cost isn't accounting errors. It's the founder remembering why a payment happened, the vendor reissuing a bill and everyone trying to agree on what a transaction from three months ago actually was. That's invisible when things are going well. It becomes very visible at month-end, quarter-end or during due diligence.
You are probably not doing it wrong
I've talked to a lot of founders who assume they are uniquely bad at this. Scattered invoices, missing PANs, unclear vendor advances, personal and company expenses mixed together. They assume it reflects something broken about how they're running the company.
It usually doesn't.
This is what happens when the tools don't match the shape of the work. Enterprise systems assume a finance team already exists. Generic expense tools treat every expense as a receipt and an amount. Accounting software assumes someone has already cleaned and categorized the data before it arrives.
In a small company, the person paying, the person approving, the person collecting documents and the person explaining the transaction to the accountant might all be different people. Or the same founder on different days.
That's why the mess feels personal even when it is structural.
Why We're Building Jupikit
We ran into all of this ourselves.
At first, we also thought the answer was to be more disciplined. Keep a better spreadsheet. Create a folder structure. Ask everyone to upload invoices properly. Remind people to add notes. Send cleaner data to the accountant.
All of that helps, but only up to a point. The real problem is that the system depends on people remembering dozens of small things at exactly the right time.
We wanted something that understood the mess instead of pretending it should not exist. Something that knows an invoice is not just a file, a reimbursement is not just an amount, and payroll is not just a bank transfer. Something that keeps the founder, employee, and accountant looking at the same source of truth without turning a five-person company into an enterprise finance department.
That is the gap we felt.
Jupikit is our attempt at filling it. Not by replacing accountants, and not by making founders learn every rule in the tax system. The point is simpler than that. Capture the right context when the expense happens, keep the details attached to the transaction, and make the handoff to the accountant less painful.
Because if you are dealing with this mess too, it is not just you. We are dealing with it as well. That is why we are building this.