Finacle or TCS BaNC

🏦 1️⃣ Finacle (Core Banking System – CBS)

Finacle

Finacle is a Core Banking System (CBS).It is the system of record for:

• Customer master

• Accounts (CASA, FD, RD, Loans)

• GL & accounting

• Interest calculations

• Transactions posting

• Regulatory reporting base data

💡 Important Architecture Principle:

CBS owns the balance and accounting truth.Everything else surrounds it.

Think of CBS as the heart, and other systems as organs connected through arteries (APIs, MQ, files).

🧩 2️⃣ CBS Integration Patterns

There are 5 major integration patterns used with Finacle.

🔹 Pattern 1: Synchronous API (Real-Time)

Used when immediate response is required.

Example:

Customer applies for personal loan → LOS calls Finacle →

• Check customer CIF

• Check liabilities

• Validate KYC

• Block lien

• Open loan account

Flow:

LOS → API Gateway → ESB/Middleware → Finacle API → Response → LOS

✔ Used for:

• Balance enquiry

• Account creation

• Fund transfer

• Real-time limit validation

✔ Pros:

• Immediate confirmation

• Better UX

⚠ Cons:

• Tight coupling

• Dependency on CBS uptime

🔹 Pattern 2: Asynchronous (Event / MQ Based)

Used when immediate response is not mandatory.

Example:

Loan disbursement completed →Event published →LMS / CRM / Reporting consumes event.

Flow:

Finacle → Event Bus (Kafka / MQ) → Downstream Systems

✔ Used for:

• Notifications

• CRM updates

• Analytics

• Audit trail

✔ Pros:

• Decoupled systems

• Resilient

• Scalable

⚠ Cons:

• Eventual consistency

🔹 Pattern 3: Batch File-Based Integration

Old but still heavily used.

Example:

• EOD GL extract

• NPA marking

• Regulatory reporting

• Bulk interest application

Flow:

Finacle → SFTP → Batch Processor → Target System

✔ Used for:

• Regulatory reporting

• Data warehouse loads

• Reconciliation

✔ Pros:

• Handles large volumes

• Simpler

⚠ Cons:

• Delayed updates

• Not real-time

🔹 Pattern 4: Database-Level Integration (Avoided Today)

Older systems used direct DB read.

⚠ Not recommended in modern banking:

• Security risk

• Upgrade impact

• Vendor support issues

Modern banks prefer API-first.

🔹 Pattern 5: Microservices Wrapper Around CBS

Modern pattern.

You create a digital abstraction layer over Finacle.

Channel → Digital Microservice → API Gateway → Finacle

This prevents:

• Direct CBS exposure

• Overloading CBS

• Tight coupling

This is common in modernization programs.

🧱 3️⃣ Surround Systems Around CBS

Now let’s go one by one.

🏦 LOS – Loan Origination System

Purpose:

• Customer onboarding

• Credit underwriting

• Document capture

• Eligibility calculation

Integration with CBS:

• Customer CIF check (real-time)

• Loan account creation (real-time)

• Status updates (async)

LOS = Pre-disbursement systemCBS = Financial booking system

📊 LMS – Loan Management System

Purpose:

• EMI schedule

• Restructuring

• Delinquency tracking

• Collections

Integration:

• Repayment posting → real-time

• DPD updates → batch

• NPA marking → batch

Sometimes LMS is merged with CBS.Sometimes external (e.g., retail lending stack).

👤 CRM – Customer Relationship Management

Purpose:

• 360° customer view

• Sales tracking

• Cross-sell

Integration:

• CIF creation event

• Account opening event

• Transaction alerts

Mostly event-driven (async).

🔎 AML – Anti-Money Laundering

Purpose:

• Suspicious transaction detection

• Regulatory compliance

Integration:

• Real-time transaction screening

• Batch monitoring

• Sanction list matching

High sensitivity.Usually hybrid (real-time + batch).

💳 Payments System

Purpose:

• NEFT / RTGS / UPI / IMPS

• Card processing

Integration:

• Real-time debit validation

• Real-time balance check

• End-of-day settlement batch

Payments must be real-time, but reconciliation is batch.

⚡ 4️⃣ Real-Time vs Batch Integration (Deep Comparison)

Feature	Real-Time	Batch
Response	Immediate	Delayed
Use Case	Balance check, debit	Reporting, EOD
Coupling	Tight	Loose
Risk	CBS downtime impacts flow	Safer
Performance	Lower volume	High volume
Consistency	Strong	Eventual

🔥 When to Use Real-Time

Use when:

• Customer is waiting

• Money movement happens

• Regulatory validation needed

• Fraud check required

Example:UPI debit → Must validate balance instantly.

🌙 When to Use Batch

Use when:

• No customer impact

• Large volume

• Heavy compute

• Historical reporting

Example:Interest calculation for 20 million accounts.

🏗 5️⃣ Modern Target Architecture (Ideal)

In modernization programs (especially cloud-based):

Channels
   ↓
API Gateway
   ↓
Digital Microservices Layer
   ↓
Event Bus
   ↓
Finacle (CBS)

Surround systems subscribe via events.

This gives:

• Loose coupling

• Cloud scalability

• Faster product launch

• CBS protection

🎯

“CBS like Finacle should remain the system of record. Surround systems should integrate via API-first and event-driven architecture. Real-time should be limited to balance-impacting transactions, while analytics and regulatory processes should move to async or batch for scalability.”

🏦 How Do You Modernize Around Finacle Without Disturbing the Core?

Finacle

First principle:

Do not touch the core unless absolutely necessary.Modernize around it, not inside it.

Finacle remains the system of record.Everything else evolves around it.

🔷 1️⃣ Establish a Digital Abstraction Layer

Problem:

Channels directly calling Finacle → tight coupling → performance risk → upgrade dependency.

Solution:

Introduce a Digital Services Layer (DSL).

Mobile / Web / Branch
        ↓
API Gateway
        ↓
Digital Microservices Layer
        ↓
Finacle APIs

Why this works:

• CBS is shielded

• Channels don’t depend on Finacle schema

• You can change UX without touching core

• Future core replacement becomes easier

This is the strangler pattern for core banking.

🔷 2️⃣ API-First, Not DB-First

Never allow:

• Direct DB reads

• Custom SQL hacks

• Stored procedure dependencies

Instead:

• Use Finacle APIs

• Wrap them with your own microservices

• Add transformation layer

You decouple domain logic from CBS structure.

🔷 3️⃣ Move Non-Financial Workloads Outside

Finacle should only handle:

• Balance updates

• GL posting

• Regulatory accounting

• Core transaction posting

Move outside:

• Customer 360

• Campaign management

• Analytics

• Notifications

• Eligibility engines

• Product configuration logic

This reduces:

• Core load

• Upgrade risk

• Batch window pressure

🔷 4️⃣ Introduce Event-Driven Architecture

Instead of polling Finacle:

Finacle → Event → Kafka/Event Bus → Downstream Systems

Examples:

• Account opened → CRM updated

• EMI paid → Collections updated

• Transaction done → AML screened

This ensures:

• Loose coupling

• Real-time propagation

• No CBS overload

🔷 5️⃣ Carve Out Microservices Gradually

Use domain decomposition:

Start with:

• Limits service

• Customer profile service

• Fees engine

• Document service

• Notification service

Gradually reduce business logic dependency on CBS.

Over time:CBS becomes ledger engine.

🔷 6️⃣ Reduce Batch Dependency

Legacy model:

• Heavy EOD

• Overnight reconciliation

• Batch GL posting

Modern model:

• Near real-time posting

• Event-based reconciliation

• Incremental processing

Goal:Shrink EOD window without touching core algorithms.

🔷 7️⃣ Use Middleware as Shock Absorber

Introduce:

• ESB or lightweight integration layer

• API Gateway

• Circuit breaker

• Rate limiter

This protects Finacle from:

• Traffic spikes

• Retry storms

• Channel bugs

🔷 8️⃣ Upgrade Without Impact Strategy

Before any Finacle upgrade:

• Freeze contract at API layer

• Regression test only wrapper layer

• Avoid customizations inside Finacle

• Keep core vanilla as much as possible

Customization inside CBS = modernization killer.

🧠 Architecture Vision (Target State)

                Channels
                    ↓
              API Gateway
                    ↓
        Digital Microservices Layer
                    ↓
              Event Streaming
                    ↓
                Finacle
           (Ledger & Accounting Only)

Core becomes:✔ Stable✔ Minimal customization✔ Ledger-centric

Digital innovation happens outside.

🔥 Risk Areas You Must Manage

Risk	Mitigation
Performance bottleneck	Caching layer
Duplicate transactions	Idempotency keys
Retry storms	Exponential backoff
Data mismatch	Reconciliation microservice
Upgrade breakage	Contract testing

🎯

“Our modernization approach preserves Finacle as a stable ledger engine while shifting innovation to an API-driven, event-enabled digital layer. This reduces upgrade risk, improves scalability, and allows faster product launches without destabilizing the core.”