Use caseContent platform exit

Legacy platform exit, with proof

Fourteen million Documentum objects have to move, rights and metadata intact. Copying is the easy part; proving nothing was lost is the project.

The docbase is counted before anything movesEvery document gets its own line in the reportA person signs each wave before the next one starts

Actions on this campaign
The verdict on the batch

Some documents need a person · each one is named, with its reason

The operations engineInventory of the docbase

14.2 million objects in five types, and nothing moved during the scan. 6.2 million sit in the generic type and need a folder rule before they can be mapped.

source · scan of prod_ecm, March 4
01

What gets in the way

The short version

The Documentum renewal notice sits on the CIO's desk at a US industrial manufacturer, eighteen years after the docbase went live. The last developer who knew the custom types has retired, and nobody wants to be the one who loses a contract version or opens an HR folder to the wrong group. The copy is the easy part. The proof is what everyone fears.

That is why the runbook is built around evidence. The operations engine counts the docbase before touching it, applies a written mapping, and writes one line per document for every batch it moves. The team reads a report and decides, wave by wave.

Source inventory, prod_ecmOperations engine
Counted before anything moves. The real numbers of the docbase, read in place.
Reconciliation, pilotOperations engine
The pilot's verdict. Source and target compared document by document. The report says whether the next batch starts.

The runbook has four beats, and they never change order: count first, map in writing, prove on a pilot, then move the rest in waves that each carry their own report. Ten steps play them out on prod_ecm, from Marc's first scan to the closed campaign.

02

The inventory

Before a single document moves, the team knows what is in the source, where it will land and who will read it.

Step 1Discovery

Scan the docbase and count what is really there

Marc Olsen, the repository administrator, connects the operations engine to the docbase and starts a discovery scan. It reads types, folders, versions and rights in place. Nothing moves during the scan.

Volumes and formatsVersionsInherited rightsMissing metadataDuplicates

By the next morning he has the real numbers, and they differ from the 2019 architecture document. The report becomes the work list of the project.

Source inventory, prod_ecmOperations engine
6.2 million objects sit in the generic type: they need a rule before they can be mapped.
The project is sized on real volumesThe estimate, the waves and the windows come from what the docbase holds today, counted before anyone commits.
Step 2Mapping

Map each type to a class, each attribute to a property

Nadia Haddad, the migration lead, maps every source type to a class of the new repository with Marc. ctr_number becomes Contract number, the repeating attribute ctr_sites becomes a multi-value property, and the generic objects are mapped by folder, one rule per cabinet.

An attribute that is dropped is dropped on purpose, with the reason written next to it.

Mapping, Documentum exitOperations engine
The mapping is versioned: which version of which rule processed which batch.
Every choice has an author and a dateSix months later, anyone can see why an attribute was dropped and which version of the rule did it.
Step 3Rights

Translate the docbase rights into the new security model

Documentum grants rights to users and groups of the docbase. Marc maps each group to a directory group of the new repository and each permit level to a role. The inventory has already listed the groups still in use, including some whose members left the company.

584 groups mapped28 waiting for a decision
Security mappingOperations engine
Nothing is loaded with wider rights than it had in the source. An unmapped group holds its documents back.
Ask around on Monday: who could say which groups read the HR folders today, and who would sign that the new system says the same?
Rights are decided once, in writingThe HR folders do not open to the wrong group by accident. Each mapping is a decision the team can show.
03

The pilot

One cabinet, every rule, the full report: the pilot is where the mapping meets real data.

Step 4Scoping

Scope the pilot on one cabinet

Nadia picks the 2019 contracts cabinet: 48,210 objects, all versions, a mix of PDF and Word. It is big enough to hit the edge cases and small enough to rerun in an afternoon. The target is a staging space that business users cannot see yet.

New batchOperations engine
The rules are tested on a sample of real data first, then replayed at scale.
The edge cases show up earlyA strange amount field or a forgotten group is found on 48,000 objects, long before it can surprise 14 million.
Step 5Supervision

Run the pilot and watch each stage

Marc starts the batch at 1:00 p.m. The workers extract each object with its versions, apply the mapping, load into staging and check what arrived. The counts are shown per stage, so a drop between two stages is visible at once.

Batch: pilot, contracts 2019Operations engine
Throughput, errors and remaining volume, while it runs.
Every object is accounted forEach one ends the run checked or set aside, with a reason. There is no third box.
Step 6Exceptions

Work the exceptions one reason at a time

The 123 exceptions fall into four reasons. Marc fixes the rule where the rule is wrong, hands the missing files to the Documentum team, and reprocesses only the failed objects. The rest of the batch is not touched.

Unmapped group: 85Invalid amount: 20Content file missing: 14Name too long: 4
Exceptions, pilotOperations engine
A missing file is a source problem. It is reported, never filled with a placeholder.
Only the failed items run againTwenty bad amounts do not send 48,000 objects back to the start. The rest of the batch stays as it is.
Step 7Reconciliation

Read the reconciliation report

Once the reruns are done, Nadia opens the reconciliation report. Every document has its own line: extraction, transformation, controls, ingestion, with the Documentum identifier and the new one side by side.

Fourteen objects remain, the ones with no content file in Documentum. The source team confirms they were already broken there.

Reconciliation, pilotOperations engine
The report exports as it is, and goes into the runbook as the evidence for this batch.
The proof is written before anyone asksWhen the CIO asks whether anything was lost, the answer is a report with 48,210 lines.
04

The waves

The pilot rules are frozen. The rest of the docbase moves in waves, each with its own report and its own sign-off.

Step 8Viewer

The records owner checks a sample in the viewer

Priya Raman owns the contract records. She picks fifty contracts across the years and opens each one in the viewer, straight from the staging space, with no download. She compares the properties with what she knows of the contract.

CTR-2019-04417.pdfViewer
The report is the technical check. The sample is the business one.
The business signs on real documentsThe person who will live with the records sees them before the wave closes, and her sign-off is filed.
Step 9Waves

Run the waves on the runbook calendar

Nadia plans six waves over eleven weeks, one business domain at a time, the largest volumes on weekends. Each wave reuses the frozen mapping, produces its report and waits for its sign-off before the next one starts.

Wave 3 hit a storage slowdown on a Saturday. It resumed from the point where it stopped, without restarting the batch and without duplicating anything.

Runbook, Documentum exitOperations engine
Each wave waits for the report and the signature of the one before.
An interruption costs a few hoursThe wave picks up where it stopped. Nothing is copied twice and nothing starts again from zero.
Step 10Closure

Close the campaign and file the evidence

When the last wave is signed, Nadia closes the campaign. The docbase is set to read-only, so nobody keeps filing there by habit, and stays available until the switch-off date the business agreed on.

The runbook, the mappings and the six reports are filed in the new repository as the record of the migration.

Campaign closureRepository
The record of the migration lives next to the content it describes.
The audit question has a folderWho mapped what, which wave moved it and who signed it: all of it sits in one folder of the new repository.
05

The outcomes

Every batch on this runbook closes in one of three states, and the state decides what the team does next.

Reconciled

Every document matches

Counts, versions, properties and rights agree, line by line, with the source.

Then: the migration lead signs and the next wave can start.
Exceptions listed

Some documents need a person

A bad value, a missing file, an unmapped group. Each one is named with its reason.

Then: the rule or the data is fixed, and only those documents run again.
Batch held

A control fails on the batch

The counts do not agree, or a rule produced the wrong result on many documents.

Then: the next wave waits until the team has found the cause and decided.
What the operations engine does not decide

It signs no wave. It switches nothing off. It does not choose which attribute to drop or which group may read the HR files. Across the ten steps on this page, every binding decision is made by a named person, and filed.

The engine counts, applies the written rules and reports. The control is in the runbook, so it holds when the volumes are fourteen million.

06

The gains

Taken from prod_ecm and its six waves. A docbase with other types and other rules will give other counts.

1 lineper document in every report, with the source and target identifiers side by side.
0 groupsloaded with wider rights than in the source. An unmapped group holds its documents back.
6 reportsfor six waves, each signed before the next wave started, all filed in the repository.

Where these numbers come from. They are counted on the scenario described on this page, with example data. They are not a customer result.

The three principles behind those numbers

Count before movingDiscoveryThe scan reads the source in place. The project is planned on what is really there.
Prove every batchReconciliationEach document carries its own line. The report decides whether the next batch starts.
Decide in writingA person signsMappings, exceptions and waves are signed by named people, and the signatures are filed.
07

Who it helps

Switching off a platform this old takes three signatures: the CIO's, the administrator's and the records owner's. What each one gets in return:

IT and architecture

CIOs and migration leads

Everyone agrees the platform has to go, and nobody can promise nothing will be lost.

  • The project is estimated on counted volumes.
  • Every batch ends with a document-by-document report.
  • An interrupted wave resumes where it stopped.
  • Documentum, FileNet and OpenText sources follow the same runbook.
Administration

Repository administrators

You inherited a docbase you did not build, with a rights model nobody wrote down.

  • The inventory lists types, versions and rights in use.
  • Rights are translated into the new security model, group by group.
  • Failed objects are reprocessed without restarting the batch.
  • The mapping is versioned, so every change can be traced.
Business owners

Records owners

You are asked to sign that your records arrived, without seeing them.

  • You check a sample in the viewer, in the browser.
  • Properties and versions are shown next to the document.
  • Known exceptions are listed with their explanation.
  • Your sign-off is filed with the report of the wave.

A good first step

With one cabinet. Take the part of the docbase that worries you most, scan it, map it and run it as a pilot. A cabinet that size gives you an answer within weeks.

The source stays untouched until you decide to freeze it, and the new repository stays invisible to users until a wave is signed.

See it live

Bring us your docbase inventory

Share the list of types and rights groups of your Documentum, FileNet or OpenText platform. We will draft the first mapping with your team and scope a pilot on one cabinet.

The screens on this page are drawn to show one step at a time, with example data.

Uxopian Software helps organizations put AI to work across the systems they already run, without giving up control of their data, their infrastructure or their critical processes.