How is ERP different from CRM, and what modules does it include?
A CRM manages the relationship with the customer: leads, deals, contacts, tasks, communication history. An ERP manages the resources the company uses to fulfil those deals: goods, materials, suppliers, production orders, money. The CRM answers who we sell to and where the deal stands. The ERP answers what we have, what we owe, what we can ship and what it cost us.
The boundary is blurry in practice. A deal that closes in the CRM becomes a sales order in the ERP, which reserves stock, triggers procurement or production and eventually produces an invoice. That handoff is where most integration pain lives. If you are still choosing between the two kinds of system, start with custom CRM or ready-made and how to design a sales pipeline.
"ERP" is a set of modules, not one product. You rarely need all of them. The usual building blocks are:
- Warehouse: items, locations, receipts, shipments, transfers, stocktaking, batches or serial numbers where they matter.
- Procurement: supplier orders, expected deliveries, receiving against the order, price history.
- Production: bills of materials, production orders, material consumption, finished goods output, scrap.
- Sales orders: reservations, shipments, returns, links to the CRM deal.
- Finance and cost: payments, receivables and payables, cost of goods, margin per order. This is management accounting, not a replacement for statutory bookkeeping.
- Reference data and access: nomenclature, counterparties, units of measure, users and roles.
When you do not need a custom ERP, and when you do
Most small and mid-size businesses should not build an ERP. A ready-made system has years of edge cases already solved: taxes, units of measure, reports, updates, a community that knows it and consultants who can configure it. You pay for that in licences or subscriptions and in accepting the vendor's way of working.
Be honest about your own process before you decide. If your warehouse, purchasing and sales work the way most companies in your industry work, a configured product is cheaper to own than a bespoke one, because you do not carry the maintenance yourself.
Custom work pays off when one process is both specific to you and expensive. Typical signs: production with unusual routing or batch tracking, a warehouse logic tied to your own pricing or packing rules, a mix of retail, wholesale and manufacturing that no product models without workarounds, or a ready-made system where every needed change turns into a paid customisation that nobody can maintain.
A middle path often beats both extremes: keep the off-the-shelf product for the standard parts and build a small service around it for the one process that is yours. This is the same hybrid logic we describe for CRMs, and the data model discipline below applies equally to extending an existing system.
- Your process is standard for your industry and the product covers it with settings, not code.
- You mostly need reporting and order tracking: a spreadsheet moved into a proper database may be enough, and the module list above is overkill.
- You have no one who will own the system after launch: product decisions, access requests, bug triage.
- The pain is in one narrow place, for example a missing report or a slow import. An extension or a small integration solves it without a new system.
- Statutory accounting is the main job. Do not rebuild it: use the accounting product your accountant already works in.
- You cannot yet describe the process on one page. Build nothing until you can; a tool will freeze the confusion in code.
How to build an ERP in stages around one process
The reliable way to fail is to specify a full ERP up front. The reliable way to succeed is to pick one process that hurts most and make it work end to end, then grow. Choose by cost of the problem, not by how interesting the module is.
A realistic path looks like this:
- Map the real process on paper first: who does what, which documents exist, where numbers are copied by hand. Include the exceptions people handle by memory.
- Build the smallest closed loop. For a warehouse that is items, locations, receipts, shipments and the stock balance. For production it is a production order that consumes materials and outputs goods.
- Run it in parallel with the old way for a short time and compare results. Differences are bugs in either the model or the habits.
- Add the neighbouring process only when the first one is stable: procurement after stock, sales reservations after procurement, costs after both.
- Keep reference data, documents and movements as separate concepts from the first release, so later modules attach instead of rewriting.
- Plan the exit and the export from day one: a data model that cannot be exported is a trap for your own business.
Stock as a journal of movements, not a number
The most common ERP design mistake is a single column quantity on the item that every screen increments and decrements. It works until the first dispute: why is the balance wrong, who changed it, what was it last Tuesday. A number cannot answer any of those questions.
Store movements instead. Every receipt, shipment, transfer, write-off and stocktaking correction is an immutable row with item, location, quantity (positive or negative), a reference to the source document, the author and the timestamp. The balance is the sum of movements, optionally cached in a table that is updated in the same database transaction as the movement and can always be rebuilt from the journal. Corrections are new movements that reverse old ones, never edits.
This gives you history for free, makes audits answerable, and lets you compute the balance as of any date. In Postgres the journal is an append-only table with constraints; the cached balance is updated in the same transaction, and concurrent writes to one item are serialised with row locks or a version check so that two shipments cannot both take the last unit. The same retry-safety rules apply when documents arrive from outside: see API idempotency and retries so a repeated request does not post a receipt twice.
Treat reservations the same way: a reservation is a separate record against a sales order, so "on hand" and "available" are different numbers, both explainable.
Connecting accounting and 1C
Most companies already keep their statutory books in an accounting product, often 1C in Russia and neighbouring countries. A custom ERP should not try to replace it. Decide what is the source of truth for each entity: usually counterparties, nomenclature and chart of accounts live in the accounting system, while operational documents such as receipts, shipments and production orders originate in your system and are passed on.
Build the exchange as an explicit, observable pipeline: a queue or outbox of documents to send, a stable external identifier on every record, retries that cannot duplicate a document, and a visible list of failed items someone owns. Designing resilient CRM and ERP pipelines covers the patterns. For the 1C side specifically, which mechanisms exist (file exchange, HTTP services, standard interfaces) depends on the configuration and platform version, so check the vendor documentation for your exact product before choosing; our overview of 1C integration options compares the approaches.
Never share one database between systems as an integration method. It couples release cycles and makes both systems fragile.
Access rights and audit trail
ERP data is money and inventory, so access design is not optional. Start from roles tied to real duties: warehouse operator, buyer, production manager, accountant, owner. Separate permission to create a document from permission to confirm it, and from permission to see cost and margin. Enforce all of it on the server; hiding a button is not a control. The patterns are covered in roles and permissions design.
Posted documents should be immutable. If a receipt was wrong, a correcting document is created and linked, so the original stays visible. Log who did what and when for sensitive actions: price changes, write-offs, manual balance corrections, role changes. Keep the log append-only and make it searchable by document, because that is how the question will actually arrive.
Add backups you have tested by restoring, not only by scheduling. The cost of losing a week of movements is higher than the cost of a rehearsal.
Migration from spreadsheets and the old system
Migration is where an ERP project quietly gets hard. Opening balances must match reality, so the safest approach is a stocktaking: count what is physically there, load it as the opening movement dated to a cut-off moment, and start the journal from that point rather than importing years of dirty history. Keep old documents available read-only or archived.
Reference data needs the same care as in any system change: deduplicate counterparties and items, agree on units of measure, assign stable identifiers and keep a mapping to the identifiers in the accounting system. The staging, rollback and cut-over steps are described in CRM data migration and carry over almost unchanged.
Pick a cut-over point where operations are quiet, freeze edits in the old system, load the opening balances, reconcile counts and money, and only then let people work in the new one.
When a contractor makes sense
A contractor helps when the process is clear enough to describe but nobody on your side can design the data model, own the integration with accounting, and support the system afterwards. It does not help when the process itself is undefined, or when a configured product would do the job.
Before you hire, prepare: the process map, the documents people actually use, a list of exceptions, the systems you must connect to, and one person on your side who decides priorities. Ask the contractor how they would model stock and documents, how corrections are handled, how you get your data out, and who maintains the system after launch. Answers that are vague on those points are a warning. If you want to discuss a specific case, see our CRM and business systems development.