The benefit is real; otherwise, I would have moved on to something more meaningful. However, this promise isn’t so straightforward.

Most ECM ROI models are overly optimistic and lack objectivity.
It’s not always intentional, though. But they are systematically so. They persistently misrepresent the facts. Often, they are politically motivated. After all, this is business.

As a vendor-free ECM consultant, I will try to take an objective look at it.

The myth of measurable value

ECM vendors and internal champions love spreadsheets.
They’re full of neat formulas like:

• Save 5 minutes per document
• Process 20,000 documents per year
• Average employee cost: 75 CHF/hour

Result: 125000 CHF annual saving.

Looks solid, right?

But it’s not!

The problem

This model assumes that time savings are perfectly converted into productive output, that organizational friction magically disappears, and that users actually change their behavior.

In reality, things are more nuanced. Saved time becomes micro-idle time rather than reinvested capacity. Users continue to work around the system, and the complexity simply shifts elsewhere instead of disappearing.

If your ECM project “saves time,” ask yourself: where exactly does that time go?

If you cannot demonstrate a real reduction in costs or an increased throughput, then your ROI is theoretical.

Fake precision

ROI models often disguise assumptions as facts.

Typical inputs:

• “Average handling time before ECM”: estimated
• “Handling time after ECM”: projected
• “Error rate reduction”: assumed
• “Adoption rate”: overestimated

These are not actual measurements, but rather assumptions (sometimes bordering on wishful thinking) that are expressed as numbers.

When you multiply uncertain assumptions together, you don’t get accuracy, you get amplified uncertainty.

Yet the final number is presented with:

• Two decimal places
• A confident tone
• A fancy PowerPoint slide

This creates the illusion of rigor.
However, it’s still just guesswork in a better format.

The political nature of ROI

That’s where things get complicated.

The return on investment for ECM projects often doesn’t reflect reality.

The main goal is to convince decision-makers.

Who needs ROI?

• Project sponsors → need funding
• Vendors → need deals
• Consultants → need positive vibes (Yep, I don’t want to work with customers who don’t recognize the value I bring.)
• Managers → need justification

So what? the ROI model becomes a political artifact:

• Inflated enough to pass governance
• Flexible enough to survive scrutiny
• Vague enough to avoid accountability

No one says:

“We don’t really know the value, but we think it’s worth doing.”

Instead, they say:

“This project will deliver €2.4M in savings over 3 years.”

Everyone knows it’s lax. But (very) few people are willing to question it.

Misleading indicators (that seem convincing)

Let’s look at the usual suspects.

Time saved

Most overused metric in ECM.

• Highly variable
• Rarely measurable at scale
• Almost never translated into realized financial gain

The truth is that saving time and saving money are not the same thing.

User satisfaction

It often increases temporarily, mainly due to the initial gains associated with novelty. Then, it declines as complexity sets in.

It is difficult to establish a link to business results.

Satisfied users alone do not justify platforms that cost millions!

Documents Processed Faster

It sounds powerful, but is it really challenging? Does faster generation actually generate more revenue? Is there a bottleneck at this stage?

Just because you do things faster doesn’t mean you’re creating value!

The real economic impact

The question to ask is: Which economic variable is actually changing?

Real ROI should come from:

• Avoid hiring and even reduce headcount.
• Increased transaction volume
• Shorter revenue cycles
• Lower regulatory penalties (measured, not hypothetical)
• Reduced external costs (printing, storage, outsourcing)

If your ECM project doesn’t impact at least one of these directly, your ROI is likely cosmetic.

Why the “lie” persists

If the flaws are so obvious, why does this narrative persist?

Because it delivers, at least in the ways that matter internally. It secures budget approval, aligns stakeholders around a common narrative, and provides a simple, reassuring story.

To be fair, many ECM projects do create value, just not in a way that can be easily captured in a spreadsheet.
Thus, the industry quietly sustains a shared illusion. It’s a cycle where belief matters more than proof and ROI becomes a tool for getting things done rather than a measure of value.

What to do instead?

Don’t get me wrong, ECM is one of the most important business applications.

The problem lies in how the project is presented, which seems dishonest to me.

As soon as human beings are involved, we can no longer rely solely on mathematical formulas. Consequently, ROI calculations are theoretical and idealized.

Nevertheless, the benefits are very real. Rather than claiming users will save five minutes per document, it’s better to state that the approval process has sped up by 20 or 30 percent and that the follow-up system is now automatic and systematic rather than dependent on an employee’s availability for that task.

Just because not everything can be monetized doesn’t mean we aren’t delivering operational value. ECM goals are to improve and simplify daily work or add strategic features.

Instead of hiding your assumptions, list them explicitly and present various possible scenarios based on confidence levels.

To avoid surprises after implementation, we must ask the tough questions.

• What will happen if the adoption rate isn’t as high as expected?
• Will this project reduce costs, or will they simply be shifted elsewhere?
• Who is responsible for delivering this value?

Ultimately, an ECM project is never just a financial equation. At dbi services, we refuse to reduce a project’s value to an artificial or approximate ROI. We focus on the real values that ECM delivers on a daily basis: human, operational, and strategic. These values are realized long before the attractive but often misleading numbers. Our goal is not to promise theoretical savings, but to tangibly transform the way teams work, collaborate, and make decisions.

L’article The ROI mirage in ECM projects est apparu en premier sur dbi Blog.

Let’s set the record straight, your users don’t hate enterprise content management (ECM).

They hate your ECM!

That might sound harsh, but have you ever heard complaints like these?

• “It’s too slow.”
• “I can’t find anything.”
• “It’s easier to keep files on my desktop,”
• “Why do I need 12 clicks just to upload a document?”

… then you’re not dealing with a technology problem. You’re dealing with an implementation problem rooted in ignoring users.

This blog takes a user-centric approach to explore why ECM initiatives fail and how to address the issue.

The Myth: Users resist change

One of the most persistent myths about ECM projects is that users resist change.

In reality, however, users resist friction, not change.

Think about it:
People adopt complex apps like Excel and SAP, as well as dynamic tools like Monday.

They learn new systems all the time when those systems help them do their job better.

So, when users resist on ECM, it’s not because they’re stubborn.

It’s because the system makes their work harder, not easier.

 Where ECM implementations go wrong

Let’s break down the most common failure patterns.

Designing for governance, not for humans

Many ECM systems are designed top-down:

• Compliance requirements first
• Retention rules
• Folder structures
• Security models

But where’s the user?

When governance becomes the primary design driver, you end up with:

• Deep, confusing hierarchies
• Mandatory metadata users don’t understand
• Rigid processes that don’t match real workflows

Result: Users either bypass the system or use it incorrectly.

“Just One More Mandatory Field…”

Metadata is essential. However, overengineering it is a common mistake.

You’ve seen this before:

• 15+ required metadata fields
• Drop-downs with cryptic business terms
• Fields that don’t apply to 80% of use cases

From the user’s perspective: “I just want to save the document! Why is this so complicated?”

Result:

• Poor data quality (users rush through fields)
• Shadow IT (files stored elsewhere)
• Low adoption

Ignoring real workflows

Many ECM projects are designed based on how processes should work rather than how they actually work.

But users operate in a messy reality:

• Emails drive decisions
• Documents evolve across multiple versions
• Exceptions happen

If your ECM forces users into a rigid “happy path,” they will:

• Work outside the system
• Duplicate content
• Lose trust in the platform

Result: ECM becomes an archive, not a working tool.

Poor search experience

Let’s be honest, if users can’t find documents quickly, the system is already broken.

Common issues:

• Inconsistent metadata
• Weak full-text search
• No relevance ranking
• No personalization

Users compare your ECM search to Google. That’s the “Standard”.

Result:

• “I know it’s somewhere, but I’ll just recreate it.”
• Massive inefficiency

Training vs. adoption

Many organizations rely heavily on training:

• Workshops
• User manuals
• Recorded sessions

But here’s the truth: If your system requires heavy training, it’s already too complex.

Good User Experience reduces the need for training.
Bad User Experience makes training necessary.

The real problem: lack of User-Centric design

At their core, failed ECM implementations share one trait.

They optimize for the system, not the people using it.

User-centric design means:

• Understanding daily tasks
• Reducing cognitive load
• Supporting real workflows
• Minimizing friction

Without this, even the best ECM platform (M-Files, Alfresco, OpenText, etc.) will fail.

What User-Centric ECM looks like

Now let’s flip the script.

Start with user jobs, not features

Instead of asking: “What features do we need?”

Ask: “What are users trying to accomplish?”

Examples:

• Close a customer case quickly
• Prepare a contract
• Find the latest version of a document

Design around these outcomes!

Make Metadata Invisible

The best ECM systems don’t feel like ECM systems.

There are several strategies to achieve this objective: auto-classification, context-based default values, and AI-based suggestions.

The goal is to reduce the need for typing and increase relevance.

Design for the 80% case

No matter what kind of business you’re in, there will always be special cases. It’s pointless to spend hours or days coming up with hypothetical exceptions.

Instead focus on:

• The most common user journeys
• The simplest possible interaction paths

Keep the complexity behind the scenes, not in the UI.

Build search as a First-class experience

Search is not just a feature, it’s the primary interface for many users.

Invest in it.

• Clean metadata models
• Relevance tuning
• Filters that make sense
• Fast performance

If users trust search, they’ll trust the system.

Integrate into daily tools

On average, a user working with documents uses 10 tools per day, such as Outlook, Teams, Word, ERP, and business applications. Adding another tool for content management would be cumbersome.

Users want ECM integrated into their existing tools. This is one of M-Files’ major advantages. The best ECM is the one we can’t see.

Mindset shift

The real shift is simple yet powerful. Instead of asking, “How do we get users to adopt ECM?” ask, “How do we make ECM worth adopting?” This change in perspective redefines everything.

As I already wrote it in another post, ECM failure is rarely about the technology itself, it’s about empathy.

When systems are designed without a deep understanding of how people actually work, the result isn’t just some mild resistance, it’s outright rejection.

However, when you align ECM with real user behavior and needs, adoption becomes natural, data quality improves organically, and the system’s value becomes apparent.

So, the next time users complain about your ECM, don’t blame them. Look closely at how it was implemented.

L’article Your users don’t hate ECM, they hate how you implemented it. est apparu en premier sur dbi Blog.

This article is not intended to be a sales pitch. Its primary objective is to ascertain the elements that genuinely deliver value in today’s market, despite the prevalent marketing hype.

What actually works

Intelligent classification

AI-based classification is one of the most mature and valuable use cases in ECM today.
Instead of relying purely on manual metadata tagging or rigid rules, AI models can:

• Automatically classify documents based on content
• Suggest metadata
• Route documents to appropriate processes

The following are some scenarios in which this approach is particularly relevant:

• Invoice processing
• Contract categorization
• HR document
• High-volume document ingestion scenarios

Why it works:

• The problem is clearly defined, and its classification is a bounded task.
• Training data is typically available, as documents are already stored in the Enterprise Content Management (ECM) system.
• It is not necessary for models to be perfect; their primary function is to reduce manual effort.

However, it is important to note that certain prerequisites are necessary for this process to be successful. A clean taxonomy is essential for effective labeling.
The training data has been properly labeled.
We are committed to ongoing tuning to ensure optimal performance.

AI won’t fix a messy repository, but it can supercharge a structured one.

Search that actually finds things

Search is another area where AI is delivering real, tangible improvements.
Modern AI-enhanced search can:

• Understand natural language queries
• Rank documents based on relevance (not just keywords)
• Extract meaning from unstructured content
• Surface related information

What has improved with this new system compared to traditional ECM search?

• Semantic understanding (not just full-text search)
• Better ranking models
• Context-aware results

For instance, a simple example would be, instead of, searching for: “contract termination clause vendor”. It would be more natural to ask, “What are the termination conditions in the supplier agreement?”

The fundamental reason for its efficacy is that search is probabilistic, meaning perfection is not necessary. Users are willing to accept “almost right” results if they can find what they need faster. Modern LLMs and vector search have significantly enhanced the relevance of results.

This is one of the few areas where users immediately feel the difference.

Content summarization & extraction

This is the benefit many organizations didn’t expect to succeed so fast.

AI can facilitate the summarization of extensive documents, the extraction of key purposes, and the identification of significant elements, including dates and stakeholders.

Typically it can be used in

• Legal contract review
• Compliance checks
• Audit preparation
• Knowledge management

What are the reasons for its popularity? In essence, it assists users without attempting to substitute for them. Even imperfect summaries can save time that can be spent on more important tasks. Users remain in control.

This is where AI becomes a productivity multiplier, not a decision-maker!

What doesn’t work (Yet)

Now, let’s talk about the uncomfortable truth.

Governance is not solved by AI

This is probably the biggest misconception in the market.
Vendors suggest AI can:

• Automatically enforce retention policies
• Identify sensitive data everywhere
• Ensure compliance with regulations

In reality, the issue of governance remains both a human and an organizational challenge, and AI faces difficulties because:

• Policies are often vague or inconsistent.
• Interpreting regulations is a complex process.
• It is crucial to understand that context plays a pivotal role in this matter, and it is evident that AI is not yet equipped with a comprehensive understanding of the business context.

AI requires clearly defined rules for successful operation, yet governance often lacks robust regulatory frameworks. If a governance model is flawed, artificial intelligence will exacerbate the chaos rather than rectifying it.

Ownership and responsibility are still undefined

Another area where marketing may overpromise:

“AI will manage your content lifecycle automatically.”

While this approach sounds promising, it is crucial to determine who will be accountable.

Who is responsible for validating the decisions made by these systems?
What about the potential errors in classification?
Who is responsible during audits?

Most organizations still struggle with essential elements for effective content management:

• Clear definition of content ownership
• Establishment of defined data stewardship roles
• In place accountability models

AI is not capable of replacing processes that lack clear definition. While the system is capable of making decisions, the question of responsibility remains, and thus far, a person must endorse that part. Who is ready to blind sign decisions made by a machine?

Fully autonomous ECM is a myth

The idea of a “self-managing ECM system” is appealing:

• Documents auto-classify
• Workflows auto-trigger
• Retention auto-enforced
• Compliance auto-validated

However, in practice, exceptions and outliers disrupt automation processes and require human intervention.
Business rules are subject to constant change.

Implementation failures can occur in various contexts, such as:

• Excessive automation from the outset
• A lack of controls and oversight
• Blind trust in the results provided by AI

The winning approach today is human-in-the-loop, not full automation.

The key takeaway from this analysis is straightforward: AI is not a standalone entity, it relies on established structures for its functionality. In an effective ECM environment with clear taxonomy, structured metadata, defined processes, and robust governance, AI can serve as a significant catalyst for improvement, enhancing efficiency, reducing manual effort, and improving the user experience. However, in a disorderly and inefficient system, it can lead to outcomes that are inconsistent, create confusion, and erode trust.

Practical advice

The successful integration of AI into ECM is not primarily a technical challenge, but rather, a matter of implementing a systematic approach.

Organizations that succeed in this regard are those that prioritize establishing strong foundations, including clean taxonomy, structured metadata, and clear governance.

They then introduce AI through targeted, high-value use cases such as classification, search, and summarization.

They ensure that humans are informed of developments, continuously refine outcomes, and maintain transparency regarding the capabilities and limitations of AI.

In the end, AI in ECM is not a revolution but an evolution. While it offers tangible benefits in situations where issues are clearly defined, it falls short in addressing more complex challenges such as governance and ownership. The distinction lies not in the sophistication of the AI, but rather in the maturity of the ECM environment that underpins it.

If you’d like to learn more about this topic, please don’t hesitate to contact us.

L’article ECM + AI: achieving optimal synergy est apparu en premier sur dbi Blog.

You become something different. Over time, I’ve come to think of it as operating within a “shadow team.”

This invisible layer changes how you navigate politics, truth, and influence.
Let’s unpack that.

The “Shadow Team” effect

As an employee, you’re clearly part of the organization.
However, when you’re an external consultant, it’s a different story.
You sit inside delivery teams while remaining outside the organization’s long-term structure. This dual positioning creates what I call a shadow team.

You collaborate closely with internal stakeholders, influence decisions without owning them, and observe dynamics that others are too immersed in to see.

You’re close enough to matter, yet distant enough to stay objective.
This reshapes everything.

Politics: Seeing the system without being trapped in it

Every organization has internal politics, including priorities, power structures, historical tensions, and unwritten rules. The larger the organization, the more politics there are.
Employees must live within that system.
Consultants, on the other hand, can often see the system more clearly because they aren’t fully bound by it.
This doesn’t mean you’re outside of politics, though.
It means:

You can identify misalignments more quickly, notice when decisions are driven by structure, not logic and spot friction between teams that others consider “normal.”

But here’s the key difference:

• You are less constrained by long-term consequences.
• An employee may avoid challenging a decision due to its potential impact on their career.
• However, a consultant can raise the concern because their role is to add clarity, not preserve equilibrium.
• Still, this doesn’t mean ignoring politics. It means navigating them consciously without being controlled by them.

Neutrality: Your most underrated asset

One of the most powerful—and most fragile—assets of being an external consultant lies in the neutrality that people attribute to you.

You are not:

• Competing for a promotion
• Defending a department
• Protecting past decisions

This creates a rare opportunity. You can become a trusted bridge between stakeholders

When done right, people will:

• Share concerns they wouldn’t voice internally
• Ask for your opinion as a “safe” perspective
• Use you to validate or challenge ideas

However, neutrality is not automatic, it must be earned and can easily be lost.
You lose it when:

• You align too strongly with one stakeholder
• You start defending internal logic instead of questioning it
• You behave like an insider too quickly

The best consultants maintain a delicate balance:

They are close enough to build trust and distant enough to stay credible.

Truth vs. Diplomacy: walking the tightrope

This is where the role becomes truly challenging.
As a consultant, you are often expected to:

• Tell the truth
• Challenge assumptions
• Highlight risks

However, you are also expected to:

• Maintain relationships
• Respect stakeholders
• Keep the project moving forward

These two expectations often conflict with each other.
The naive approach: “Just be brutally honest.”
This approach quickly fails. Brutality destroys trust.

The safe approach: “Say what people want to hear.”
This makes you irrelevant.

The real skill is delivering truth in a way that can be heard.
That means:

• Frame issues in terms of impact, not fault.
• Ask questions instead of making accusations.
• Adapt your message to your audience.

For example, rather than saying, “This process isn’t working at all”

A more measured approach might be: “I see a few risks associated with this process. Could we go over them together?”

The observation is the same.
However, the outcome is different.

What really changes

Being a consultant isn’t just about knowledge. It’s also about positioning. You have a clearer view, speak more freely, and connect across sides.

However, our profession is based on a paradox. We must be objective enough to provide sound advice, yet also be fully committed to the task at hand. Additionally, we must offer honest feedback without hurting the client’s feelings or losing their trust.

At dbi services, we’re passionate about striking that delicate balance, whether the subject is ECM or any other area of our expertise. Learn more about us here.

L’article What being an external consultant really changes est apparu en premier sur dbi Blog.

As I wrote earlier, an ECM implementation is different from other IT projects. It’s a living system!

For years, organizations have relied on the same familiar KPIs to measure success:

“We migrated one million documents.”

“Two hundred users successfully completed the training.”

And yet, users still can’t find what they need. Decisions are still slow to be made. Content is still seen as a burden rather than an asset.

It’s time to stop measuring ECM success this way.

The problem with traditional KPIs

Number of documents migrated

Migrating documents is a technical milestone, not a business outcome.
A repository full of poorly classified, duplicated, or outdated documents is not a success; it’s digital clutter on a large scale. Migration only answers the question, “Did we move data?” It completely ignores whether people can actually use it.

Even worse, focusing on volume often encourages lift-and-shift strategies that preserve old folder structures and bad habits, the very things that ECM is designed to address.

Number of trained users

Although training metrics can be reassuring, they measure exposure, not adoption.
Completing a training session does not necessarily mean that:

• Users have changed how they work.
• They trust the system.
• They stopped saving content locally or emailing attachments.

In many ECM projects, users are technically “trained” yet still bypass the system because it slows them down instead of helping them.

Why these metrics miss the point?

ECM isn’t just about storing documents. It’s about enabling better, faster, and safer work.

If your KPIs don’t reflect this, you may declare success while the business quietly disagrees.

So, what should we measure instead?

Measures that matter

Time-To-Find (TTF)

This is one of the most honest and revealing ECM KPIs.

In organizations that rely on folders:

• Users browse
• guess locations
• Open the wrong versions
• Ask colleagues, “Where is the latest file?”

With a metadata-driven ECM like M-Files, content is found by what it is, not where it’s stored.

Measuring Time to Find:

• Before ECM
• After going live
• And again after optimization.

This gives you a direct line from ECM value to daily productivity.
If users can’t find content faster, the ECM isn’t working, regardless of how many documents were migrated.

Decision speed

This KPI is even more powerful and strategic.

Decision speed is affected by:

• Content availability
• Version accuracy
• Context (related documents, metadata, and workflow state)
• Trust in information completeness

M Files accelerates decision-making by:

• Ensuring users always see the latest version
• Automatically surfacing related content
• Embedding documents directly into business processes
• Applying governance without slowing people down

When ECM is implemented effectively, decision cycles shorten. Approvals happen faster, issues are resolved sooner, and risks are identified earlier.
That’s real business impact.

Why M‑Files changes the KPI conversation

Traditional ECM systems force users to adapt to them. M-Files, however, adapts to the business.

M-Files is:

• Metadata-driven
• Process aware
• Contextual
• Automation ready

It enables KPIs centered around work outcomes, not IT activities.

Instead of asking:

“How much content did we store?”

You can ask:

• “How quickly do our teams find information?”
• “Where are decisions still slow, and why?”
• “Which processes would improve most with better information?”

A more effective approach to ECM success

Thinking differently isn’t that hard, and yet it makes a huge difference. You just need the courage to take a step back.

Instead of thinking about “How your documents are stored?”, ask yourself: “What information is available?”

“Are my users trained?” Or rather, “Do my users have the tools they need to take action?”

“Is the metadata understood?”, is more important than “How my folder structure is organized?”

The question isn’t whether I completed the migration, but whether it sped up the decision-making process.

To sum things up

If your ECM success story starts and ends with numbers like documents migrated or users trained, then you’re focusing on the effort rather than the actual impact. That’s a real shame because you’re missing the point of such a project.

Modern ECM success is about:

• Time saved
• Decisions accelerated
• Risk reduced
• Work simplified

With M Files, these outcomes are not side effects but they are the goal.

Stop measuring ECM success like an IT project. Instead start measuring it like a business advantage!

We’re here to help you with that transition.

L’article Stop measuring ECM success like this est apparu en premier sur dbi Blog.

It is supposed to make work easier, promising order instead of chaos, findability instead of frustration, control instead of clutter. In the world of document management, metadata is often treated as the solution, the moment where unstructured content becomes manageable.

In reality, in many organizations, metadata quietly becomes the problem.

Not because metadata is bad. But because too much structure, designed in the wrong way, can actively destroy productivity.

This is the metadata trap: when structure stops serving work and starts working against it.

The promise of perfect structure

Every ECM project starts the same way. A workshop room with a whiteboard. Some PowerPoint slides with boxes and arrows. Someone asks:

What metadata do we need?

At first, the answers are sensible:

• Document type
• Customer
• Project
• Status

Then the room warms up. Legal wants contract subtype. Finance wants cost center. Compliance wants retention category. Sales wants region, industry, deal size. IT suggests future-proofing “while we’re at it.”

Before long, a simple document requires:

• 10/15 mandatory fields
• Complex naming conventions
• Conditional rules and dependencies

On paper, it’s beautiful.

In practice, it’s an additional charge on every single user, every single day.

The user “fees” nobody calculates

Although metadata only amounts to a few bytes and is therefore seemingly insignificant in the context of a global ECM project, it isn’t free.

Each required field adds:

• A decision the user must make
• Context they must understand
• Time they must spend

Individually, that cost seems trivial. Five extra seconds here. Ten seconds there, but multiply that by:

• Hundreds of users
• Thousands of documents
• Years of daily work

What looked like “good governance” becomes a significant productivity drain.

Worse, the people who pay this tax are rarely the people who designed the metadata model, that’s why it is crucial to involves the right people at the really beginning of the project.

What really happens in the real world

When metadata becomes too heavy, users don’t become more disciplined.

They become creative.

They:

• Select the first value in the list just to proceed
• Copy metadata from an old document whether it fits or not
• Create “Miscellaneous” documents whenever possible
• Store drafts locally and upload them later (maybe)
• Avoid the system unless absolutely forced

Although the metadata appears to be complete at this stage, it is far from relevant. The result is a highly detailed structure that lacks substance.

The illusion of control

One of the most dangerous assumptions in ECM projects is this:

If we enforce the metadata, people will use it correctly.

They won’t.

Not because they’re lazy.
Because their primary job is not data quality.

A project manager wants to move a project forward.
A lawyer wants to close a contract.
An engineer wants to solve a problem.

Metadata is secondary. If it becomes an obstacle, it will be bypassed consciously or subconsciously.

Heavy structure creates the illusion of control while eroding actual adoption.

Metadata designed for reporting vs. for work

Here’s a useful distinction:

• Reporting metadata serves management, analytics, and compliance.
• Operational metadata serves daily work.

The trap appears when reporting needs dominate design decisions.

Fields are added because:

• “We might need this later”
• “It could be useful for dashboards”
• “Compliance asked for it”
• “Another department uses it”

Very few fields are added because:

“This helps users get their work done faster”

This imbalance is deadly.

If metadata does not help users perform actions such as finding, reusing, automating or making decisions, it will eventually become redundant.

Metadata isn’t a magic bullet.

This may sound heretical in ECM circles, but it’s true.

Metadata itself has no value.
Metadata only becomes valuable when…

• It is used later.
• by a real process.
• with a clear outcome.

Unused metadata is just overhead.

A useful question to ask about every field is:

“What breaks if this metadata is missing or incorrect?”

If the honest answer is “nothing important”, then the field may not be necessary.

The cognitive load problem

There’s also a human factor we often ignore: cognitive load.

Every metadata field requires the user to:

• Understand the difference between similar options
• Interpret abstract definitions
• Predict future use cases

This is exhausting, especially under time pressure.

When systems demand constant classification, users feel policed rather than supported.

The result?

• Reduced satisfaction
• Lower trust in the system
• Gradual disengagement

And no training program can fix that.

Simpler structure, better outcomes

The most successful systems tend to share a few traits:

• Minimal mandatory metadata
• Strong defaults and automation
• Metadata inferred from context whenever possible
• Progressive disclosure (advanced fields only when needed)

They accept a hard truth:

Incomplete but accurate metadata is better than complete but meaningless metadata.

The goal isn’t perfection. The goal is usefulness at scale.

A practical rule of thumb

Here’s a very simple rule that works shockingly well:

If a user cannot explain why a metadata field is important for their work in a single sentence, then that field is hindering efficiency.

This doesn’t mean removing governance. It means aligning structure with reality.

Metadata should:

• Reduce friction, not add it
• Follow work, not dictate it
• Evolve over time, not fossilize

Escaping the Metadata Trap

Avoiding the metadata trap doesn’t require radical change, but just discipline.

• Start with the minimum viable structure
• Observe real usage, not design intent
• Remove fields that don’t pull their weight
• Treat metadata models as living systems

Most importantly, listen to users. Not in requirements workshops, but in their daily behavior.

They will always tell you when structure has crossed the line.

Life is full of compromises, and so is the life of an ECM too! Structure is powerful. Metadata is necessary. Governance matters. But when structure becomes heavier than the work it supports, productivity collapses quietly and steadily.

The structure should serve the work, not the other way around.

That’s the difference between a system people tolerate and a system they actually use.

Modern ECM systems, such as M-Files, can greatly improve the user experience. There are various mechanisms for doing so:

• Metadata discovery suggests values for you
• Automatic value applies basic rules (concatenation, automatic numbering,…)
• Background calculations perform more complex actions
• A dynamic user interface that displays or hides properties depending on the lifecycle state and or the user profile

These capabilities enable users to work efficiently without wasting time filling out endless forms. Meanwhile, governance keeps everything under control, and management continues to receive relevant analytics data.

As always, dbi services (and I) are here to guide you through this complex yet essential process.

L’article The metadata trap est apparu en premier sur dbi Blog.

In almost every enterprise content management (ECM) initiative, the phrase “Let’s get some quick wins” appears early, often with good intentions.

Quick wins promise momentum. They reassure sponsors. They demonstrate value quickly.
This is an important phase, especially in complex ECM programs. Initial success sends the right signal.
However, there’s a hidden risk that few teams discuss: when quick wins influence design decisions, the future of the platform is often jeopardized.
After years of working on digitization projects at different stages of maturity, I’ve seen how short-term victories can quietly create long-term problems.
Let’s explore why.

Why “Quick Wins”

ECM projects have a reputation problem.

They’re perceived as lengthy, organizationally disruptive, and unable to deliver visible value on day one.

Pressure builds from every direction:

Executives want proof of ROI, business users want immediate relief, and IT wants to reduce risk.

Quick wins seem like the perfect solution:

A fast workflow, a simple metadata model, a department-specific solution, and minimal integration “for now.”

In isolation, these choices often work.
The issue isn’t the quick wins themselves, but when they become the strategy.

The illusion of success

A quick win often looks like this:

Users quickly adopt the solution.
A process is automated in weeks.
KPIs show immediate improvement.
The project is labeled a “success.”

What’s rarely measured are the following:

• Architectural compromises
• Governance shortcuts
• Data model rigidity
• Future integration costs

The ECM system works, but only for the narrow scope for which it was built.
This creates the illusion of success, making it extremely difficult to later argue for redesign, refactoring, or rethinking foundational choices.

Where the long-term damage begins

Hard-Coded Business Logic

Quick wins often embed business rules directly into:

• Workflows
• Scripts
• Folder structures
• Naming conventions

While this accelerates delivery, it also freezes flexibility.
When regulations change, processes evolve, or new departments are brought on board, the system resists change.
What should be a configuration becomes redevelopment.

Fragmented Information Architecture

Delivering fast often means:

• Department-specific metadata
• Unique taxonomies
• Custom object types without alignment

Individually rational, collectively disastrous.
Over time, the ECM becomes:

• Hard to search across
• Impossible to standardize
• Expensive to clean up
• Politically sensitive to redesign

The organization ends up managing multiple ECMs on one platform, which slows down operations and reduces efficiency.

Governance deferred

I’ve already written about governance in previous posts (here or here), This is rarely part of a quick win.
So it’s postponed:

“We’ll define ownership later”
“Retention can come in phase two”
“Permissions can be cleaned up once adoption grows”

Except “later” never arrives.
By the time governance becomes urgent:

Nowadays, content is no longer limited to simple documents, so volumes quickly become huge. This makes it difficult to manage corrective actions.
Bad habits have taken root.
Addressing access or retention issues becomes risky when the original needs and constraints are no longer clear.

The cost of governance grows exponentially with time.

Technical debt that looks like business value

Perhaps the most dangerous effect:
Early success hides technical debt behind business praise.
The system delivers value today, so questioning its design feels unnecessary, even disruptive.
Until:

• Performance degrades
• Reporting becomes unreliable
• Integrations become costly
• Upgrades feel dangerous

By that point, the platform has become business-critical and fragile. Often, at this time, the customer is considering a new ECM migration, not because the initial solution is inadequate, but because of poor implementation: a bad data model and a lot of custom development, which makes the solution slow and impossible to upgrade without starting from scratch.

Sometimes, migration project is switching from one ECM system to the same, but three or four major versions later. Ideally, a good solution would follow the product lifecycle with maintenance tasks varying in complexity depending on the version updates. However, this is just part of how IT works.

The false choice: Speed vs. Sustainability

Most ECM teams believe they face a trade-off:

“We can deliver fast, or we can design it right.”

That’s a false dichotomy.
The real issue is intentionality.
You can provide early value without sacrificing the future if you treat quick wins as such.

• Controlled experiments
• Learning tools
• Stepping stones, not endpoints

How to Reframe “Quick Wins” Safely
Here’s what sustainable ECM teams do differently:

Design the core before the win

Even if the first delivery is small, the foundations aren’t:

• Information model
• Governance principles
• Extension strategy
• Integration approach

You don’t need to build everything right now, but you must decide on all aspects from the beginning.

Keep “Quick Wins” reversible

Before approving a shortcut, ask one question:

“How difficult would it be to undo?”

If the answer is “painful” or “political,” then it’s a liability, not a win.

Separate demonstration from architecture

Sometimes, a quick win is just for proof of concept. That’s fine.
But:

Don’t let demo logic become production architecture.
Don’t optimize a prototype as if it will live forever.

Be explicit about what is temporary.

Measure long-term risk alongside short-term value

Add one metric to your success criteria: Future adaptability.

If achieving a quick win makes the platform harder to evolve, the cost of doing so must be apparent from the beginning, not discovered years later.

ECM remembers every shortcut

ECM systems are unlike many other platforms.
They:

• Accumulate content
• Preserve decisions
• Amplify early design choices over time

Every shortcut becomes part of the organizational memory.
Of course, quick wins aren’t bad, they are even necessary for user adoption. However, if left unchecked, quick wins can silently compound.
True success of an ECM project isn’t how fast it delivers value in the first month.
Rather, it’s how well it continues to serve the organization in year five.

If you are looking for advice about your ECM strategy, please ask us!

L’article The hidden cost of “Quick Wins” in ECM projects est apparu en premier sur dbi Blog.

The situation

This wasn’t just a storage platform.
It was the operational backbone of the company.
Contracts, invoices, compliance records, procedures, employee files, approval workflows, audit trails, everything lived there.
Teams across finance, HR, legal, procurement, and operations relied on it constantly.
If the ECM system slowed down, business slowed down.
If it stopped… business stopped.
And that morning, it stopped.

What went wrong?

The issue had been building quietly for months.
Nobody noticed because the pain came slowly.
A few extra seconds to retrieve a file, a delayed workflow here, a failed search there.
People adapted. They worked around it.
IT assumed it was “normal system aging.”
But underneath, the real problem was growing:

• No proper retention policy.
• No archive strategy.
• No performance monitoring.
• No governance around content growth.

Years of duplicate files as well as outdated versions of documents no one needed.
Massive email attachments stored for nothing or expired records that should have been deleted years ago.
With all those things, the repository had become digital landfill.
As a result, storage became bloated, indexes became overloaded, and search performance collapsed. Backups also took a dangerous amount of time.
Finally, one morning, the system simply couldn’t keep up anymore.
Not because of one dramatic failure, but rather hundreds of small, ignored ones.

The impact

The finance department could not process payments, the HR department could not retrieve employee documentation, and the legal department could not access signed contracts.
In practical terms, stalled approvals delayed, customer responses and froze audit preparation.
Executives wanted answers, users wanted miracles, and IT needed time.
No one had enough of it.
Emergency meetings replaced actual work.
Consultants were called in.
Recovery plans were hastily put together.
Suddenly, budgets appeared for problems that had been ignored for years.
But the real cost wasn’t just technical; it was a loss of trust.
People stopped trusting the system.
Once users lose confidence in your ECM platform, rebuilding that trust is far more difficult than resolving storage issues.

The lesson

Most ECM failures don’t happen overnight.
They happen silently, slowly, and politely.
Then, one day, they become impossible to ignore.
Governance may feel boring until disaster makes it urgent.
Retention policies feel optional until storage becomes a crisis.
Performance reviews feel like “later” work until later arrives.

An ECM system doesn’t fail because it stores too much.
The system fails because no one decides what shouldn’t be stored

The lesson was painful.
You don’t manage an ECM system when it breaks.
You manage it so it never gets there.
By the time everyone notices, it’s already too late.

Unfortunately, this scenario isn’t rare. As consultants at dbi services, we’re often called in after the damage has been done. Of course, our job is to find solutions, it’s still better to act before a crisis hits. That way, we have time to implement strategies without rushing.

L’article The day your ECM System became unusable est apparu en premier sur dbi Blog.

M-Files is a wonderful tool and probably my favorite ECM, but it won’t solve your problem.

Companies that initiate digitalization projects like to convince themselves that investing in an ECM will solve all their problems: no more chaos, data loss, inefficiency, or lack of collaboration.

I’m sorry to break your dreams, but it won’t!

Tools Amplify

Software like M-Files is powerful. No doubt about it.

It structures information, automates workflows, enables collaboration, and improves visibility. However, all of that depends on one thing:

What you put into it.

If your processes are unclear, M-Files will exacerbate the confusion.
Likewise, if your governance is weak, M-Files will amplify that weakness.
M-Files won’t magically make your teams start collaborating.
Tools don’t create discipline; they expose it, or the lack of it.
Think of M-Files less as a solution and more as a multiplier.

• Good processes become great.
• Broken processes break faster.

Why Companies Expect Magic

So why do organizations keep expecting tools to “fix everything”?
Because it’s easier.
Buying software seems like progress. It’s tangible, measurable and budgeted. It shows action.
On the other hand, fixing an organization requires:

• Alignment between teams
• Clear ownership
• Hard decisions on processes
• Cultural change

That’s messy, Political and Slow.
Instead, companies subconsciously shift the responsibility.

Once we have the tool, things will improve.

But what if they don’t?
They blame:

• The tool
• The implementation
• The users

Almost never the organization itself.

The Real Success Factors

When M-Files works really well, it’s never just about the tool.
It’s because a few key things were already in place or built alongside it.

Clear Processes

Before digitizing anything, successful teams answer:

• What actually happens today?
• What should happen?
• Who is responsible at each step?

M-Files then becomes the execution layer, not the definition layer. It is not the job of M-Files to determine what should be done, but rather to ensure that the process is under control and follows organizational rules.

Ownership & Accountability

Every document, workflow, and decision needs an owner.

Without that:

• Workflows are stuck.
• Approvals take forever.
• Nobody feels responsible.

With it:

• M-Files flows naturally.
• Decisions are made faster.
• Accountability is visible.

Simplicity Over Perfection

Over-engineered systems fail.

The best M-Files setups are:

• Simple
• Intuitive
• Close to how people already work

Not “perfect.” Just usable and adopted.

Improving a work process is possible at any stage, but simplifying an existing one is challenging.

Change Management

The biggest challenge isn’t technical, it’s human.

People need to:

• Understand why things are changing
• Trust the system
• See personal value

Without that, even the best setup gets ignored.

Continuous Improvement

Successful organizations don’t “finish” their M-Files project.

They:

• Iterate
• Adjust workflows
• Refine metadata
• Listen to users

The system evolves with the business, which is the most important aspect, in my opinion, and one that is often overlooked.

Thinking differently

The real question is not: “What can M-Files do for us?”

Instead think: “Are we mature enough to successfully implement M-Files?”

It’s obviously not easy to answer that question, especially when you’re focused on your core business.

And that’s perfectly normal, that’s why we’re here to bridge the gap between software and the realities of business.

We’re not just here to install and configure systems; when we take on a digital transformation project, our primary role is to assess the organization’s readiness from an outside perspective, without passing judgment. Then we identify the necessary steps to reach the target.

To me, the real reward at the end of a project isn’t when the client says, “M-Files works well,” but when they say, “Thanks to M-Files, we’ve improved our collaboration and streamlined our interactions” and that makes a big difference.

L’article M-Files didn’t fix your problem, your organization did. est apparu en premier sur dbi Blog.

Firstly, in most cases, your ECM project did not fail because of the tool!

That’s the uncomfortable truth

It wasn’t because the platform was bad.
It wasn’t because the features were missing.
It wasn’t even because users ‘resisted change’.

And yet, the project still underdelivered. Or worse, it quietly failed.

After years of working on ECM implementations, I have seen the same pattern emerge time and time again: Good tools. Smart people. Disappointing results.

So what’s really going wrong?

The illusion of the “Right Tool”

Let’s start with the most common misconception:

If we choose the right ECM solution, everything else will fall into place.

It won’t.

Modern ECM platforms are powerful. They can manage documents, automate workflows, enforce governance and integrate with almost anything.

But here’s the reality, A tool can’t fix a broken organization. It exposes it.

• If your processes are unclear, the system will amplify the confusion.
• If ownership is undefined, governance will collapse.
• If users don’t see the value, adoption will stall.

The tool is not the problem. It’s a mirror.

Business and IT are not solving the same problem

Most ECM projects start with a misalignment that no one explicitly addresses.

IT is thinking:

• architecture
• security
• scalability

The business is thinking:

• “Where is my document?”
• “Why is this so slow?”
• “Why do I have to click 12 times?”

Both are valid. But they are not the same problem.

So what happens?

You get:

• technically solid systems
• that don’t solve day-to-day frustrations

And users disengage, not because they’re resistant, but because the system doesn’t help them.

Over-engineering everything

This is an incredibly common issue.

In the name of ‘doing things properly’, projects end up with overly complex metadata models.

• overly complex metadata models
• workflows for every edge case
• validation rules everywhere.

On paper, this looks impressive.

In reality, the system becomes fragile, slow and difficult to use.

Complexity is often mistaken for maturity. In ECM, complexity is usually the fastest way to kill off adoption.

Governance that exists only in slides

Every project has governance.

Or at least, a document describing it:

• Naming conventions
• Validation rules
• Lifecycle definitions

Everything is defined and then… ignored.

Because:

• no one owns it
• no one enforces it
• no one adapts it

It looks good during the project, but it disappears in real life.

The “Quick Win” trap

Quick wins are supposed to build momentum and it’s true, however they often create long-term problems.

Why? Because they:

• bypass proper design
• introduce shortcuts
• create inconsistencies

And what about those “temporary” solutions? They never get fixed.

Months later, the system becomes:

• inconsistent
• hard to maintain
• confusing for users

You haven’t gained any speed. You just made things more complicated.

Quick wins are essential for driving user adoption, but this must be taken into account when designing the project as a whole. Consider the pros and cons, but do not compromise on the project’s overall quality.

No one owns the system after Go-live

This is where many projects quietly fail.

Once the system is live:

• the project team disappears
• IT moves to other priorities
• the business assumes “it’s done”

ECM is not a one-time project. It’s a living system.

Without ownership:

• governance degrades
• usage diverges
• value decreases over time

And nobody reacts until it’s too late.

What actually works

Having seen what fails, the question becomes:

What makes an ECM project succeed?

Not perfectly. But sustainably.

From my experience, here’s what consistently makes the difference:

Start with real user problems

Not features. Not architecture.

Ask:

• Where do people lose time?
• What frustrates them daily?

Solve that first.

Keep it simpler than you think

• Fewer metadata fields
• Fewer workflows
• Clearer rules

You can always add complexity later, but it’s rare that you can remove it.

Make ownership explicit

Someone must:

• own the system
• enforce governance
• evolve the platform

No owner = slow decay

Design for reality, not theory

People will:

• take shortcuts
• ignore rules
• prioritize speed

During the design phase keep that in mind.

Treat ECM as a product, not a project

Projects end, but Products evolve.

To create long-term value, you need:

• continuous improvement
• feedback loops
• adaptation.

When I started working in ECM, data was made up of static documents with few or no relationships between them. Now, we have various types of content, such as pictures and videos, as well as more interaction and workflows. Therefore, what is suitable now might not be in two or three years.

Final Thought

In conclusion, most ECM projects don’t fail spectacularly. They fail quietly.
Users stop using advanced features, workarounds appear and value slowly erodes.

Eventually, people say:

The system is not that useful.

Not because the tool was bad. It’s because the project misunderstood what success actually looks like.

A good ECM system is not necessarily the one with the most or the trendiest features. Rather, it’s the one that people actually use because it simplifies their work.

As a result, the tool itself is not as important as you might expect. Of course, some are more relevant than others depending on the case. That is why, at dbi services, we support several of them.

The real key to the success of an ECM project lies in its management and long-term vision.

L’article Why ECM Projects fail (even with good tools) est apparu en premier sur dbi Blog.