Guide · ImplementationUpdated October 14, 2026

Common EDC implementation mistakes and how to avoid them

Most failed EDC implementations are not caused by software. They come from a build started on a draft protocol, a paper CRF copied screen for screen, edit checks nobody tested and sites trained the day before enrolment. Here are twelve mistakes, what they look like and the fix.

  • Twelve failure modes
  • Signs, cost and fix for each
  • Written for small teams

Free sandbox · No credit card · 21 CFR Part 11 aligned

Build review findings · demo study

Study

DEMO-IMPL-04

Forms

14 drafted

Findings

5 open

  • Visit schedule matches protocol schedule of assessmentsChecked line by line
  • Every required field has a protocol reason6 fields to review
  • Edit check ranges signed off by the medical monitorWaiting
  • Blinded role cannot see treatment armTested as that role
  • Export opened and read by the statisticianNot yet
Demo data. A build review before UAT finds most of these cheaply.

The pattern behind the mistakes

  • Most are made early and found late. A field that should not be required, a missing visit window or an export nobody opened costs minutes to fix in week two and weeks to fix after enrolment starts.
  • Copying paper is the most common root cause. A paper CRF is a print layout, not a data model. Re-think every page for entry, queries and analysis.
  • Testing the happy path is not testing. Out-of-range values, missing data, wrong roles and mid-study changes are where builds break.
  • Roles and the export are build requirements. Decide who sees what and what the statistician needs before you build the first form.
  • Change control belongs in the plan. Protocol amendments will happen. A build that cannot absorb them cheaply is a risk, whoever builds it.

Why this matters

Implementation is where data quality is decided

An EDC system does not make data clean by itself. It makes data clean when the forms ask the right questions in the right order, when the rules catch errors at entry, when the right people have the right access and when the data can leave the system in a shape the analysis needs. Each of those is a decision made during implementation, usually by a handful of people under time pressure and often before the protocol is final.

The cost of a mistake rises sharply with time. A wrong unit on a form caught in design review is a two-minute edit. The same error caught after 40 participants requires a version change, a decision about already-entered data, queries to sites, retraining and an audit trail explaining all of it. Our guide to ecrf versioning for mid-study changes shows what that looks like in practice, and protocol amendments without change orders covers why who owns the build matters.

None of the mistakes below is exotic. Each one appears repeatedly in small sponsor and academic studies, and each can be prevented with an hour of planning. For the schedule view of the same project, see the EDC implementation timeline.

Design mistakes

Six mistakes made in the design stage

These are made before a single form is built, or while building it.

1

Building on a draft protocol

The protocol is still changing, the visit schedule is vague and the build starts anyway. Sign: forms are renamed weekly. Fix: freeze a build baseline (schedule of assessments and primary endpoints), and treat later changes as controlled amendments. A schedule of assessments builder helps you agree the grid first.

2

Copying the paper CRF page by page

Free-text fields, combined questions and printed-page layout carry over. Sign: coded fields hold phrases like "see notes". Fix: one data point per field, typed answers, units and options defined. See how to design an eCRF and paper CRF to eCRF conversion.

3

Collecting everything "just in case"

Every extra field is a query, a training point and a monitoring burden. Sign: sites say forms take longer than the visit. Fix: trace each field to an endpoint, a safety need or a regulatory requirement, and cut the rest.

4

Making too many fields required

Required flags on fields that may legitimately be unknown force sites to enter junk. Sign: "99" and "NA" entries. Fix: require only what the protocol needs, and give an explicit "not done" or "unknown" route.

5

No data dictionary or naming convention

Variable names invented ad hoc make exports hard to read. Sign: the statistician asks what "Q14b" means. Fix: use consistent names, and confirm the automatic codebook reads sensibly. See the data dictionary generator.

6

Ignoring the export until the end

The first time anyone opens the dataset is at lock. Sign: reshaping work consumes weeks. Fix: export a test file in the first month and have the statistician comment on structure, labels and coding. Capture exports CSV or Excel with a data dictionary and SDTM datasets as SAS XPT with Define-XML.

Execution mistakes

Six mistakes made in testing, launch and the first months

These appear once the build exists and people start to use it.

7

Edit checks nobody tested

Ranges set from memory fire on valid data or miss real errors. Sign: sites ignore queries because most are noise. Fix: have the medical monitor sign off ranges, test with boundary values and use priority levels. See edit checks software.

8

UAT that only follows the happy path

The scripts enter valid data in order. Sign: first week of enrolment surfaces skip-logic bugs. Fix: include negative tests, wrong roles and out-of-window visits. See EDC UAT and sandbox.

9

Roles and blinding decided last

Everyone gets the same access because roles were never specified. Sign: site staff see coded IDs they should not, or unblinded staff see blinded views. Fix: write a role matrix before the build and test as each role. See blinded and unblinded role management and role-based access control.

10

Training sites the day before

Sites meet the system when the first participant is in the room. Sign: entry errors and protocol deviations from misunderstanding the forms. Fix: give sites sandbox access two weeks ahead and a one-page entry guide per form.

11

No plan for mid-study changes

Amendments arrive and nobody knows who approves a form change or how old data is treated. Sign: edits made directly on live forms. Fix: define change control (request, impact assessment, test, approval) and use draft, approve and lock states on every form.

12

Treating go-live as a button

No go/no-go criteria, no first-week monitoring. Sign: issues found by sites rather than the team. Fix: use a written gate and a short hypercare period. See the EDC go-live checklist.

When the mistake is found

What the same mistake costs at different stages

A qualitative view. Your own costs depend on study size and vendor terms.

MistakeFound in design reviewFound in UATFound after enrolment starts
Wrong unit or range on a vital sign fieldEdit the fieldEdit, retest the formNew form version, query existing entries, retrain sites, explain in the audit trail
Required flag on a field that can be unknownUntick itUntick it, retestSites have entered placeholder values; clean up and document
Blinded role sees treatment armFix role matrixFix and retest as that rolePotential unblinding event and deviation reports
Visit window set to the wrong day countEdit scheduleEdit, retestOut-of-window flags on valid visits; reassess deviations
Export never reviewedFix labels earlyFix labelsRe-map, re-export and re-validate analysis datasets

The pattern is the point: the same fix gets slower, more visible and harder to explain on the record.

Find the mistakes in a sandbox, not in the field

Build your forms, add edit checks, run practice participants as each role and open the export. The free sandbox has every feature, with no credit card and no time limit.

Rehearse your build free

Prevention built in

Where a self-serve build avoids several of these by design

Some of these mistakes grow out of the vendor model: a ticket for every change, a build you cannot see, and testing against a system you do not control. With a self-serve platform the team that knows the protocol builds and changes the forms directly.

  • Forms move from draft to approved; approved forms are locked for live use and only approved forms appear in the casebook.
  • Edit checks with range high, range low and custom value rules raise an auto-query at entry, with a priority for each rule.
  • Calculated fields such as BMI, eGFR and QTc appear read-only during entry, removing transcription errors.
  • Role-based access with PII segregation, and blinded roles that never receive treatment-arm values, enforced in the database.
  • Free sandbox with every feature, so UAT and site rehearsal cost nothing before go-live.
Edit checks and auto-queries

Stage 1

Draft

Build and edit freely

Stage 2

Approved

Locked for live use

Stage 3

In the casebook

Only approved forms

Audit trail
  • SDV requirement changed on Systolic BP

    Data manager · Reason: critical safety value

  • Form approved: Vital Signs (VS) v2

    Study owner · Locked for live use

  • Answer changed: Weight 68.0 to 68.5 kg

    Site coordinator · Reason: transcription error

A safer path

A review routine that catches most of them

  1. 1

    Baseline the protocol

    Agree the schedule of assessments, primary and key secondary endpoints and safety reporting. Record the version the build follows.

  2. 2

    Review fields against endpoints

    Walk every field and ask what decision it supports. Remove, merge or justify it.

  3. 3

    Write the role matrix

    Who enters, who reviews, who sees identity, who is blinded. Test it as each role.

  4. 4

    Run a planted-error test

    Enter ten deliberate errors (out-of-range, missing, wrong date order) and confirm each is caught or documented.

  5. 5

    Open the export early

    Give the statistician a test export and fix labels, units and coding while it is cheap.

  6. 6

    Rehearse with sites

    Give sites sandbox access and a short entry guide before launch.

  7. 7

    Pass the gate

    Use the go-live checklist, then monitor the first weeks closely.

The commercial side

Mistakes that come from the contract, not the build

Some implementation failures are commercial. A fixed build fee that excludes amendments produces change orders at the exact moment the protocol shifts. A vendor that must build every form means the sponsor cannot test a change without a ticket. A subscription that makes the data hard to export turns every later decision into a negotiation. These are choices made when buying, not when building. Hidden EDC fees lists the items to ask about, and the EDC procurement checklist covers the buying questions.

Capture lets a team build and change its own forms, with a free sandbox before go-live and paid plans from the point of going live with real participants. Specific pricing is not published here; ask for terms in writing. The aim of this page is general: whichever system you pick, spend the effort early.

FAQ

Questions teams ask before they switch

Something not covered here? Ask us directly.

What is the most common EDC implementation mistake?

Starting the build before the protocol is stable, and copying the paper CRF page by page. Both lock in a design that is expensive to change after enrolment starts.

How long should EDC testing take?

It depends on the size of the build. What matters more is coverage: negative tests, every role and mid-study changes, not only the happy path. See the EDC UAT guide for a scope.

Who should sign off edit check ranges?

Usually the medical monitor or clinical lead, since ranges reflect clinical judgment. The data manager implements and tests them.

Can a small team avoid these mistakes without a data manager?

Yes, if someone owns the build baseline, role matrix and test plan, and if the system lets the team change forms directly. A free sandbox makes rehearsal cheap.

Do I need to validate the EDC myself?

Validation is a shared responsibility. Capture provides 21 CFR Part 11-aligned controls and, for enterprise customers, documentation to support sponsor validation and UAT. The sponsor remains responsible for validated use.

How do I handle protocol amendments after go-live?

Use a defined change process: request, impact assessment, test in the sandbox, approval, then a new approved form version. Capture forms move through draft and approved states with an audit trail.

Build it right the first time, free

Free sandbox with every feature. No credit card, and you pay only when you go live with real participants.

Rehearse your build free