Dave McComb has written The Data-Centric Revolution, a quarterly column for TDAN.com (The Data Administration Newsletter), since September 2015. Every column is published in full here. They’re listed below from the first to the latest, each with a line on what it covers, and the first column follows the list.
The column has run alongside the Data-Centric Manifesto, which Dave proposed and which practitioners sign to declare their support. The first column ends by inviting readers to sign it.
Every column
2006
- The Enterprise Ontology (July 2006). Written before the column began: what an enterprise ontology is, how to build one, and what makes a good one.
2015
- The Data-Centric Revolution (September 2015). The first column: data as a permanent shared asset, with applications that come and go. It’s printed in full below.
- The Warning Signs (December 2015). A tongue-in-cheek diagnosis of Appliosclerosis, the hardening of the silos.
2016
- The Evolution of the Data-Centric Revolution (March and June 2016). A history of the data-centric idea, from punched cards and magnetic tape to data lakes.
- Data-Centric vs. Data-Driven (September 2016). Why the two aren’t the same, and why gathering more data can leave a company less data-centric.
- Do Data Lakes Make My Enterprise Look Data-Centric? (December 2016). What a data lake would need to be data-centric: understandability, usability, and updateability.
2017
- Integration Debt (March 2017). The column that coined “integration debt,” a cousin of technical debt that is broader and probably more costly.
- The Core Model at the Heart of Your Architecture (September 2017). What a core model is, how to build one, and how to use it for analytics and new applications.
- Data-Centric’s Role in the Reduction of Complexity (December 2017). Complexity drives the cost of information systems, and a data-centric approach cuts the factors behind it.
2018
- Data-Centric vs. Application-Centric (March 2018). Why systems built application-first cost 10 to 100 times what they should, and what changes when you start from the data.
- Data-Centric and Model Driven (June 2018). A history of model-driven development from 1980s CASE tools on, and why data-centric companies so often go model-driven too.
- Governance in a Data-Centric Environment (September 2018). Why shared data is harder to govern than silos, and how simpler structures make governance come more naturally.
- Implementing a Data-Centric Architecture (December 2018). The layers early adopters have to build for themselves, from data and federation to security, identity, and integrity management.
2019
- The 1st Annual Data-Centric Architecture Forum: Re-Cap (March 2019). What the first forum agreed a data-centric architecture needs, and seven ways to start one.
- Lawyers, Guns and Money (June 2019). Why going data-centric takes more than a technology upgrade.
- Toss Out Metadata That Does Not Bring Joy (September 2019). Why most large firms have far more metadata than they can use.
- Semantics and the DAMA Wheel (December 2019). The DAMA wheel taken one wedge at a time, and where knowledge graphs change data management most.
2020
- DCAF 2020: Second Annual Data-Centric Architecture Forum Re-Cap (March 2020). The second forum, with Dave’s report from the front lines.
- Data-Centric vs. Centralization (September 2020). Why centralizing a business function’s data isn’t the same as being data-centric.
- The Role of SemOps (December 2020 and March 2021). What DevOps and data governance each bring to SemOps, the practice of moving ontology changes into production.
2021
- Fighting Class Proliferation (June 2021). Why application data models end up with more classes than the enterprise needs, and the options for keeping a core model small.
- Data-Centric Accounting (December 2021). Where Semantic Arts’ data-centric accounting work began: accounting built on a knowledge graph, with every entry tied to a business event.
2022
- Incremental Stealth Legacy Modernization (March 2022). Modernizing legacy systems by building a data-centric graph beside them and taking them over one piece at a time.
- Headless BI and the Metrics Layer (June 2022). The modern data stack’s metrics layer, and how a data-centric architecture defines metrics in shared data.
- OWL as a Discipline (September 2022). OWL treated less as a language than as a discipline, akin to normalization.
- Detour/Shortcut to FAIR (December 2022). The FAIR principles, why they’re hard to meet, and the detour and the shortcut to them.
2023
- Zero Copy Integration (March 2023). The technology behind integration without copying data, with an investment bank case study.
- Is a Knowledge Ontology the Missing Link? (June 2023). Where knowledge management and knowledge graphs meet.
- “RDF Is Too Hard” (September 2023). The objection answered for enterprise integration, and where RDF might be overkill.
- Best Practices and Schools of Ontology Design (December 2023). The main schools of ontology design, what each optimizes for, and the practices they share.
2024
- How Big Things Get Done (in IT) (March 2024). What Bent Flyvbjerg’s How Big Things Get Done means for IT projects and legacy modernization.
- Who Doesn’t Need Data-Centric? (June 2024). Four years after naming target markets for data-centric work, what Semantic Arts got right and wrong.
- Dealing with Data Complexity (September 2024). Complexity as the root data problem, and the one strategy for it that works.
- Putting Knowledge Into Our Knowledge Graphs (December 2024). How a knowledge graph can carry knowledge, track where it came from, and bring it forward when it’s needed.
2025
- ABox Versioning (March 2025). Versioning the data as well as the ontology, since a query can break when the way data is used shifts.
- The Year of the Knowledge Graph (June 2025). Earlier candidates for the year of the knowledge graph, and the signals pointing to 2025.
- Evolution of Metrics in a Data-Centric Enterprise (September and December 2025). A six-step progression for enterprise metrics, worked through with aging accounts receivable.
The first column (September 2015)

We are in the early stages of what we believe will be a very long and gradual transition of corporate and government information systems. As the transition gets underway, many multi-billion dollar industries will be radically disrupted. Unlike many other disruptions, the revenues currently flowing to information systems companies will not merely be allocated to newer more nimble players. Much of the revenue in this sector will simply evaporate as we collectively discover what a large portion of the current amount spent on IT is unnecessary.
The benefits will mostly accrue to the consumers of information systems, and those benefits will be proportional to the speed and completeness that they embrace the change.
The Data-Centric Revolution in a Nutshell
In the data-centric enterprise, data will be a permanent shared asset and applications will come and go. When your re-ordering system no longer satisfies your changing requirements, you will bring in a new one, and let the old one go. There will be no data conversion. All analytics that worked before will continue to work. User interfaces, names of fields, and code values will be similar enough that very little training will be required.
The Current Status Quo is Application Centric
This is in stark contrast to what occurs now. Currently, if your re-ordering function no longer meets your needs, you will typically create a patchwork of add-on systems. These add-on systems will provide partial solutions, at the expense of ossifying the data structures and interfaces that were established to allow this. Over time, the ability to change the system continues to decline until a lack of functionality threshold is crossed. At this point a new application project is announced that will solve this problem. The new system may be a package or it may be custom. It may be on premise or it may be in the cloud. The only thing that is guaranteed is that the new system will have a different data structure and data model.
If you buy a package and implement a SaaS system, the data model will pre-exist and have no relation to your current system. If you custom build a system, you could in theory recreate your current data structures, however this almost never happens. Designers believe, correctly in most cases, that a good part of the limitations of the existing system stem from its inadequate data structures.
Whatever the reason, the decision to change the data structures has many direct consequences, including:
- Data conversion—it makes the very idea of a data conversion a necessary part of the system replacement project
- User Retraining—the change in the data structure ripples all the way through to the user interface and work-flow. All the users of the system will need to be retrained to do their jobs. Not only do the number of screens and the sequence change, the names of the fields, the levels of abstractions, and the codes used in the system will all be different. Thousands of small, evolved processes and workarounds will be obsoleted.
- Big Bang—due to the data conversion and user training, you will end up with a big bang project. That is, no improvement at all until the conversion occurs. Big bang conversions have been shown to be high risk, and because of that add additional costs just to attempt, sometimes successfully, to mitigate the risks.
- Data Quality—most projects of this type spawn a “data quality” sub project. The new system shines a light on data quality problems that have lain dormant for decades. Very often the new system can’t convert until the data quality issues are taken care of. Who can argue with data quality? But the truth is, most of what comes up as data quality issues in the conversion are just differences in integrity management and constraints between the old system and the new system. Perhaps there are more integrity checks in the new system than the old, but most of the effort goes into requirements caused by the fact that they are just arbitrarily different, which is a side effect of the different models.
What is a bit subtle is that the sum total of these implications adds up, in almost every case, to large projects. These are typically projects large enough to need to go through the capital budgeting process (years can be lost here). These are projects that are big enough to fail, and big enough for people to notice when they fail.
The Other Way
Unfortunately, we are going to incur some of the downsides listed above when we first implement data centric. You will have a data conversion. The main goal of a data centric architecture is not to preserve the lousy data structures you have, but to create an environment where your next set of data structures can persist.
A data centric enterprise needs a few things that are currently uncommon, but are all technically quite feasible. We will touch on these briefly here and more completely in subsequent columns.
Some of the key requirements of a data centric architecture:
- A federate-able data store—there are many reasons (performance and security being two) to believe that any reasonably sized data centric enterprise will rely on a large number of coordinated data stores that can be queried and updated individually or in groups.
- A flexible data structure—current data structures are rigid (not innately flexible), and that promotes rigid coding practices (developers code to the data structures which tends to lock them in place). More flexible structures (XML, json, and rdf) promote flexible coding and allow the data structures to be extended in place.
- Shared meaning—the data centric enterprise will need a way to communicate and propagate the meaning of the data in the system, as it can no longer rely on the application to be the arbiter of meaning.
- Schema later—some call this “schema on read” to emphasize the fact that schema need not exist prior to writing. We prefer the term “schema later”, because it also includes extending the schema to the data in place, and having it available as a shared resource and not just for the current reader.
- Curated and uncurated data sets—there will be data sets that are highly curated, where integrity constraints are consistently applied. There will also be harvested and external data sets that are uncurated. The architecture will need a mechanism to enforce constraints, independent of any application on the curated sets, and will need ways to deal with data sets that are of mixed levels of curation.
- Identity Management—far beyond the identity of users, the system will need to manage the identities of everything else as well. The system needs to know whether a potential “add” is creating a Person or widget or transaction that the enterprise already has registered, and if so notify the initiator. At the same time, the system will need to manage the inevitable and almost innumerable identity synonyms that our existing system of system-building has created.
A Long, Slow Road
I liken this to the electrification of factories. In the 1800’s, factories ran on steam engines and complex systems of drive shafts, pulleys, and gears. By the 1880’s the electric motor was invented and it was obvious that the future factories would be populated exclusively by electric motors. And yet it was not until the 1920’s that the revolution was mostly complete.
Many things allowed this inevitable transition to drag on for 40 years. Inertia was one. An over reliance on the idea that the steam engine and the gears represented an investment (which they did), but also encourage re-investment. There was a complex set of skills and expertise that held the status quo in place far longer than it should have stayed: architects whose expertise lay in designing factories for the large steam apparatus, work flow designers who were oriented around the drive shafts, attempts to replace the monolithic steam engine with a monolithic electric engine, few electric machines to choose from and the like.
But some companies did make it through the transition, and no doubt some more rapidly than others.
We need to remind ourselves that we are in the same position. It can now be obvious and inevitable, but we will still face great resistance, and things will take far longer than they theoretically should. This is the nature of change.
Some of the Themes I Plan to Explore in Future Columns
In no particular order, here are some of the themes I plan to cover in future columns.
- How to tell that you’re not already data centric
- Data centric is far more than a data warehouse on steroids
- Estimates on the order of magnitude improvement possible in the data centric enterprise
- How we got in this mess, and what keeps us stuck there
- What kind of data structures will endure through generations of applications
- Case studies in the impact of not being data centric
- Case studies in data centric
- The Status Quo will strike back
- The difference between a data centric application and a data centric enterprise
- What does security look like in a data centric enterprise
- How data centric deals with the huge numbers of current applications
- Data centric and external and unstructured data
- The role of identity management in data centric architectures
- What does integrity management look like if it’s not application centric
By the way, if you have any case studies in adopting data centric approach I’d be happy to feature them. They are few and far between and need to get into the collective consciousness.
If you’d like to declare your support, lend your name and credibility to the cause, and interact with like-minded professionals, please visit and sign the manifesto: datacentricmanifesto.org
First published on TDAN.com in September 2015.