Kanoniv vs AWS Entity Resolution

Bottom line: AWS Entity Resolution is a fully managed AWS service for matching records across S3/Glue data sources with rule-based, ML-based, and third-party provider matching. Kanoniv is a declarative identity resolution platform with golden records, offline-first development, and multi-cloud portability. Choose AWS ER if you're already deep in the AWS analytics stack and want a point-and-click solution; choose Kanoniv if you need golden records, local development, or want to avoid AWS lock-in.

At a Glance

	Kanoniv	AWS Entity Resolution
Type	Identity resolution platform	Managed AWS service
Approach	Declarative rules (YAML spec)	Rule-based, ML-based, or provider-based
Deployment	Local SDK + Cloud (any infra)	AWS only
Configuration	YAML file (version-controlled)	Console UI / CloudFormation / Boto3
Golden Records	Yes (survivorship strategies)	No (match groups only; needs Glue ETL post-processing)
Real-time API	Yes (sub-ms)	Near real-time (Generate Match ID API)
Multi-tenant	Yes (RLS isolation)	No (single AWS account per workflow)
HIPAA	Yes	Yes (eligible since Nov 2023)
Free SDK	Yes (local engine included)	No
Pricing	Free tier + usage-based	$0.25 per 1K records processed (no free tier)

Feature Comparison

Feature	Kanoniv	AWS Entity Resolution
Deterministic matching	Yes	Yes (rule-based, exact)
Fuzzy matching	Yes (Jaro-Winkler, Levenshtein, phonetic)	Yes (Levenshtein, Cosine, Soundex -- Advanced rules)
Probabilistic matching	Yes (Fellegi-Sunter with EM)	Yes (pre-trained model, confidence scores)
Provider matching	No	Yes (LiveRamp, TransUnion, UID 2.0)
Survivorship / golden records	Yes (source priority, recency, aggregation)	No (match groups with IDs; golden records require separate Glue ETL)
Identity graph	Yes (persistent, queryable)	No (relies on external providers)
Real-time resolution API	Yes (sub-millisecond)	Near real-time (Generate Match ID API)
Batch processing	Yes	Yes (primary mode)
Incremental processing	Yes	Yes (automatic for rule-based)
Multi-tenant isolation	Yes (row-level security)	No
Audit logs	Yes (immutable, with reason codes)	Yes (CloudTrail)
HIPAA compliance	Yes (PII masking, retention policies)	Yes (eligible with BAA)
Data normalization	Configurable in spec	Yes (built-in, automatic)
Cross-account collaboration	N/A	Yes (via Clean Rooms)
Warehouse integration	Snowflake, dbt	AWS Glue, S3 only
Local development	Yes (full offline reconciliation)	No (requires AWS account and infra)
Version-controlled config	Yes (YAML in git)	Partial (CloudFormation/Terraform)
Free local SDK	Yes	No
Cloud lock-in	None	AWS only

Code Comparison

Kanoniv: YAML spec + Python SDK

# customer-spec.yaml
entity:
  name: customer
sources:
  - name: crm
    adapter: csv
    location: contacts.csv
    primary_key: id
  - name: billing
    adapter: csv
    location: stripe.csv
    primary_key: id
rules:
  - name: email_exact
    type: exact
    field: email
    weight: 1.0
  - name: name_phone
    type: composite
    operator: and
    children:
      - type: jaro_winkler
        field: name
        threshold: 0.9
      - type: exact
        field: phone
survivorship:
  strategy: source_priority
  priority: [crm, billing]
decision:
  thresholds:
    match: 0.85

from kanoniv import Spec, Source, reconcile, validate

spec = Spec.from_file("customer-spec.yaml")
validate(spec).raise_on_error()

sources = [
    Source.from_csv("crm", "contacts.csv"),
    Source.from_csv("billing", "stripe.csv"),
]
result = reconcile(sources, spec)
print(f"Golden records: {len(result.golden_records)}")
print(f"Merge rate: {result.merge_rate:.1%}")

AWS Entity Resolution: Boto3 SDK

import boto3

client = boto3.client('entityresolution')

# Step 1: Create schema mapping
client.create_schema_mapping(
    schemaName='customer_schema',
    mappedInputFields=[
        {'fieldName': 'full_name', 'type': 'NAME', 'matchKey': 'name_key'},
        {'fieldName': 'email', 'type': 'EMAIL_ADDRESS', 'matchKey': 'email_key'},
        {'fieldName': 'phone', 'type': 'PHONE_NUMBER', 'matchKey': 'phone_key'},
    ]
)

# Step 2: Create matching workflow
client.create_matching_workflow(
    workflowName='customer_matching',
    roleArn='arn:aws:iam::123456789012:role/EntityResolutionRole',
    inputSourceConfig=[{
        'inputSourceARN': 'arn:aws:glue:us-east-1:123456789012:table/mydb/customers',
        'schemaName': 'customer_schema',
        'applyNormalization': True,
    }],
    outputSourceConfig=[{
        'outputS3Path': 's3://my-bucket/output/',
        'output': [
            {'name': 'full_name', 'hashed': False},
            {'name': 'email', 'hashed': False},
        ],
        'applyNormalization': True,
    }],
    resolutionTechniques={
        'resolutionType': 'RULE_MATCHING',
        'ruleBasedProperties': {
            'rules': [
                {'ruleName': 'Rule1', 'matchingKeys': ['email_key']},
                {'ruleName': 'Rule2', 'matchingKeys': ['name_key', 'phone_key']},
            ],
            'attributeMatchingModel': 'ONE_TO_ONE',
        }
    }
)

# Step 3: Run the workflow
client.start_matching_job(workflowName='customer_matching')

# Output: match groups written to S3 with match IDs
# Golden records require a SEPARATE Glue ETL job

When to Choose AWS Entity Resolution

• You're already deep in the AWS analytics stack (Glue, S3, Lake Formation, Redshift)
• You want no infrastructure to manage -- fully serverless matching
• You need ML-based matching with confidence scores and no model training
• You need third-party identity providers (LiveRamp, TransUnion, UID 2.0) for ad-tech or marketing
• You need HIPAA-eligible matching with a BAA from AWS
• You want cross-account data collaboration via AWS Clean Rooms
• You need automatic incremental matching triggered by new S3 data arrivals

When to Choose Kanoniv

• You need golden records with survivorship out of the box -- AWS ER produces match groups but golden records require a separate Glue ETL pipeline you build yourself
• You want to develop and test locally before deploying to production -- AWS ER requires an AWS account for any matching
• You want to avoid AWS lock-in -- Kanoniv works with any infrastructure, any cloud, or no cloud
• You need multi-tenant isolation for a SaaS product
• You want version-controlled matching logic in a YAML file, not scattered across CloudFormation resources
• You need to integrate with Snowflake or dbt (not just AWS Glue/S3)
• You want a free tier for production use -- AWS ER has no free tier and charges $0.25/1K records per run
• You want transparent, inspectable matching logic with explainable decisions

Key Differences Explained

Managed Service vs Platform

AWS Entity Resolution is a fully managed, serverless service. You don't provision infrastructure, scale compute, or manage state. You define schemas, workflows, and rules through the console or API, and AWS handles execution.

Kanoniv is a platform with two deployment modes: the Python SDK runs locally (zero infrastructure), and Kanoniv Cloud provides managed infrastructure. The key difference is portability -- your YAML spec works identically in both environments and isn't coupled to any cloud provider.

Golden Records

AWS Entity Resolution outputs match groups: sets of records that the service believes refer to the same entity, each tagged with a match ID. Creating golden records from these groups requires building a separate AWS Glue ETL job with your own survivorship logic. AWS documents this as a "post-processing" step.

Kanoniv includes survivorship as a first-class concept. You declare the strategy in your spec (source priority, recency, aggregation), and the engine produces golden records automatically during reconciliation.

Cost at Scale

AWS ER charges $0.25 per 1,000 records processed -- all records, whether they match or not. At 10M records, that's $2,500 per run. If you run daily incremental matching on 100K new records, that's ~$750/month.

Kanoniv's local SDK is free for any volume. Kanoniv Cloud uses usage-based pricing that starts with a free tier suitable for production workloads.

Local Development

There is no way to run AWS Entity Resolution locally. Every test, every experiment, every iteration requires an AWS account, IAM roles, Glue crawlers, and S3 buckets. The feedback loop is slow and expensive.

Kanoniv's SDK runs entirely offline. You can validate specs, plan execution, and reconcile data on your laptop in seconds. When you're ready for production, deploy the same spec to Kanoniv Cloud.