Skip to main content

Reconciliation Platform

Overview​

The Reconciliation Platform is a powerful automated system for matching and reconciling financial data from multiple sources. It streamlines the process of comparing core banking data with external data sources (bank statements, payment gateways, etc.) to identify matches, discrepancies, and exceptions.

Key Features​

🔄 Automated Matching​

  • Rule-based auto-matching
  • Configurable matching criteria
  • Tolerance settings for amount differences
  • Multi-field matching support

📊 Dual Dataset Support​

  • Primary Dataset: Core banking data (internal)
  • Reference Dataset: External data (bank statements, partner systems)
  • Multiple data source support
  • Flexible data import formats

🎯 Smart Reconciliation​

  • Automatic match detection
  • Partial matching support
  • Many-to-one and one-to-many matching
  • Manual matching capability

📈 Status Tracking​

  • Pending: Awaiting matching
  • Matched: Successfully auto-matched
  • NoMatch: No match found
  • Manual: Manually reconciled
  • Ignored: Excluded from reconciliation

🔍 Audit Trail​

  • Complete reconciliation history
  • Match reasoning and scores
  • User actions tracking
  • Data lineage

Use Cases​

1. Bank Statement Reconciliation​

Match internal transactions with bank statements:

  • Daily bank reconciliation
  • Account balance verification
  • Transaction matching
  • Exception reporting

2. Payment Gateway Reconciliation​

Reconcile payment gateway transactions:

  • Online payment matching
  • Settlement reconciliation
  • Fee verification
  • Chargeback tracking

3. General Ledger Reconciliation​

Match transactions to GL accounts:

  • Account reconciliation
  • Balance verification
  • Period-end closing
  • Audit support

4. Inter-Branch Reconciliation​

Reconcile transactions between branches:

  • Branch transfer verification
  • Suspense account clearing
  • Inter-branch settlements

Reconciliation Flow​

Workflow Steps​

  1. Job Creation

    • Define reconciliation parameters
    • Set matching rules
    • Configure tolerances

  2. Data Upload

    • Upload primary dataset (internal data)
    • Upload reference dataset (external data)
    • Validate data format

  3. Auto-Matching

    • Apply matching rules
    • Calculate match scores
    • Auto-match qualifying records

  4. Manual Review

    • Review unmatched items
    • Manually match records
    • Mark items as ignored if needed

  5. Job Completion

    • Generate reconciliation report
    • Export results
    • Archive job data

Architecture​

Data Model​

// Reconciliation Job
{
  id: number,
  jobReference: string,
  status: "Active" | "Completed" | "Cancelled",
  createdDate: Date,
  completedDate: Date,
  totalRecords: number,
  matchedRecords: number,
  unmatchedRecords: number
}

// Reconciliation Job Data
{
  id: number,
  jobId: number,
  datasetType: "Primary" | "Reference",
  sourceCode: string,
  transactionReference: string,
  amount: number,
  transactionDate: Date,
  status: "Pending" | "Matched" | "NoMatch" | "Manual" | "Ignored",
  matchedWithId: number,
  matchScore: number,
  metadata: object
}

Matching Algorithm​

  1. Exact Match: All key fields match exactly
  2. Fuzzy Match: Fields match within tolerance
  3. Partial Match: Some fields match, requires review
  4. No Match: No matching record found

Dataset Types​

Primary Dataset​

Core banking internal data:

  • Transaction records
  • Account statements
  • Ledger entries
  • System-generated data

Example:

{
  "transactionReference": "TXN-20250126-001",
  "amount": 50000.00,
  "transactionDate": "2025-01-26",
  "accountNumber": "1234567890",
  "narration": "Transfer to savings"
}

Reference Dataset​

External data sources:

  • Bank statements
  • Payment gateway reports
  • Partner system data
  • Third-party records

Example:

{
  "statementReference": "STMT-456789",
  "amount": 50000.00,
  "valueDate": "2025-01-26",
  "accountNumber": "1234567890",
  "description": "Credit - transfer"
}

Matching Rules​

Configuration​

{
  "matchingRules": {
    "exactMatchFields": ["transactionReference"],
    "fuzzyMatchFields": [
      {
        "field": "amount",
        "tolerance": 0.01,
        "type": "absolute"
      },
      {
        "field": "transactionDate",
        "tolerance": 2,
        "type": "days"
      }
    ],
    "optionalFields": ["narration"],
    "minimumScore": 85
  }
}

Matching Criteria​

  • Amount: Match within tolerance (e.g., ±0.01)
  • Date: Match within date range (e.g., ±2 days)
  • Reference: Exact or partial reference match
  • Account: Account number match
  • Description: Keyword matching

Process Integration​

Reconciliation jobs can trigger BPM workflows:

Events​

  • OnReconciliationJobStart: Job initiated
  • OnReconciliationJobCompletion: Job completed
  • OnReconciliationDataUpdate: Data matched/updated
  • OnReconciliationError: Error occurred

Example Workflow Trigger​

{
  "event": "OnReconciliationJobCompletion",
  "condition": "unmatchedRecords > 0",
  "action": {
    "processKey": "RECONCILIATION_EXCEPTION_REVIEW",
    "context": {
      "jobId": "{{jobId}}",
      "unmatchedCount": "{{unmatchedRecords}}"
    }
  }
}

Quick Start Example​

Step 1: Create Job​

var job = doCmd('CreateReconciliationJobCommand', {
  Data: {
    jobReference: 'BANK-RECON-' + formatDate(new Date(), 'yyyyMMdd'),
    description: 'Daily bank reconciliation'
  }
});

Step 2: Upload Primary Data​

var primaryUpload = doCmd('UpdateReconciliationJobDataCommand', {
  Data: {
    jobId: job.data.id,
    dataSetType: 0, // Primary
    records: [
      {
        transactionReference: 'TXN-001',
        amount: 50000,
        transactionDate: '2025-01-26'
      }
    ]
  }
});

Step 3: Upload Reference Data​

var referenceUpload = doCmd('UpdateReconciliationJobDataCommand', {
  Data: {
    jobId: job.data.id,
    dataSetType: 1, // Reference
    sourceCode: 'BANK_STATEMENT',
    records: [
      {
        statementReference: 'STMT-001',
        amount: 50000,
        valueDate: '2025-01-26'
      }
    ]
  }
});

Step 4: Execute Matching​

var matchResult = doCmd('ExecReconciliationDataChainCommand', {
  Data: {
    jobId: job.data.id
  }
});

Best Practices​

✅ Do's​

  • Define clear matching rules
  • Set appropriate tolerance levels
  • Review unmatched items promptly
  • Maintain audit trail
  • Archive completed jobs
  • Test rules with sample data
  • Document reconciliation process

❌ Don'ts​

  • Don't use overly strict matching (causes false negatives)
  • Don't ignore unmatched items without investigation
  • Don't delete reconciliation jobs (archive instead)
  • Don't bypass manual review for exceptions
  • Don't use same job for different periods

Performance Tips​

  • Process reconciliations in batches
  • Archive old reconciliation data
  • Index frequently queried fields
  • Use appropriate date ranges
  • Optimize matching rules
  • Schedule jobs during off-peak hours

Next Steps​

Support​

For questions or issues with Reconciliation Platform: