Build vs buy, the document automation decision for Indian brokers.

Every six months, an Indian broker shop, lender, or HR team asks the same question. Should we just build our own document tool. We have in-house engineers, the requirements are clear, how hard can it be.

The answer is harder than it looks. This post breaks down what it really costs to build, what you actually get from buying, and a simple rule of thumb to decide which side is right for you.

What "building it ourselves" really means

Most teams underestimate the work because the first version looks simple. A PDF, some fields, a way to fill them. A junior engineer can put together a demo in a week. The real cost is what comes after the demo.

The hidden parts

• A drag and drop editor where non-engineers can drop fields on a PDF. This alone is two to three months of focused work.
• Version control so a template change does not break what is live in production.
• An audit log that records who signed what, when, from where.
• A fill experience that works on a phone, on a poor network, in any browser.
• Signature capture with three methods (draw, type, upload) and tamper-evident proof.
• Conditional sections (this clause only shows when X is true).
• Loop sections (one row per line item).
• An API for your developers to call when needed.
• Webhooks so your CRM updates when a document is signed.
• A way to bundle 40 documents into one signing flow for a customer.
• A way to store and retrieve old signed PDFs months later for compliance.

That is the real product, not the demo. A team that ships all of this well takes 8 to 14 months of two engineers working full time.

The demo takes a week. The production product takes a year. Most teams stop somewhere in between, with a half-working tool nobody trusts.

The full cost of building, in INR

Here is the honest math for an Indian team building in-house. We will assume two mid-level engineers.

Year one cost

• 2 engineers at Rs 18 lakh per year salary. Total Rs 36 lakh.
• 1 designer for 3 months at Rs 1.5 lakh per month. Total Rs 4.5 lakh.
• 1 product manager part-time for 6 months at Rs 1 lakh per month. Total Rs 6 lakh.
• Cloud and infrastructure costs at Rs 30,000 per month. Total Rs 3.6 lakh.
• One PDF library license (for proper rendering) Rs 1 lakh.
• Bug fixing and support time, hard to count, roughly 20% of engineering time on top.

Total year one cost, around Rs 51 lakh. To get to a tool that handles ten different forms reliably with proper audit and signing.

Year two cost

You still pay for the engineers because the tool needs upkeep. Forms change when IRDAI updates rules. Browsers change. Customers report bugs. The annual run rate is roughly Rs 45 lakh year two and beyond. Forever.

The cost of buying, in INR

Same problem solved with an off-the-shelf tool. Take Mezdoc as the example.

• Starter plan, Rs 999 per month, covers small teams.
• Growth plan, Rs 3,999 per month, covers most broker shops up to 50 people.
• Scale plan, Rs 14,999 per month, for high volume teams.
• No engineering time needed to set up. A non-technical ops person builds the first templates in an afternoon.

Total year one cost on Growth plan, roughly Rs 50,000. Compared to Rs 51 lakh to build. The math is brutal.

Side-by-side comparison

• Time to first working form, 1 hour (buy) vs 3 months (build).
• Year 1 total cost, Rs 50,000 (buy) vs Rs 51 lakh (build).
• Year 2 ongoing cost, Rs 50,000 (buy) vs Rs 45 lakh (build).
• Features included, 30+ field types, signing, audit, workflows, webhooks (buy) vs whatever your team has time to finish (build).
• Bug fixes, vendor problem (buy) vs your engineering team (build).
• IRDAI form updates, vendor adds it (buy) vs your team patches the template (build).
• Hiring risk, none (buy) vs lose one engineer, the project stalls (build).

When building actually makes sense

Buying wins for most teams, but not all. Building is the right call in three specific cases.

1. The document is your product

If your company sells the document itself (a legal contract generator startup, a form-filling app for end users), then the document engine IS your product. You should build it, not buy it. Buying means you are selling someone else's engine.

2. You have requirements no vendor can meet

For example, a bank with a homegrown core banking system that needs a document tool to run on-premise, behind their firewall, in an air-gapped network. No SaaS vendor will fit. Build is the only option.

3. You already have a dedicated team

If you already have a document engineering team in-house (some big insurers do), building a tool that exactly fits your workflow can be cheaper than retrofitting a SaaS tool around it. But this is rare and only for companies above 500 people.

Building makes sense in three cases. Most teams do not fit any of them. They build because building feels safer, not because it is better.

The hidden risks of building

Beyond the cost, building has three risks that do not show up on a spreadsheet.

• Engineer departure. If the one engineer who built it leaves, the rest of your team has to relearn the codebase. This kills six months.
• Feature stagnation. Vendors ship new features (Aadhaar eSign support, IRDAI rule updates) every quarter. Your in-house team will not ship these unless they are paid to keep building.
• Compliance drift. If a new IRDAI rule lands and your engineering team is busy elsewhere, your forms fall out of compliance. With a vendor, this is their problem to fix.

A simple rule of thumb

Use this 30-second test to decide.

• Will document automation be a feature your customers pay you for directly? If yes, build.
• Do you have at least two full-time engineers free for 12 months? If no, buy.
• Does your industry have specific compliance requirements no vendor meets? If yes, build. If a vendor like Mezdoc meets them, buy.
• Are you trying to save Rs 50,000 per year? Buy. Building to save that money costs you Rs 50 lakh.

What we hear from teams that already chose

Brokers we talk to who tried building say the same thing. They wish they had bought sooner. The team spent a year on a half-finished tool, then bought Mezdoc anyway. The year of engineering time turned out to be the most expensive mistake.

The teams that bought first, on the other hand, almost never switch to building. They customise the vendor through the API where they need to, and use the off-the-shelf flow where it works.

Where to go from here

If you are still considering building, do this. Take one form your team fills frequently. Set it up on Mezdoc free plan in an afternoon. Run 10 real customers through it. Then compare the time and cost to what you estimated for building.

The decision becomes obvious in less than a week, and you saved months of meetings about it.