Cycle Count Variance Reconciliation in IFS Cloud
Independent IFS Cloud practice · Expert notes Cycle count variance reconciliation in IFS Cloud: the matching mechanics, why one threshold is always wrong, and…
Read moreIndependent IFS Cloud practice · Expert notes Cycle count variance reconciliation in IFS Cloud: the matching mechanics, why one threshold is always wrong, and…
Read moreIndependent IFS Cloud practice · Sales The order you confirmed, and the change nobody re-promised You confirmed the order to the customer: this quantity, this…
Read moreIndependent IFS Cloud practice · Sales The delivery date you promised that the plan cannot keep A promised date is a calculation dressed up as a commitment. At…
Read moreIndependent IFS Cloud practice · Field notes Data migration silent killers: the FndMig and DMM failures that never throw an error, and only surface weeks after…
Read moreIndependent IFS Cloud practice · Expert notes Duplicate supplier invoice detection in IFS Cloud: why exact match misses most real duplicates, and how to design…
Read moreIndependent IFS Cloud practice · Extensibility & Upgrades Silent custom code failure in IFS Cloud: the technical anatomy, and how to actually find it A PL/SQL…
Read moreIndependent IFS Cloud practice · Supply Chain The order you shipped for nothing, because the price line was zero The customer order looked complete. It had a…
Read moreERP Advisory & Strategy When Does an Independent IFS Consultant Really Add Value? Sometimes the most valuable person on an ERP project is the one who isn’t…
Read moreIndependent IFS Cloud practice · Upgrade readiness IFS Cloud upgrade readiness: a 10-point checklist before your next release Key takeaways An IFS Cloud…
Read more
Independent IFS Cloud practice · Implementation
Key takeaways
Most articles about ERP business impact are written from the brochure. This one is written from the projects. I have spent seventeen years inside IFS, from Apps 7.5 through Cloud, and the pattern that repeats is not that companies pick the wrong system. They pick a capable one and then implement it in a way that throws the capability away: a template nobody reuses, an automation layer nobody trusts, reports rebuilt one for one from the old system because nobody had the authority to delete any of them.
So this is not a list of what IFS Cloud can do. It is a walk through the places where a decision taken during implementation determines whether the platform pays for itself or just replaces one kind of manual work with another. Where a topic deserves its own treatment, I have linked to the longer piece on the ifs-erp.com blog rather than compressing it into two sentences here.
Grouping sites so they share parts, defaults and process setup is sold as a speed feature. It is really a consistency feature, and the speed is a side effect. When site four inherits the purchasing parameters that sites one to three already run on, you are not just saving a week of configuration. You are removing the possibility that site four quietly does receiving differently, which is what costs you two years later when someone tries to compare performance across the group and finds the numbers are not measuring the same event.
The catch is that a cluster only helps if the template being cloned is one somebody defended. Rolling out a bad standard quickly is worse than rolling it out slowly, because a slow rollout at least gives each site a chance to object. I ask for the template to be signed off by the person who will own the process across all sites, not by the site that happened to go first. That is also where the multi-site purchasing decisions belong: whether demand consolidates centrally, and how stock moves between sites once it has.
Further reading: centralised purchasing in IFS Cloud, distribution orders between sites, and from planning to go-live.
IFS Cloud gives you three tools that cover most of what people used to write code for, and knowing which one to reach for is the whole skill. A Quick Report reads data out: a saved query for a list or an extract, with no logic. A Custom Field stores something the standard data model does not. A Custom Event reacts when a row changes, and can hand off to a Workflow that routes an approval, sends a notification, or calls out to another system.
The failure mode is predictable. Teams discover Custom Events, like them, and attach one to everything. Six months later there is an event layer nobody can explain, firing on saves that were never meant to be significant, and the business has learned to ignore the notifications it produces. The second failure mode is subtler: reaching for a Custom Event when the requirement is actually a scheduled check. An event fires when a row changes. It cannot fire because a row has not changed, which is exactly what an unconfirmed order or an untouched receipt is.
Where the requirement crosses a system boundary, the answer is usually an interface rather than an in-system automation. IFS Cloud's OData projections are the normal integration surface, and keeping the orchestration outside IFS keeps that logic out of your ERP, where it would otherwise become one more thing to retest at every release.
Further reading: Custom Events explained, Quick Reports vs Custom Fields vs Custom Events, IFS Cloud API integration, orchestrating IFS Cloud with n8n. Work that has already been built once sits in the configurations and interfaces sections of the marketplace.
IFS Cloud ships R1 and R2 every year. That cadence is the biggest single change in how you should think about customisation, and it is where legacy habits do the most damage. On Apps 9 or 10 an upgrade was an event you prepared for over months, so carrying technical debt between them felt survivable. On Cloud it arrives twice a year, and anything built outside the Extensibility Framework has to be checked, and often reworked, on that same rhythm.
The boundary is simple to state and easy to cross by accident. Extending the data model with Custom Fields, adding logic through Custom Events and Workflows, adapting screens through configuration: all inside the contract, all carried forward. Touching a core object, or building a report or an interface directly against an internal view rather than a published projection, puts you outside it. Nothing stops you at the time. The bill arrives at the next release, and at every release after that.
I have watched this go wrong in both directions. Companies that refuse all extension end up with a shadow layer of spreadsheets doing the work the system was not allowed to do, which is worse, because at least a customisation is visible. The honest position is that some extension is necessary, and the only real question is whether it is built where the platform will maintain it for you.
Further reading: update-safe extensions, the true cost of customisation, clean core in an SCM context, the upgrade tax, the upgrade readiness checklist, and what a release actually brings, with 25R2 purchasing as the worked example. Scoped modification work is listed under marketplace modifications.
Ask a buyer what goes wrong and you get something dramatic: a late shipment, a line stopped for a missing part. Look in the data and the costly problems are the undramatic ones, because nothing in the system objects to them.
| What is sitting there | Why nobody sees it | What it turns into |
|---|---|---|
| A released PO the supplier never acknowledged | The order is valid and open. No field says "ignored" | A delivery date everyone planned around that was never agreed |
| Goods received, invoice never matched | Both records are individually correct | An accrual that grows quietly until period end |
| A supplier price that moved between orders | The new price applies cleanly, exactly as configured | Margin erosion found during an annual review |
| A buyer who stopped ordering from a usual source | Every individual order is legitimate | Concentration risk, or a supplier problem nobody escalated |
All of this is detectable, and all of it is readable through standard OData projections on a read-only account. That means a monitor can look for it daily without touching a record, installing an object, or adding anything the next release has to be checked against. It is the design principle behind the SCM Automation Pack, and the reason the five-day exception scan exists as a way to see what is already in your own data before committing to anything ongoing.
On the physical side the same principle applies to warehouse work. Picking strategy and packing proposals are configuration decisions that quietly set your throughput ceiling, and they are rarely revisited after go-live.
Further reading: unconfirmed purchase orders, what unmatched receipts do at period end, supplier price changes, advanced picking strategies, the packing proposal.
Anomaly detection, demand forecasting and predictive maintenance are genuinely useful, and they all rest on the same unglamorous foundation: whether your master data is good enough for a model to learn from. A forecast built on lead times copied out of the legacy system in 2019 and never reviewed will be precise, confident and wrong, and it will be harder to challenge than a human guess because it arrives with a number attached.
The second thing the demo leaves out is what happens to the output. Detection is the easy half. The half that decides whether any of it pays off is routing: who receives the signal, how it reaches them, and what happens when they do nothing. An alert stream with no named owner and no escalation is a mailing list, and people unsubscribe from mailing lists in their heads long before they do it in the client.
That is why I design exception rules around the recipient rather than the condition. One deduplicated digest per owner per day beats forty individual notifications that are each technically correct. And a rule that cannot state in one sentence what the recipient is supposed to do about it does not ship.
Further reading: alert fatigue and exception design, the cost of missed exceptions, detecting supplier behaviour change, the data attention gap, assumed vs confirmed records, read-only OData monitoring.
Crystal Reports layouts from Apps 9 and 10 do not carry across to IFS Cloud. That is the fact that matters for your plan, whatever any vendor's support calendar says, and it is usually discovered later than it should be, because reporting gets treated as a workstream that can start once the real configuration is done.
IFS Cloud splits the job across different tools. Quick Reports handle lists and extracts: saved queries, no layout ambition, self-service for anyone who can be trusted with a data set. Laid-out business documents are produced through IFS Cloud's own report layout tooling. Analysis and dashboards belong in the reporting and analytics layer rather than in a printed report at all. Trying to recreate a 200-item Crystal inventory inside any one of these is how reporting becomes the critical path.
The work that actually saves you time is triage, and it is a business job rather than a technical one. Pull the usage data first. Most report inventories contain a long tail nobody has run in two years, a middle band that exists because one person likes the format, and a small core the business genuinely runs on. Rebuild the core properly, convert the middle band to Quick Reports or a dashboard, retire the tail. The conversation about retiring the tail is the hard part, which is why it needs to start early and needs someone senior to close it.
Further reading: when a Quick Report is the right answer, and the reports section of the marketplace.
Permission sets in IFS Cloud are capable enough to express proper segregation of duties. Whether they end up doing so is decided in the first six weeks of the project, when someone is under time pressure and the fastest way to unblock testing is to grant a broad set to a group and move on. That grant is almost never revisited, because nothing breaks. It surfaces at the first external audit, when a tester asks who can both create a supplier and approve a payment to it, and the honest answer takes a fortnight to assemble.
Design the role model against the process rather than the org chart, and build it while the process design is still fresh in everyone's head. It costs days then and weeks later. The same applies to standards work: if you operate under ISO requirements, the evidence those audits want is largely a by-product of decisions you are already taking, provided you record them as you go instead of reconstructing them afterwards.
Further reading: RBAC and segregation of duties, permission sets in IFS Cloud, ISO standards in IFS Cloud, and the security section of the marketplace. My own view on the wider ownership question sits on the data governance page.
Every implementation plan has a migration workstream, and most are optimistic by the same margin. The reason is consistent: the effort is not in loading the data, it is in deciding what the data should say. Loading is mechanical. Agreeing that these 4,000 part records are the ones worth keeping, that this status code maps to that one, and that a customer with no valid tax ID is a customer you are not going to migrate, is a series of business decisions with no obvious owner.
Two habits change the outcome. Rehearse the load more than once, on a schedule, with a defined cut of source data each time, so the failure list shrinks between rehearsals instead of being discovered on cutover weekend. And treat validation as its own deliverable with its own sign-off rather than as the last step of loading, because IFS Cloud enforces its business rules at load time: well-formed source data can still be rejected for violating application logic nobody had read.
Further reading: the data migration checklist, how FNDMIG and the Data Migration Manager fit together, and the data migration section of the marketplace.
In most of the companies I work with, a large amount of operational knowledge lives in one person's head and one person's spreadsheet. The buyer who knows which supplier actually delivers on time regardless of what the lead time field says. The planner whose workbook reconciles two things the system does not reconcile. None of this shows up in an ERP assessment, and all of it walks out of the building when that person leaves.
An implementation is the one moment when you have a mandate to surface it. Every shadow spreadsheet is a documented requirement waiting to be read: it exists because the system does not do something, and finding out what that something is tells you more about your real process than a workshop will. Some of them should become configuration. Some should become a Quick Report. A few are genuinely someone's judgement and should stay human, but at least then you know where they are.
The same logic applies to the implementation record itself. Decisions taken in month two get questioned in month eleven by people who were not in the room, and a project that cannot answer "why is it set up this way" reopens settled arguments for the rest of its life.
Further reading: shadow spreadsheet risk, knowledge loss when people leave, buyer knowledge concentration, and the implementation documentation kit if you would rather not build the templates from scratch.
I am wary of quoting percentage improvements. Published ranges come from situations you cannot inspect, with baselines nobody defined, and a number borrowed from another company's business case is not evidence about yours. What I can offer is the short list of measures that survive contact with an actual steering committee.
Further reading: ERP ROI analysis, why go-live is a load test, the implementation crisis.
If you are live on IFS Cloud and this article has described your situation rather than your plan, the order that works is roughly this. Find out what is actually in your data before redesigning anything, because the exception population usually contradicts the received wisdom about where the problems are. Then fix the governance decisions that get harder with time: the role model, the report inventory, the ownership of master data. Automation comes after that, not before, because automating a process nobody owns only makes it produce wrong answers faster.
What I do is on the offer page, the platform view is on the IFS Cloud page, and the process side sits under business process optimisation. The applications themselves, including the read-only exception monitoring described in section 4, live on ifs-erp.com.
No, but the work changes shape. Before go-live it is a design decision that costs nothing extra. After go-live it is an inventory exercise: list everything built outside the Extensibility Framework, establish what each item actually does, and decide case by case whether to rebuild it inside the contract, replace it with standard functionality, or accept the maintenance cost knowingly. The last option is legitimate. What is not legitimate is not knowing which category each item falls into, which is the usual starting position.
No. In most projects I see, the unclaimed value sits in exceptions a plain query would find: orders nobody confirmed, receipts nobody invoiced, prices that moved. That is rule-based detection rather than machine learning, and it works on data that is merely adequate. Model-driven forecasting is worth doing once master data has an owner and a maintenance routine, and worth postponing until it does.
Yes, and that is the approach I prefer for anything that only needs to read. Standard OData projections plus an integration account with read permission are enough to detect the exception patterns in section 4. Nothing is installed in IFS, nothing is written back, and there is no object for the next R1 or R2 release to break. If you want to see the output before committing to anything ongoing, the five-day exception scan produces the same report in observation mode only.
Budget the triage, not the rebuild. Pulling usage statistics and getting a decision on what to retire takes longer than rebuilding the reports that survive, because it needs business sign-off rather than developer time. Start it in parallel with configuration rather than after it, and give the retire list an owner with the authority to say no. Teams that skip this step rebuild everything one for one and carry the whole inventory forward, including the part nobody has opened since 2019.
The configuration saving is small at that scale. The consistency saving is not, and it compounds: two sites configured independently will diverge on receiving, costing and reporting definitions within a couple of years, and reconciling them later is considerably more work than agreeing a shared template now. If there is any prospect of a fourth site, an acquisition, or a group-level report, treat it as worth it.
Dariusz Myśliwiec: 25+ years in ERP and supply chain, 17+ on IFS (Apps 7.5–10 and IFS Cloud). IFS Certified Associate Consultant. PRINCE2® 7. Based in Kraków, delivering remotely across Europe and globally through an independent practice.
Selected clients: Fugro · LGC · BVI Medical · Betafence (PRÆSIDIAD) · Barlinek · NGK Ceramics · Newag · Oleofarm.
IFS is a registered trademark of IFS AB; this practice is not affiliated with IFS AB.
If you are scoping an IFS Cloud implementation, or you are already live and suspect the value case has quietly gone missing, a short call is the fastest way to work out which two or three of the eleven sections above are actually costing you something.
Independent IFS Cloud practice · Upgrade readiness
Key takeaways
IFS Cloud moves forward on a fixed cadence, and each R1/R2 release can change the ground your customisations stand on. Teams that treat the upgrade as an event to be managed sail through it. Teams that treat it as something that happens to them pay the upgrade tax: broken flows, emergency hotfixes, a go-live that slips a fortnight. The difference is preparation. This checklist is the ten points to clear before you schedule the next release, so nothing on the far side surprises you.
Because the expensive part of an IFS Cloud upgrade is not the upgrade itself. It is discovering, in the new version, what you should have found beforehand. The IFS Cloud upgrade tax is paid almost entirely in things that were knowable in advance: an extension nobody realised reached into modified core, a report built on a view that changed, an integration wired to an interface IFS never promised to keep.
A checklist converts that risk into a to-do list. Each point below is something you can inspect, decide on and sign off before the release is booked, while you still have time and before the deadline forces rushed decisions.
Work these ten points in order and the pattern is clear: the first two find the risk, the middle six remove it, the last two make sure someone owns the outcome.
The same three points catch most teams, every release. Knowing them in advance is half the battle.
| Blind spot | Why it bites | Checklist point |
|---|---|---|
| Reports on volatile views | A restructured view returns wrong data or errors, and nobody notices until a decision is made on it | Point 4 |
| Silent RBAC drift | New or reshaped permission sets widen access, breaking Segregation of Duties without any error | Point 5 |
| Integration contracts | An interface wired to an internal API stops exchanging messages; the queue backs up unseen | Point 6 |
RBAC drift is the quietest of the three, because it throws no error. Access simply widens. If your SoD model matters for audit or compliance, treat the upgrade as a moment to re-prove it. The mechanics are covered in Permission Sets and Segregation of Duties in IFS Cloud.
A checklist you run once is useful. A checklist you never need to run is better. The durable fix is to stop generating upgrade risk in the first place: keep every extension inside the supported framework so there is nothing on the far side of the line to break.
That is the Clean Core discipline: the same one behind IFS Cloud Clean Core. Apply it to everything you build and the checklist shrinks to a re-validation, release after release.
Before the release is booked, not after. The first two points, inventory and risk classification, take real calendar time, and everything else depends on them. Starting early means remediation and a proper dry run happen without deadline pressure, which is where rushed upgrades go wrong.
Reports on volatile views and silent RBAC drift. Both fail without throwing an obvious error. A report returns wrong data, or access quietly widens and breaks Segregation of Duties. Because there is no error to chase, they are often discovered only after a decision or an audit depends on them.
Yes. A rollback plan is cheap insurance you write once and hope never to use. It defines your backup points, cut-over window and the exact trigger to stop and revert. Without it, a failed validation turns into an unplanned outage while people improvise under pressure.
You can run it yourself if you have a clear view of every extension and how it is built. If that inventory is fuzzy, or nobody owns the older customisations, the Update-Safe Audit does points one and two for you in 10 business days, classifying each extension Safe / Refactor / Rewrite / Retire with a fixed-price roadmap.
Dariusz Myśliwiec: 25+ years in ERP and supply chain, 17+ on IFS (Apps 7.5–10 and IFS Cloud). IFS Certified Associate Consultant. PRINCE2® 7. Based in Kraków, delivering remotely across Europe and globally through an independent practice. You talk to the consultant who does the work, not a sales layer.
Selected clients: Fugro · LGC · BVI Medical · Betafence (PRÆSIDIAD) · Barlinek · NGK Ceramics · Newag · Oleofarm.
IFS is a registered trademark of IFS AB; this practice is not affiliated with IFS AB.
The first two points of this checklist are the ones that matter most. They are also the ones teams skip. The Update-Safe Audit does them for you in 10 business days: every extension classified, a fixed-price roadmap, and the fee credited against the fix.
Consultants promising a «vanilla» IFS Cloud implementation are either lying or don’t understand your business. A system completely devoid of modifications is a business prosthesis, not a competitive engine. By the time you hit your first mandatory service update, that promise of simplicity will turn into a financial nightmare.
The issue isn’t the existence of extensions; it is the lack of architectural control. IFS Cloud 25R2 and beyond demand a clean separation between your unique business logic and the core system. If your CRIMS are welded directly into the standard code, every update becomes a high-risk surgery instead of a routine maintenance task.
Following «standard» blindly kills the very agility you paid for. You chose a cloud ERP to be faster, not to be constrained by a generic template that fits your competitors just as well as it fits you. When you ignore the need for proper extensions, you aren’t saving money — you are deferring debt.
Stop fighting the system’s nature. Use Workflows and projections where they actually generate profit. Your goal is not a pristine, untouched system; it is a resilient one. You need an environment that can be updated over a weekend, not a six-month migration project every year.
An ERP implementation is a surgical operation on a living organization. A poorly written workflow acts like an arterial blockage. Either you master the architecture, or the technical debt will eventually dictate your budget.
Clean Core doesn’t mean «no extensions.» It means «no legacy baggage.» It is the difference between a system that grows with you and one that holds you back.
If your current implementation feels like a straightjacket, your architecture is broken. We build extensions that survive updates and workflows that actually work. Don’t let a «vanilla» promise destroy your ROI.
Verify if your current IFS Cloud setup is ready for the next release cycle before the update window closes.
January 2026 | IFS-ERP.Consulting
Most ERP programmes celebrate go-live like it’s the finish line. The steering committee pops the champagne, the System Integrator closes their tickets, and the project is marked «Green.» In reality, you haven’t finished the job. You have just handed over the risk.
Over the last few weeks, we’ve spoken to organisations that have invested $10m to $100m+ in ERP platforms and are now quietly battling a different problem:
Their people don’t want to use the system. Not because the technology failed, but because adoption was treated as an event, not a strategy.
For IT Directors and CIOs, this is critical. The system is technically stable. The uptime is 99.9%. But business value is flatlining.
If your ERP is live but value isn’t, the work isn’t finished, it’s just starting. Here is how we turn ERP programmes around.
Shift from «System Implementation» to Enterprise Behaviour Change. When you frame it as a technical upgrade, you get technical engagement. When you frame it as an operational shift, you get executive buy-in.
In an Evergreen environment like IFS Cloud (R1/R2 releases), governance must be perpetual. Assign a Product Owner whose KPI is User Adoption, not just system stability.
Low adoption is a commercial risk, not an HR issue. Track metrics like «Percentage of POs created via automation» and report them to the Board alongside uptime.
Shift your training budget. Reserve 40% for months 2 to 6. Learning sticks when users are facing real scenarios, not during UAT in a sandbox.
If you are looking at your post-go-live landscape and seeing frustration instead of flow, it is time to stop patching the software and start patching the strategy.
Curious how other IFS customers are tackling post-go-live adoption? Let’s compare notes.
Schedule a Strategy Call
Centralized purchasing separates the transactional flow (ordering) from the physical flow (delivery):
Key Benefit: No internal inventory transactions are required between the demand site and the ordering site, as receipt and arrival registration occur at the demand site.
To implement centralized purchasing effectively, enforce the following data consistency rules:
All sites must use identical:
Failure to standardize: Leads to order errors, delayed deliveries, and increased operational costs.
Configure site-level rules to define interactions between central and local entities:
The transition from local requisition to central order can be automated or manual:
Receipt and arrival registration are handled entirely by demand sites:
Inconsistent part data across sites can disrupt centralized purchasing. Mitigate risks by:
Before go-live, test the following scenarios:
Use this checklist to ensure a successful centralized purchasing implementation:
Measure the success of your centralized purchasing implementation with these KPIs:
A centralized order retrieves price-related information from either the Purchasing Site (PO Header) or the Demand Site (PO Line). This depends entirely on your specific configuration preferences for pricing logic.
No. One of the key benefits of this model is that receipt and arrival registration occur directly at the demand site, effectively eliminating the need for complex internal inventory transactions.
The system is designed for safety; the «Central Order» option will not enable automatically if data is missing. However, buyers can intervene by manually selecting the option and specifying the necessary part pricing and site details.
Yes, this is a strict prerequisite. For seamless processing, parts must share the same Part Number, Unit of Measure (UoM), and conversion factors across all participating sites.
Data Mesh architecture facilitates real-time data synchronization across decentralized locations. This ensures consistency (e.g., matching part numbers) and significantly reduces errors inherent in multi-site procurement strategies.
Calculate your return on investment