The Dictionary Travels Further Than the Data

A REDCap data dictionary gets around. It is emailed to a collaborating site so they can stand up the same instruments. It is attached to a protocol so a reviewer can see what is being collected. It is handed to a statistician who needs the codebook, to an engineer who needs to build a load, to the next study that wants to reuse a validated instrument. The participant data stays behind an access committee. The dictionary circulates freely, because it carries meaning rather than records.

That circulation is the reason we built our REDCap connector to consume exactly that artifact and nothing else. Governance should meet a schema where it already travels, not demand a new channel.

The capture layer's portable unit

REDCap's place in the research landscape is specific and well earned: electronic data capture for academic and clinical research, with the instrument as its unit of design and the data dictionary as its unit of exchange. One CSV describes every form, variable, choice list, validation type, branching rule, and identifier mark in a project. In practice it functions as a common schema language for research data capture — the thing people actually pass around when they need to agree on what a study collects.

Our connector (vendor key redcap) asks for that file, named data_dictionary, and asks for nothing else. No token, no live connection, no agent installed beside your instance. Columns are matched by header keyword, so a lightly renamed export still parses, and quoted choice lists are read with a proper RFC 4180 reader rather than a naive split. If your dictionary travels, it can be governed wherever it lands.

Direction one: the estate does not end at capture

An institution that runs a hundred REDCap projects also runs a warehouse, transformation pipelines, ingestion tooling, a graph or two, and domain platforms — and a single participant answer crosses most of them on its way to a result. Governance that stops at the capture layer governs the first hop and abandons the rest.

The CoreModels integration layer is vendor-neutral by construction. Thirteen connectors — REDCap alongside dbt, Snowflake, Databricks Unity Catalog, Google BigQuery, Microsoft Fabric, AWS Glue Data Catalog, Confluent Schema Registry, Airbyte, Apache Airflow, Neo4j, Salesforce, and cBioPortal — parse into one neutral estate model. An instrument and a warehouse table become the same kind of governed object: a Type with Elements, checks, and taxonomies. The same audit engine emits the same coverage, drift, and conformance sections for all of them; the same history, badge, and build gate apply.

That sameness is what makes cross-boundary questions askable at all. Is the value set enforced by the capture form the same one the analytics column accepts? Today that question is usually answered by two people comparing screenshots. It should be answered by one model.

Worth noting that REDCap is not the only research-domain citizen in the registry: cBioPortal sits in the same list, on the same verbs. We think the research vertical deserves first-class connectors rather than adapters bolted onto warehouse tooling.

Direction two: meaning has to leave in other dialects

Neutrality would be hollow if the governed model were itself a proprietary destination. It is not. What enters from a REDCap dictionary can leave in whatever the next tool speaks: JSON Schema for validation, LinkML for biomedical schema work, ShEx and OWL and JSON-LD for semantic tooling, SQL DDL for a warehouse, Avro or Protobuf for a pipeline, an Apache Ossie semantic model, a Bitol Open Data Contract Standard contract, a Synapse manifest template.

We implement those open specifications rather than inventing an interchange format of our own, precisely so that a choice list captured from a dictionary is never trapped — not in REDCap's format, and not in ours. A governed taxonomy that started life as 1, Male | 2, Female can come out as a LinkML enumeration or a JSON Schema enum without anyone re-typing it, and every place the target format cannot carry something, the loss is reported rather than smoothed over.

Direction three: back where it came from

The loop closes toward REDCap too. The generate verb writes an upload-ready data dictionary CSV from the governed model, with the full eighteen-column header: taxonomies as dropdowns with minted codes, not-null checks as required fields, governed types as validation types. A vocabulary refined in governance can scaffold the next instrument or the next site's project, reviewed and uploaded by a person. Capture feeds governance; governance feeds capture.

Why neutrality is load-bearing

Three things follow from it that would not follow from a REDCap-specific tool.

Vendor facts stay labeled as vendor facts. REDCap details with no universal equivalent — the numeric codes behind choice labels, branching logic, field notes, the identifier marks — are preserved as clearly attributed REDCap metadata. They are queryable and they round-trip, but they are never promoted into the shared model as though every system had them. A neutral core forces that bookkeeping to be explicit; a single-vendor tool never has to admit which of its concepts are parochial.

Studies outlive tools. Protocols run for a decade; platforms and stacks do not. A governance layer welded to one vendor's format recreates the silo it was meant to dissolve, one level up. A neutral one survives the migration that has not been announced yet.

Exit stays cheap, which is what makes staying reasonable. We never held your credentials, and the model exports to open formats, so leaving costs an export rather than a project. A governance layer you could walk away from tomorrow is one you can trust while you stay — and in a domain where the data belongs to participants and the meaning belongs to the study, that is the only defensible arrangement.

The answer a participant gave on a tablet ought to mean the same thing in the analysis dataset, the consortium warehouse, and the registry two years later. That is not a REDCap problem. It is an estate problem, and it takes a layer that belongs to no single vendor to solve it.

To see how REDCap plugs into the wider layer, start with the REDCap quickstart in the CoreModels integration docs.