When your ERP or WMS doesn’t cover a logistics process, you have four options, not two: buy another product, configure the system you already own, extend around it through its supported interfaces, or build custom software. Decide with six criteria: how much the process sets you apart, the upgrade path, the number of integrations, who owns the data, the team needed to maintain it, and five-year cost. Check configuration first, buy when the process is standard and a vendor can carry its changes, and extend when the core holds the record and the gap is narrow. Build only when no package meets your must-haves and you can fund a team to keep it running.
That is the short answer to the build vs buy WMS question. The rest of this field note defines the options precisely, sets out the criteria as a decision table, gives a cost model you can fill in, and walks through a fictional scoring example. It also states where we stand, because a firm that builds software has an obvious interest in the answer.
Our interest, stated up front. GenFrontier builds shipment-tracking and inventory software around existing ERP, WMS and TMS. Extending and building are work we could be paid for. Buying and configuring are not. We resell no software and have no vendor partnerships, so no license recommendation earns us anything.
Read the criteria below with that interest in mind. Where buying or configuring is the better answer, we say so in plain terms, and the section on buying is at least as long as the section on building. Nothing here ranks products; the vendor documents quoted are there for their extension and update policies, not as recommendations. The criteria work the same whichever vendors are on your shortlist.
Why build vs buy WMS is really a four-way choice
The question is rarely whether to use packaged software at all. It is how much of the process the package should carry and where the custom part should sit. David Carney’s 1997 monograph for the Software Engineering Institute (SEI) at Carnegie Mellon put it this way: the decision “is more likely to focus on the extent of commercial components in the system rather than whether to use COTS at all”, where COTS means commercial off-the-shelf (Carney, SEI, 1997).
The four options, defined
Most build-or-buy articles blur the options together. A configuration change gets called “customization”, and an integration gets called “a build”. The blur matters, because each option carries a different upgrade risk and a different maintenance bill.
| Option | What it means | What changes in the core system | Who maintains it |
|---|---|---|---|
| Buy | License another package for the missing process, next to the core or as its replacement | Nothing, or the core is retired | The vendor maintains the product; you maintain its interfaces |
| Configure | Turn on and set up features the core already has: parameters, workflows, user-defined fields, reports | Settings only, inside the vendor’s supported tools | You maintain the settings; the vendor carries them through upgrades |
| Extend | Build a separate application or module that reads and writes the core only through supported APIs, events or files | Nothing in the vendor’s code | You, or whoever you contract |
| Build | Write a custom system that takes over the whole process, often including its own data | Interfaces only, but the custom system becomes a new core | You, permanently |
Configuration versus customization
The test that separates them is simple. Ask whether the vendor’s next release will carry the change forward without anyone touching it. Settings, user-defined fields, approval workflows and report layouts built in the vendor’s own tools usually pass. Changes to the vendor’s source code or database schema do not.
The fifth option, which is to avoid
There is a fifth path that no one proposes by name: modifying the core product’s own code. It often starts as one urgent change and grows release by release.
Carney’s monograph describes where it ends. Where customization “does not fit well or overshadows the commercial products”, he wrote, the system “can suffer simultaneously from the constraints of a proprietary, custom-built system and the competing constraints that stem from the whims of the marketplace”. You carry the cost of custom code and still depend on someone else’s release calendar.
At least one large ERP vendor has closed this path by design. Microsoft’s developer documentation for its Dynamics 365 finance and supply chain apps says the move to frequent cloud updates “requires a less intrusive customization model, so that updates are less likely to affect custom solutions”, and that “Overlayering isn’t supported” (Microsoft Learn). Whatever your platform, treat modification of the core as a last resort that needs a written exit plan.
Use what you own first
Federal IT policy offers a useful order of operations. The 2016 Federal Source Code Policy, OMB memorandum M-16-21, required agencies to work through three steps (OMB M-16-21):
- Analyze alternatives, giving “preference to the use of an existing Federal software solution”, meaning software the government already holds rights to.
- If that cannot meet the need, explore whether the requirements “can be satisfied with an appropriate commercially-available solution”.
- Only then consider custom code, “in whole or in conjunction with existing Federal or commercial code”.
The memo also told agencies to consider hybrids, mixtures of existing, commercial and custom code, at every step. It recommended modular architecture because modularity “can reduce overall risk and cost”. Translated to a distribution center: configure what you already license, then look at packages, then extend or build, and expect the answer to be a mix.
Requirements and products shape each other
The SEI’s later framework for commercial-component systems, EPIC, starts from the same point. Its overview says that defining requirements, then an architecture, then searching for components that fit “have been disappointing”. It recommends “concurrent discovery and negotiation” of user needs and business processes, available products, the target architecture and programmatic constraints (SEI, EPIC overview, 2002).
In practice, that means your requirements list is a draft until you have seen what the market and your current system already do. Some requirements will turn out to be habits.
Six criteria that decide it
Score each option against the same six criteria. No single criterion decides the answer, but two of them, differentiation and the team to maintain it, eliminate options faster than the rest.
| Criterion | Points to buy | Points to configure | Points to extend | Points to build |
|---|---|---|---|---|
| How differentiating the process is | Standard across the industry | Standard, and the core already models it | Specific to you, but narrow | Central to how you compete, and broad |
| Upgrade path | Vendor carries partner and rule changes | Settings survive upgrades untouched | Core exposes stable, documented interfaces | You control the release calendar |
| Number of integrations | One or two new interfaces | None | Needs data from two or more systems | Replaces several manual handoffs |
| Data ownership | Export and exit terms are acceptable | Data stays in the core | Core keeps the record; extension keeps its own data | You must own schema and history |
| Team to maintain it | No developers on staff | An administrator who knows the core | Access to developers for interfaces | A funded team for the system's life |
| Five-year cost | Subscription beats build and upkeep | Lowest, if it meets the must-haves | Moderate build, low run cost | Justified by value only you capture |
1. How much the process sets you apart
Ask whether customers choose you because of how you run this process. A food distributor’s lot and expiry discipline might qualify. Its freight-bill audit almost certainly does not.
Standard processes belong in packages. Packages encode how most companies do the work, and the SEI’s report on a Department of Defense manufacturing resource planning (MRP II) program warns that “All software packages include assumptions about the way in which they will be used; violating these assumptions means that the software will be hard to use” (Brownsword and Place, SEI, 2000). If you are willing to work the way the package assumes, buying gets much cheaper.
2. The upgrade path
Every option has an upgrade path; the difference is who controls it. A cloud package updates on the vendor’s schedule. Microsoft’s documentation, for example, says customers of its finance and supply chain apps can pause “for a maximum of one consecutive service update”, with updates applied to the user acceptance testing environment first so customers can validate (Microsoft Learn).
That cadence is an advantage for anything the vendor carries, such as tax tables, carrier label formats or EDI versions. It is a recurring test for anything you attach. Each extension and interface needs a regression test every time the core updates.
3. The number of integrations
Count the interfaces each option needs before you compare prices. A new package for dock scheduling might need a purchase order feed in, an ASN feed in and a receipt confirmation out. That is three interfaces to build, monitor and retest.
Carney is blunt about the work between products: commercial products “will rarely fit together without some sort of third-party work”. The usual fix is “wrappers,” “bridges,” or other “glueware”, which “can increase, rather than decrease, a system’s overall cost”. Glue code is real software with its own maintenance, and it has to be repeated “during maintenance as each product changes”. List every interface with the integration inventory worksheet before you compare options.
4. Who owns the data
For each data element, decide which system holds the record and which systems hold copies. A package that keeps its own inventory balances creates a second balance to reconcile. An extension that reads balances from the core and writes only its own data does not. Our field note on which system should own each inventory number covers that assignment element by element.
Data ownership also has a contract side. For any package, read the export and exit terms: in what format you get your history, how fast, and at what cost. For any build, confirm in the statement of work who holds the source code and the database design.
5. The team needed to maintain it
This criterion eliminates more custom builds than any other. Carney noted that “system maintenance and evolution has long been known to be the most expensive portion of the life-cycle cost”. A custom system needs people who understand its code for as long as it runs.
Be honest about the depth of your bench. One in-house developer who wrote the system is a single point of failure, not a team. If you would need a contractor for every change, price that contractor into every year of the model.
6. Five-year cost
One-time cost favors configuration and buying. Run cost over several years can reverse that. Model five years with the same cost categories for every option, as described in the cost section below, and include the internal hours your people will spend.
When buying another package is the better answer
Buying wins more often than a software builder might like to admit. If several of the conditions below are true, a package should be your default, and extending or building needs a specific reason to beat it.
- The process is standard and you are willing to adopt the package’s way of working. The MRP II depots that changed their processes let the program buy commercial software “rather than having to develop and maintain a customized system” (Brownsword and Place).
- Outside rules change often. Carrier label specifications, parcel rating, EDI versions and tax rules change on schedules you do not set. A vendor with many customers spreads that cost; a custom system pays it alone.
- You have no developers and do not want any. A package with a support contract asks for an administrator, not a development team.
- The gap is a whole function, not a feature. If your ERP’s inventory module lacks directed put-away, wave picking, RF scanning and labor tracking, you are describing a WMS. Extending an ERP until it becomes a WMS is a build in disguise.
- The gap list is long and growing. When the core misses many processes and is near the end of its supported life, replacing the core is usually cheaper than surrounding it with extensions.
- You need it soon and can accept process change. A configured package can be live sooner than a build, provided the people on the floor accept the package’s screens and sequence.
- Many sites and many users need the same thing. Vendor training material, user communities and implementation partners reduce the cost of rolling out at scale.
Buying is not free of risk. The MRP II report records that features requested from a vendor “will be added only if they make commercial sense to the vendor”. It also says that “The DoD underestimated the time to transition and deploy” the system. Budget for interfaces, data conversion and process change, not only the license.
How to buy well
Write your must-haves before demos, then ask vendors to run your scenarios with your data, not their standard script. The software requirements checklist lists what to cover. Keep the team that wrote the requirements on the evaluation; the MRP II program did exactly that so the people who knew the needs judged the proposals.
Questions to put to every vendor
Ask each shortlisted vendor the same questions in writing, so the answers can be compared side by side:
- Which of our must-have requirements does the standard product meet without code, and which need configuration?
- How often does the product update, can we defer an update, and for how long?
- Which APIs, events and file formats are documented and supported, and how are breaking changes announced?
- Does the product keep its own copy of inventory, orders or item data, and how is that copy kept in step with our ERP?
- In what format, how quickly and at what cost can we export all our data and history if we leave?
- Which costs sit outside the subscription: implementation, interfaces, devices, training, extra environments?
A vendor that answers all six plainly makes the comparison easier. A vendor that cannot answer the fifth is telling you something about data ownership.
When configuring what you already own wins
Configuration is the first option to test because it is the cheapest and the safest. Plenty of gaps turn out to be features that were licensed, never switched on, and forgotten after go-live.
Look in four places before you commission anything:
- Release notes since your go-live. Cloud vendors add features with updates, and some ship them switched off until a customer opts in.
- Modules you already license but never implemented. Check the contract, not only the menu.
- Configuration tools the original project skipped. Workflows, user-defined fields, alerts, and report or label designers.
- The vendor’s support community and documentation. Search for the exact process, such as “blind cycle count” or “lot expiry hold”.
Signs configuration is enough
- The process can follow the system’s sequence with only minor changes on the floor.
- The data the process needs already lives in the core.
- The change can be made, tested and documented by your system administrator.
- The vendor’s documentation describes the setting as supported.
Example (fictional). A distributor asks for custom software to run cycle counts by ABC class with blind counting. A review of its WMS finds a cycle-count module already licensed, with count classes, blind-count mode and a recount threshold, all switched off since go-live. Configuration, a written procedure and two training sessions cover 9 of its 11 must-have requirements. The remaining two are a weekly variance report by root cause and a supervisor approval above a dollar threshold. Both turn out to be a report and an approval workflow the same WMS can be set up to handle.
Where configuration stops
Configuration stops being the answer when the process needs data the core does not hold, such as carrier status events, or serves people who should not log in to the core, such as a 3PL’s clients. It also stops when the change needs code inside the vendor’s product. At that point you are choosing between extending and the fifth option, and the fifth option should lose.
When extending around the core makes sense
Extending means building a separate application that treats the ERP or WMS as the system of record and talks to it only through supported interfaces. It suits narrow gaps that sit across systems, where the process is specific to you but the core data is not.
Typical extension candidates in logistics share a pattern. They combine data from two or more systems, or they serve people who should not log in to the core.
- A shipment milestone view that combines ERP orders, WMS ship confirmations and carrier status messages.
- A client-facing inventory view for a 3PL, by owner, lot and expiry, without giving clients WMS logins.
- A receiving app that checks ASNs and SSCC labels against purchase orders before the WMS receipt posts.
- A lot genealogy lookup that joins receipts, transformations and shipments across systems for recall work.
What makes an extension safe
An extension is only as safe as its boundary with the core. Hold it to five rules:
- Use only supported interfaces. Published APIs, documented events, standard EDI messages or vendor-supported file imports. Never write directly into the core’s database tables.
- Keep one system of record per data element. The extension may cache core data for speed, but it never becomes a second source of on-hand balances.
- Own your data. Data the core does not hold, such as carrier events or client notes, lives in the extension’s own database, under your control.
- Test every interface on every core update. Put the interface tests in the regression suite you run before each vendor release.
- Document the interfaces like a product. A runbook names each interface, its trigger, its volume, its owner and what to do when it fails.
Example (fictional). A distributor’s ERP holds purchase orders and its WMS holds receipts, but nobody can see inbound loads between the supplier’s dock and its own. The extension reads open purchase order lines from the ERP API every 15 minutes, takes supplier 856 ship notices from the EDI translator and carrier status messages from a carrier API, and stores those events in its own database. It writes nothing back to the ERP or WMS. Buyers see each PO line as ordered, shipped, in transit or delivered, with the ASN quantity beside the ordered quantity. When the ERP vendor ships its next update, the team reruns its three interface tests before the update reaches production.
What extending costs you
Extension does not remove glue code; it is glue code with a user interface. You take on its maintenance and its retesting on every core release. If the core vendor later ships the same feature, retiring your extension should be a planned and cheap event, which is another reason to keep it separate from the core.
This is where our own interest lies, so apply the test strictly. If the extension would need more than a handful of interfaces, or would duplicate most of a package that already exists, buy the package.
When building custom software is justified
A full custom build makes sense in fewer cases than the build-or-buy debate suggests, but those cases are real. Building is justified when no package meets your must-haves after you have challenged them, the process is central to how you compete, and you can fund the people who will maintain the system.
Challenge the must-haves first
The MRP II team sorted requirements into “must have,” “should have,” and “nice to have”. Its report puts the challenge in one sentence: “creating a requirement solely to satisfy an existing process is insufficient. There must be a strong reason for the requirement to exist; otherwise it should be considered a preference that may be negotiated away.”
Apply that to every requirement that rules out a package. “We have always printed the pick list in bin order” is a preference. “Our customers’ contracts require lot-level recall within four hours” is a requirement.
Cases that hold up
- The process is your product. A 3PL that sells a specific kitting or value-added service may need software that models it exactly.
- The data model is unusual. Serialized kits with field returns, or ownership that changes mid-warehouse, can break package assumptions.
- Control of the roadmap matters more than speed. You need to change the process monthly, on your schedule.
- You have, or will fund, a team. The build budget is the smaller number; the five-year maintenance budget is the one to approve.
Cases that fail
- Rebuilding a legacy system screen by screen to avoid retraining.
- Building because a vendor demo did not show a feature nobody asked the vendor to demonstrate.
- Building with one developer and no documentation.
History offers a warning. The MRP II report notes that the program replaced an earlier depot system “based on different custom software and modified COTS products”, which “was unsuccessful”. The replacement program allowed “No modification of the COTS product suite’s software”.
Counting five-year cost honestly
Compare options over five years with identical cost categories, including your own people’s time. One-time costs dominate the first year, and run costs dominate the fifth. The cheapest option at go-live can differ from the cheapest at year five, and the order can flip more than once.
Cost categories to include for every option
| Category | Buy | Configure | Extend | Build |
|---|---|---|---|---|
| License or subscription | Yes, every year | Already paid, check module fees | Hosting and any tooling | Hosting and any tooling |
| Implementation or build | Vendor or partner services | Administrator time | Development and testing | Development and testing |
| Interfaces | Build each one, then monitor | Usually none | Build each one, then monitor | Build each one, then monitor |
| Data migration | Opening balances, master data | Usually none | Reference data only | Full history if required |
| Testing per core update | Interfaces and process | Settings and reports | Interfaces and extension | Interfaces and the system |
| Training and documentation | Vendor material plus your SOPs | SOP updates and short sessions | Guides and role training | Guides, runbook and role training |
| Ongoing changes | Vendor roadmap, change requests | Administrator time | Developer time | Developer team time |
| Internal staff time | Administrator, super users | Administrator | Product owner, administrator | Product owner, developers |
| Exit cost | Data export, contract terms | None | Retire the extension | Replace or rewrite |
Three lines are easy to leave out: internal staff time, testing on every core update and the exit cost. Estimate all three explicitly. They grow with every interface you add, whichever option you choose, and none of them appears on a license quote or a build estimate.
Reading a crossover
When two options cross inside your five-year window, the decision depends on the horizon you believe. If you expect to replace the core within three years, the option that is cheaper early wins. If the core will stay for a decade, look at run cost per year, not the total at year five.
Also test the sensitivity of each total to its biggest assumption. For a package, that is usually the renewal price and the user count. For an extension or a build, it is usually the hours of change work per year.
Running the decision: a step-by-step procedure
A gap decision for one process can usually be run in a few weeks by a small group: the process owner, an IT lead, a finance partner and two people who do the work. The steps below keep the decision on paper, where it can be checked.
- Write the gap as numbered requirements. Each one is a single testable statement with an acceptance test. Our field note on writing logistics software requirements your team can test shows the format.
- Sort and challenge them. Mark each must, should or nice. For each must, write down the business reason. Anything without one becomes a should.
- Check what you own. Review release notes, licensed modules and configuration tools against the must-haves. Record which ones configuration meets.
- Test packages against the rest. Shortlist two or three products for the remaining musts. Ask each vendor to run your scenarios on your sample data.
- Draw the interfaces per option. For each option, list every interface with its direction, trigger, data, method and owner.
- Assign the system of record. For each data element the process touches, name the one system that holds the record.
- Model five-year cost. Use the same categories for every option, including internal time and testing per core update.
- Score, decide and write it down. Record the scores, the decision, the assumptions and the events that would reopen it.
The decision record
The decision record is the easiest step to skip, and the one that saves the most argument later. It is one page with five headings: the gap, the options considered, the scores, the choice with its reasons, and the review triggers.
Review triggers are specific events. Examples: the core vendor releases the missing feature, volumes double, the developer who maintains the extension leaves, or the package’s renewal price rises past a set point. When a trigger fires, the decision is reopened on purpose rather than by complaint.
A worked scoring example
This example applies the six criteria and the cost model to one gap. The company, numbers and scores are invented, and a different operation could reach a different answer with the same method.
Example (fictional). A regional 3PL runs one WMS across two warehouses for 14 clients. Clients email for stock positions by lot and expiry, and customer service answers by exporting WMS screens to spreadsheets. The gap: a client-facing inventory and order-status view, by owner, lot and expiry, with ASN and shipment status.
The team writes 11 must-have requirements. Configuration of the WMS’s own client portal meets 6: stock by item, open orders, shipped orders, a login per client, export to file, and a printable stock report. It misses lot and expiry by owner, ASN status, carrier tracking events, per-client branding required in two contracts, and refresh within 15 minutes.
Two client-portal packages meet 10 of 11, but each keeps its own copy of inventory balances, refreshed by file every hour. An extension that reads the WMS through its API and stores carrier events in its own database meets all 11. A full custom WMS replacement is listed for completeness and rejected at step 2, because the WMS meets every warehouse-floor requirement.
The team weights the six criteria and scores each option from 1 (poor) to 5 (strong). The weights reflect this company’s situation: it has two in-house developers, and client data separation is a contract term.
| Criterion | Weight | Configure | Buy portal package | Extend | Build new WMS |
|---|---|---|---|---|---|
| Fit to the must-haves (from differentiation) | 3 | 2 | 4 | 5 | 5 |
| Upgrade path | 2 | 5 | 4 | 3 | 2 |
| Number of integrations | 2 | 5 | 3 | 3 | 1 |
| Data ownership | 2 | 5 | 2 | 4 | 5 |
| Team to maintain it | 2 | 5 | 4 | 3 | 1 |
| Five-year cost | 3 | 5 | 3 | 3 | 1 |
| Weighted total (out of 70) | 61 | 47 | 50 | 36 |
Configuration scores highest, yet it fails 5 of 11 must-haves, so it cannot be the whole answer. The real choice is between the package (47) and the extension (50), with configuration doing the 6 requirements it can.
The five-year costs in the chart above are close: 160 cost units for the package and 155 for the extension. The scores split on data ownership, because the package keeps a second copy of balances refreshed hourly, and on the 15-minute refresh requirement that two client contracts include. The team chooses configuration plus an extension, and writes one review trigger: if the WMS vendor ships lot-level client visibility, retire the extension.
A different 3PL, with no developers and no contractual refresh requirement, would score it differently. It would weight the team criterion at 3 and score the extension 2 on it. It would also drop the refresh requirement to a should, so the package meets every must-have and scores 5 on fit. With those changes, the package scores 54 out of 75 and the extension 50. That is the honest result of the method: the criteria are fixed, but the weights belong to you.
What the example does not show
Scores invite false precision. A weighted total of 50 against 47 is not proof; it is a summary of judgments that the team should be able to defend line by line. If one score changes the answer, investigate that score before you sign anything.
What happens after the decision
The decision is the start of a project, not the end of one. Whichever option wins, the same disciplines decide whether it works: requirements with acceptance tests, a tested cutover, documentation and trained people.
The pattern in the research
Research on ERP adopters points the same way. Markus, Axline, Petrie and Tanis found that “the success of ERP systems depends on when it is measured”, and that “many of the problems experienced in later phases originated earlier but remained unnoticed or uncorrected” (Journal of Information Technology, 2000). A buy, extend or build decision made without written requirements carries its problems forward into the build and the go-live.
What each option still needs
- Buy: interface specifications, data conversion, SOPs rewritten for the package’s screens, and role-based training.
- Configure: a record of every setting changed and why, updated SOPs, and a short retraining for the affected roles.
- Extend: an interface runbook, a regression test set for core updates, and an owner for the extension.
- Build: all of the above, plus source code and configuration delivered with documentation that a new developer can follow.
In our engagements we start with the requirements and end with documentation and a trained team, whichever option the client chooses. The six stages of how we work and the engagement types describe that sequence, including a fixed-scope first phase whose documents you can take to any vendor.
What to do next
Start with the cheapest evidence you can collect this month. You can complete the first four items below without any vendor conversation.
- Write the gap as numbered requirements, each with an acceptance test.
- Mark each requirement must, should or nice, and write the business reason for every must.
- Check your current ERP or WMS for licensed modules, release-note features and configuration options that meet the musts.
- List every interface each option would need, with direction, trigger, data, method and owner.
- Name the system of record for each data element the process touches.
- Build a five-year cost model with identical categories for every option, including internal time.
- Ask two or three vendors to run your scenarios on your data.
- Score the options, choose, and write a one-page decision record with review triggers.
If the answer is extending around your core, our inventory management software page describes what that layer usually holds. If you want the requirements and cost model written with you, requirements analysis is the place to start, and it is useful whether you end up buying, configuring, extending or building. For a related decision about tracking platforms, see the field note on buying, building or extending shipment visibility.
