Data Quality Scoring for Email Lists: Frameworks, Metrics and Implementation

Why Score Data Quality

Most organisations describe their data quality as "good" or "bad" without measuring it. This makes it impossible to prioritise improvement, track progress or justify investment in data cleaning.

A data quality score assigns a number to each record, segment or list. That number tells you:

• Which records need attention. Sort by score and clean the worst records first.
• Which sources produce good data. Compare scores by acquisition source to identify the best and worst channels.
• Whether quality is improving or declining. Track the average score over time.
• When to stop cleaning. Diminishing returns become visible when the score plateaus.
• What the business impact is. Correlate quality scores with deliverability, engagement and conversion.

Scoring Dimensions

Data quality is not a single attribute. It has multiple dimensions, each of which can be measured and scored independently.

Completeness

Does the record have all the fields you need?

Completeness score = sum of (field present x weight) / sum of weights

Example: a record with email, first name, last name and company but missing job title, phone, industry and location:

• Weighted sum: 1(required) + 1(high) + 1(high) + 1(medium) + 0(medium) + 0(low) + 0(low) + 0(low) = meets required, weighted completeness depends on your scheme.

Validity

Is the data in the correct format and does it represent a real value?

Accuracy

Does the data reflect reality?

This is the hardest dimension to measure because it requires external verification:

• Does the person still work at the listed company?
• Is the job title current?
• Is the phone number still active?
• Is the address correct?

Proxy measures for accuracy:

• Recency of verification. Verified in the last 30 days = 1, 30-90 days = 0.8, 90-180 days = 0.6, over 180 days = 0.4, never = 0.2.
• Engagement history. Opened or clicked in the last 90 days = 1 (proves the address is real and active), 90-180 days = 0.7, over 180 days = 0.4, never engaged = 0.2.
• Bounce history. Never bounced = 1, soft bounced once = 0.7, soft bounced multiple times = 0.3, hard bounced = 0.

Consistency

Is the data formatted consistently across the list?

Consistency scoring: compare each field value against the standard format. Matches = 1, does not match = 0.

Uniqueness

Are there duplicate records?

• Unique record = 1.
• Duplicate record = 0.

Upload your lists to Email Extractor for case-insensitive deduplication across all your source files. See How Email Deduplication Works.

Timeliness

How current is the data?

Building a Scoring Model

Step 1: Define dimensions and weights

Not every dimension matters equally for every use case. Assign weights based on your business:

For cold email outreach:

For CRM data management:

Step 2: Score individual records

Calculate a score for each record:

Record score = sum of (dimension score x dimension weight)

Example record:

Step 3: Set thresholds

Step 4: Score the list

Aggregate individual scores to get a list-level score:

Healthy list benchmarks:

Implementation

Spreadsheet approach (small lists)

For lists under 10,000 records, a spreadsheet works:

1. Export your list with all fields.
2. Add columns for each dimension score.
3. Add formulas to calculate dimension scores:
   • Completeness: =COUNTA(B2:H2)/7 (count non-empty fields / total fields).
   • Validity: manual or based on verification results imported from a service.
   • Consistency: =IF(EXACT(B2, PROPER(B2)), 1, 0) (checks name capitalisation).
4. Add a weighted total column: =SUMPRODUCT(scores, weights).
5. Add a quality tier column: =IF(total>=0.85, "Excellent", IF(total>=0.7, "Good", ...)).

Python approach (larger lists)

import pandas as pd
import re

def score_record(row):
    scores = {}

    # Completeness
    fields = ['first_name', 'last_name', 'company', 'title', 'phone', 'industry']
    weights = [0.25, 0.25, 0.2, 0.15, 0.1, 0.05]
    completeness = sum(
        w for f, w in zip(fields, weights)
        if pd.notna(row.get(f)) and str(row.get(f)).strip()
    )
    scores['completeness'] = completeness

    # Validity (email)
    email = str(row.get('email', ''))
    if re.match(r'^[\w.-]+@[\w.-]+\.\w+$', email):
        scores['validity'] = 1.0
    else:
        scores['validity'] = 0.0

    # Uniqueness (requires checking against full dataset, simplified here)
    scores['uniqueness'] = row.get('is_unique', 1.0)

    # Consistency
    first = str(row.get('first_name', ''))
    last = str(row.get('last_name', ''))
    name_consistent = 1.0 if (first == first.title() and last == last.title()) else 0.5
    email_consistent = 1.0 if email == email.lower() else 0.5
    scores['consistency'] = (name_consistent + email_consistent) / 2

    # Timeliness (based on a 'date_added' field)
    # Simplified: would calculate days since date_added
    scores['timeliness'] = row.get('timeliness_score', 0.5)

    # Accuracy (based on engagement data)
    scores['accuracy'] = row.get('accuracy_score', 0.5)

    # Weighted total
    dimension_weights = {
        'validity': 0.35,
        'accuracy': 0.25,
        'completeness': 0.20,
        'uniqueness': 0.10,
        'consistency': 0.05,
        'timeliness': 0.05
    }

    total = sum(scores[d] * dimension_weights[d] for d in dimension_weights)
    return total

# Apply to dataframe
df = pd.read_csv('email_list.csv')
df['quality_score'] = df.apply(score_record, axis=1)
df['quality_tier'] = pd.cut(
    df['quality_score'],
    bins=[0, 0.3, 0.5, 0.7, 0.85, 1.0],
    labels=['Critical', 'Poor', 'Fair', 'Good', 'Excellent']
)

CRM-native scoring

Some CRMs and data quality tools offer built-in scoring:

Monitoring and Reporting

Dashboard metrics

Track these metrics over time:

Alerting

Set up alerts for:

• Average quality score drops below 0.70.
• More than 15% of records fall into "Poor" or "Critical."
• A new data source produces records with an average score below 0.60.
• The percentage of sendable records drops below 75%.
• A specific segment's quality drops significantly.

Reporting cadence

Continuous Improvement

Using scores to prioritise cleaning

1. Sort records by quality score (ascending).
2. Identify the most common issues among low-scoring records.
3. Address the highest-impact issue first (the one that affects the most records).
4. Re-score after cleaning to measure improvement.
5. Track the cost per point of quality improvement (time and money spent vs score increase).

Preventing quality decay

Quality decays naturally. People change jobs, companies, email addresses and phone numbers. Prevention is cheaper than cleaning:

• Validate data at the point of entry (form validation, API verification).
• Verify the full list quarterly.
• Remove hard bounces immediately.
• Re-engage or suppress inactive contacts.
• Enrich records periodically (update company, title, phone).
• Score new records on import and reject imports below a threshold.

Benchmarking

Compare your scores to industry benchmarks:

These are illustrative ranges based on the scoring framework above, not from a specific published study. Your results will depend on your sources, industry and cleaning practices.

Related Guides

• Data Quality Metrics for Email Lists
• Building a Data Quality Programme
• How to Clean an Email List
• Automating Data Validation for Email Lists
• CRM Data Hygiene Guide