Software shaped around your business, not the other way round
Off-the-shelf products make you change your process to fit theirs. That is often fine. When your process is the thing that makes you competitive, it is expensive — and that is when custom software earns its cost.
Almost every mid-sized company we meet runs on a hybrid system nobody designed. There is an accounting package, usually Tally. There are between six and forty Excel files that hold the parts Tally does not. There is a WhatsApp group where actual decisions happen. And there are two or three people who are the only ones who understand how the pieces connect — which means the company has a single point of failure with a notice period.
That arrangement is not stupid. It evolved because each piece solved a real problem faster than a formal system would have. But it has a cost curve that bends sharply upward: as volume grows, the re-keying grows linearly, the error rate grows, month-end close gets longer, and the number of questions that simply cannot be answered — which customer is actually profitable, which SKU is losing money, why did dispatch slip in March — grows too.
Custom software is worth building at exactly the point where that cost exceeds the cost of the system. Our job in the first conversation is to help you work out honestly whether you are at that point, and if you are, to build the smallest system that removes the largest cost. We have told prospects that Zoho or an off-the-shelf ERP would serve them better, and we would rather do that than sell an eighteen-month project that fails.
Where we do build, we build systems that last. Our oldest running client system went live in 2015 and is still handling daily operations, because it was built on boring, well-understood technology with a data model that reflected the business rather than the fashion of the moment.
How we decide what to build first
The most common failure in custom software is scope: an organisation tries to replace everything at once, the project takes two years, requirements drift, and the thing that goes live no longer matches the business. We work in the opposite direction.
In discovery we map every process end to end and attach two numbers to each: how many person-hours a month it consumes, and how much money leaks through it in errors, delays or missed opportunity. That gives a ranked list. The first release addresses the top one or two items only, and it goes live within eight to fourteen weeks. It earns its budget before we build anything else.
This has a second benefit. By the time release two is specified, your team has used release one for two months and knows far more precisely what they actually need — which is almost never what they said in the first workshop, and that is not a criticism of them. Nobody specifies software well in the abstract.
| Process | Monthly hours | Annual error cost | Priority |
|---|---|---|---|
| Order entry from email and WhatsApp into Tally | 186 | ₹8.4 L in pricing errors | 1 |
| Dispatch planning across three warehouses | 94 | ₹5.1 L in detention and re-routing | 2 |
| Monthly MIS assembly from twelve spreadsheets | 72 | Decisions made 3 weeks late | 3 |
| Field inspection reporting on paper | 61 | ₹2.2 L in disputed claims | 4 |
| Vendor invoice matching | 48 | ₹1.6 L in duplicate payment | 5 |
The architecture we build on
For most business systems our default is a Node.js or Laravel API with PostgreSQL underneath and a React or Next.js front end. PostgreSQL is deliberate: business systems are relational, they need real constraints and transactions, and they need to answer reporting questions years later. Choosing a document database because it feels modern is one of the more expensive mistakes we get called in to unwind.
Where a client's team is PHP-strong we build in Laravel or CodeIgniter 4 and make it genuinely good — proper service layers, migrations, queues, tests. The framework matters far less than whether the people who will maintain it can read it.
Everything is designed around a few non-negotiables. Every table that matters has an audit trail: who changed what, when, and what the previous value was. Every workflow that involves money or approval has a state machine rather than a boolean flag, so you can always answer where something is and who is holding it. Every integration is idempotent and retry-safe. And every environment — development, staging, production — is created from the same infrastructure definition, so "it worked on staging" is a meaningful statement.
In practice
Every engagement starts with a conversation, not a proposal template.
Thirty minutes with a senior engineer. You leave with an architecture sketch and an honest cost range, whether or not you hire us.
Integrating with what you already run
Nobody replaces everything, and they should not. Tally is an excellent accounting package and your CA knows it. Your plant historian works. Your bank has its own portal. Custom software succeeds by fitting between these, not by pretending to replace them.
We have built integrations with Tally Prime, SAP, Oracle, Zoho, Salesforce, Marg, Busy, and a long list of bespoke systems written by someone who left in 2011. The pattern is consistent: a thin adapter service that speaks the legacy system's language on one side and a clean, documented API on the other, with a reconciliation report so finance can verify what synced.
That reconciliation report is not optional. Every integration will fail sometimes — a network drop, a locked file, a schema change nobody announced. The difference between a robust system and a fragile one is whether failures are visible and recoverable or silent.
Adoption is a design problem, not a training problem
The graveyard of custom software is full of technically correct systems nobody uses. Staff continue with the spreadsheet because it is faster, and within four months the official system holds stale data and everyone stops trusting it.
The fix is mostly in design. Screens must be faster than the thing they replace, measured with a stopwatch, not asserted. Fields must be in the order people actually fill them, which we learn by watching. Data that the system already knows must never be asked for again. Bulk entry, keyboard navigation and sensible defaults matter more than aesthetics for a user doing this two hundred times a day.
We also run pilots with the most sceptical user we can find rather than the most enthusiastic. If the person who hates change can complete their day faster on the new system, adoption takes care of itself.
The stopwatch test
Before rollout we time a real user completing a real transaction on the old process and the new one. If the new one is not meaningfully faster, we redesign it. Every system we have shipped that passed this test achieved over 90% adoption within a month.
What we build most often
Order and dispatch management for distributors and manufacturers — capturing orders from every channel, applying the right price list, checking credit, allocating stock, planning dispatch and pushing invoices into accounting.
Production and quality systems for plants — shift logs, batch records, quality checks, downtime capture with reason codes, and the daily and monthly reports that currently take somebody four hours each morning.
Service and field operations — job allocation, engineer scheduling, spare parts, warranty validation, service history and a customer-facing status page that removes half the phone calls.
Project and contract management for construction, EPC and consulting firms — milestones, billing, retention, subcontractor bills, and the physical-versus-financial progress view that most spreadsheets do badly.
Compliance and document systems for regulated sectors — controlled documents, version history, sign-offs, expiry alerts and an audit trail that satisfies an inspector without a week of preparation.
“We were three people re-typing orders from email into Tally, working till nine most nights. Their system took that to twenty minutes of exception handling a day. It paid for itself in seven months.”
Ownership, documentation and what happens if we part ways
You own the source code, the database and the infrastructure from day one. We work in your repository and your cloud account. There is no runtime licence, no encrypted module, and no dependency on a component only we can rebuild.
We document as we go: a data dictionary, an architecture overview, integration specifications, deployment and rollback runbooks, and a recorded walkthrough. The test we hold ourselves to is that a competent engineer who has never met us could take over the system in a fortnight. We have handed systems over on exactly those terms and it costs us nothing we are not comfortable with.
Every engagement starts with a conversation, not a proposal template.
Thirty minutes with a senior engineer. You leave with an architecture sketch and an honest cost range, whether or not you hire us.
What is actually included in custom software development
Each of these is something we have shipped and still support in production — not a list of things we could do if asked.
Process discovery and costing
We map and cost your processes before proposing anything, so the business case is arithmetic rather than assertion.
Order and dispatch systems
Multi-channel order capture, pricing engines, credit checks, allocation and dispatch planning.
Production and quality
Shift logs, batch records, QC checks, downtime with reason codes, and automated daily reports.
Field service management
Job allocation, engineer scheduling, spares, warranty and customer status visibility.
Approval workflows
Multi-level, delegation-aware approvals with full audit history and mobile action.
Document and compliance
Controlled documents, versioning, expiry alerts and inspection-ready audit trails.
Legacy modernisation
Strangler-pattern replacement of ageing systems, module by module, without a big-bang cutover.
Integration layer
Adapters for Tally, SAP, Oracle, Zoho, banking and plant systems with reconciliation reporting.
The stack we actually use for this
Chosen for what your team can maintain in three years, not for what looks impressive in a proposal.
Backend
- Node.js
- Express
- NestJS
- Laravel
- CodeIgniter 4
- Python
Data
- PostgreSQL
- MySQL
- MongoDB
- Redis
- Elasticsearch
Front end
- React
- Next.js
- TypeScript
- React Native
Platform
- Docker
- Kubernetes
- AWS
- Azure
- GitHub Actions
- Grafana
From first conversation to something in production
Two-week slices, a demo you can share every alternate Friday, and no phase where you are waiting without seeing progress.
Process mapping
On site, watching the work, with hours and error costs attached to every step.
Business case
A ranked list of what to build, with expected saving and cost per item — your CFO's document.
Data model design
The longest-lived decision in the system, made by a senior engineer with your domain experts.
Release one
The highest-value slice, live in eight to fourteen weeks, earning before anything else is built.
Pilot and stopwatch test
Real users, timed against the old process, redesigned if it is not faster.
Roll out and extend
Wider rollout, then subsequent releases informed by two months of real usage.
Everything hands over. No lock-in, ever.
Source code in your Git organisation, infrastructure in your cloud account, domains in your name and documentation written for the next team rather than for us. If you part ways with us in year three, a competent engineer should be able to take over in a fortnight.
Deliverables checklist
- Source code and database in your ownership
- Data dictionary and architecture documentation
- Integration specifications with reconciliation reports
- Role and permission matrix agreed with your management
- Deployment and rollback runbooks
- User manuals and recorded training, in Bengali or Hindi where useful
- Automated tests on the money-handling paths
What this typically costs
Real ranges from real projects. The variable is almost always scope and integration count — the calculator will get you closer in two minutes.
Discovery
₹1,20,000
Process mapping and a costed business case before commitment.
- On-site process mapping
- Hours and error costing
- Ranked build plan
- Architecture outline
- Budget estimate
Release one
₹6,50,000 – ₹18,00,000
The highest-value module, live and earning.
- Data model and API
- Web application
- Key integrations
- Pilot and rollout
- 90 days support
Platform programme
₹25,00,000 upwards
Multi-module ERP-class system delivered over quarters.
- Multiple modules
- Mobile applications
- Reporting and BI
- Dedicated pod
- SLA support
All figures exclude GST. Fixed-price options available on defined scope. Build your own estimate →
The questions clients actually ask
Including the ones where the honest answer is that you may not need us. If your question is not here, call +91 70033 91355 — you will speak to an engineer, not a call handler.
Often, yes. If your processes are conventional, an established product with a large user base will be cheaper, faster and better supported than anything custom. Custom is justified when your process is genuinely a competitive advantage, when you have a workflow no product models, or when licence costs across many users exceed a build. We run that comparison honestly in discovery and have recommended clients buy rather than build more than once.
Discovery is fixed price. After discovery we can usually offer a fixed price for release one because the scope is genuinely known by then. Longer programmes run as a dedicated pod on a monthly rate with a quarterly roadmap, which is more honest than pretending an eighteen-month scope can be fixed. Payments are milestone-linked and every milestone has a demonstrable deliverable.
On fixed-price work we absorb overruns caused by our estimation. We do not absorb scope added mid-project — that is quoted as a change with its own cost and timeline, in writing, before work starts. The two-week slice model keeps this visible: you see progress every fortnight, so a slip is apparent in week four rather than month six.
That is an explicit design goal. We use mainstream technology, follow conventional patterns, document as we go, and offer a handover period where your developers pair with ours. Several clients now run their systems entirely in-house and call us only for larger additions. We would rather have that relationship than a captive one.
Carefully, because it is usually the messiest part. We write repeatable migration scripts rather than doing manual cleanup, so it can be run many times as data is corrected. We produce a validation report showing counts, totals and exceptions, and we insist your team signs off on that report before go-live. Expect the data to be worse than anyone believes — it always is, and finding out early is the point.
Ninety days of hypercare is included with every build. After that most clients take an AMC covering defined response times, bug fixes, small enhancements, infrastructure monitoring and quarterly reviews. Rates depend on system criticality; a plant system with a four-hour response commitment costs more than an internal tool with next-business-day.
Why being local to you matters here
The industrial belt around Kolkata — Howrah, Dankuni, Durgapur, Asansol, Haldia — is full of companies doing ₹50 crore to ₹500 crore of business on systems held together by three key people and a shared drive. Those companies are usually not looking for digital transformation; they are looking for month-end to stop taking nine days. That is the work we do, and being an hour away means we can spend a day on your shop floor rather than guessing from a specification.
For custom software development in Kolkata and West Bengal, call +91 70033 91355 or WhatsApp us. Discovery can start with a single day on your site.
Services that pair with this
View everythingTell us what is slowing your business down.
A 30-minute call with a senior engineer — not a salesperson. You leave with an architecture sketch and an honest cost range, whether or not you hire us.
Direct line
+91 70033 91355Mon–Sat · 9:30 AM – 7:30 PM IST · Sealdah, Kolkata