> ## Documentation Index
> Fetch the complete documentation index at: https://grandcentral.backbase.io/llms.txt
> Use this file to discover all available pages before exploring further.
# Sync Hub use cases
> Real-world banking scenarios demonstrating Sync Hub integration patterns in action
See how Sync Hub solves real-world banking data synchronization challenges across different scenarios. Each use case demonstrates practical applications of the integration patterns.
## Customer data synchronization
Synchronize customer profiles across branch systems, CRM, and digital channels in real-time.
### The challenge
Customer profile information originates from multiple sources - branch systems, call centers, digital channels, and third-party services. Keeping all systems synchronized in real-time while maintaining data quality and consistency is critical for delivering unified customer experiences.
**Business impact:**
* Inconsistent customer data across channels leads to poor experiences
* Manual data reconciliation is time-consuming and error-prone
* Delays in synchronization affect compliance and risk management
* Multiple point-to-point integrations increase complexity
### The solution
```mermaid theme={"system"}
%%{init: {
'theme': 'base',
'themeVariables': {
'primaryColor': '#ffffff',
'primaryBorderColor': '#295eff',
'primaryTextColor': '#091c35',
'lineColor': '#091c35',
'secondaryColor': '#f3f6f9',
'tertiaryColor': '#ebf0f5',
'fontFamily': 'Libre Franklin, sans-serif'
}
}}%%
graph TD
A[Branch system] -->|File upload| B[File processor]
C[CRM] -->|Webhook| D[Webhook connector]
E[Digital banking] -->|API event| F[Event publisher]
B & D & F -->|Publish| G[Sync Hub]
G -->|Distribute| H[Core banking]
G -->|Distribute| I[Digital channels]
G -->|Distribute| J[Marketing platform]
G -->|Distribute| K[Compliance systems]
```
**Integration patterns used:**
* File processing for batch updates from branch system
* Webhooks for real-time CRM updates
* Event publishing from digital banking changes
* Multi-consumer distribution to all downstream systems
**Example: Customer Address Change**
1. **Customer initiates change** in branch system
2. **Branch system** publishes update via daily batch file
3. **File processor** detects file, parses customer records
4. **Enrichment** adds account associations and preferences
5. **Sync Hub** distributes to all consuming systems:
* Core Banking: Update master record
* Digital Banking: Refresh profile display
* Marketing: Update segmentation
* Compliance: KYC record update
* Document Management: Update mailing address
**Customer experience:**
* Immediate profile synchronization across all channels
* Consistent information regardless of touchpoint
* Reduced customer inquiries about data discrepancies
**Operational efficiency:**
* Eliminated manual data reconciliation processes
* Single source of truth for customer data
* Automated compliance updates
**Risk reduction:**
* Real-time KYC/AML data synchronization
* Complete audit trail for all customer data changes
* Improved regulatory compliance capabilities
## Real-time transaction distribution
Distribute transaction data across channels, fraud detection, and analytics systems in real-time.
### The challenge
Transactions occur across multiple channels - ATMs, point-of-sale, online banking, mobile apps. Each transaction must be visible immediately in digital channels, analyzed for fraud, recorded for compliance, and available for customer service - all in real-time.
**Business impact:**
* Delayed transaction visibility frustrates customers
* Fraud detection requires immediate transaction data
* Multiple system queries create performance bottlenecks
* Point-to-point integrations are fragile and hard to maintain
### The solution
```mermaid theme={"system"}
%%{init: {
'theme': 'base',
'themeVariables': {
'primaryColor': '#ffffff',
'primaryBorderColor': '#295eff',
'primaryTextColor': '#091c35',
'lineColor': '#091c35',
'secondaryColor': '#f3f6f9',
'tertiaryColor': '#ebf0f5',
'fontFamily': 'Libre Franklin, sans-serif'
}
}}%%
graph TD
A[Core banking] -->|Kafka events| B[Event consumer]
C[Card processor] -->|Webhooks| D[Webhook connector]
E[Payment gateway] -->|JMS queue| F[Message consumer]
B & D & F -->|Publish| G[Sync Hub]
G -->|Distribute| H[Digital banking UI]
G -->|Distribute| I[Fraud detection]
G -->|Distribute| J[Transaction enrichment]
G -->|Distribute| K[CRM dashboard]
G -->|Distribute| L[Analytics platform]
```
**Integration patterns used:**
* Event streaming from core banking Kafka
* Webhooks from card processor
* Message consumers for payment gateway
* Multi-consumer distribution (5+ consuming systems)
**Example: ATM Withdrawal**
1. **ATM transaction** processed by core banking
2. **Core banking** publishes transaction event to Kafka
3. **Event consumer** reads from Kafka, validates schema
4. **Transformation** converts to canonical transaction format
5. **Sync Hub** distributes to all consumers simultaneously:
* **Digital banking:** Display in transaction history (\< 1 second)
* **Fraud detection:** Analyze for suspicious patterns (\< 2 seconds)
* **Transaction enrichment:** Categorize and enrich
* **CRM:** Update customer interaction timeline
* **Analytics:** Add to data warehouse for reporting
**Customer experience:**
* Real-time transaction visibility across all channels
* Immediate fraud alerts and notifications
* Consistent balance information regardless of touchpoint
**Fraud prevention:**
* Real-time fraud detection and prevention capabilities
* Faster detection through immediate data distribution
* Immediate account holds when suspicious activity detected
**Operational efficiency:**
* Single integration point replacing multiple point-to-point connections
* Reduced system load from duplicate API calls
* Centralized monitoring and observability
## Payment processing integration
Orchestrate payment lifecycle events across processors, digital channels, and accounting systems.
### The challenge
Payment processors like Alacriti and Volante send status updates via multiple channels - webhooks for real-time notifications, daily settlement files, and event streams for transaction lifecycle. Each requires different handling but must result in consistent payment status across all systems.
**Business impact:**
* Multiple integration points create complexity and maintenance burden
* Payment status updates must be immediate for customer notifications
* Settlement reconciliation requires batch file processing
* Compliance requires complete audit trail of all payment activities
### The solution
```mermaid theme={"system"}
%%{init: {
'theme': 'base',
'themeVariables': {
'primaryColor': '#ffffff',
'primaryBorderColor': '#295eff',
'primaryTextColor': '#091c35',
'lineColor': '#091c35',
'secondaryColor': '#f3f6f9',
'tertiaryColor': '#ebf0f5',
'fontFamily': 'Libre Franklin, sans-serif'
}
}}%%
graph TB
A[Alacriti/Volante] -->|Webhooks| B[Webhook endpoints]
A -->|SFTP| C[Settlement files]
A -->|Kafka| D[Transaction events]
B -->|Real-time status| E[Webhook processor]
C -->|Batch processing| F[File processor]
D -->|Event stream| G[Event consumer]
E & F & G -->|Publish| H[Sync Hub]
H -->|Distribute| I[Digital banking]
H -->|Distribute| J[CRM]
H -->|Distribute| K[Accounting]
H -->|Distribute| L[Reconciliation]
```
**Integration patterns used:**
* Webhooks for real-time payment status updates
* File processing for daily settlement files
* Event streaming for transaction lifecycle events
* Event Enrichment to add customer/account context
* Multi-consumer distribution to all systems
**Example: Wire Transfer Lifecycle**
**Real-Time Updates (Webhooks):**
1. Payment initiated → Webhook notification
2. Payment sent to processor → Webhook notification
3. Payment completed/failed → Webhook notification
**Batch processing (files):**
1. Daily settlement file arrives via SFTP at 2:00 AM
2. File processor validates and parses 10,000+ transactions
3. Events generated for each settlement record
**Event stream (Kafka):**
1. Processor publishes lifecycle events to Kafka
2. Event consumer reads and transforms to canonical format
**All sources → Sync Hub:**
* Deduplicate events from multiple sources
* Enrich with customer and account information
* Distribute to digital banking, CRM, accounting, reconciliation
**Customer experience:**
* Real-time payment status notifications
* Immediate visibility of payment completion
* Reduced payment status inquiries to support
**Operational efficiency:**
* Automated settlement reconciliation
* Single integration framework for multiple patterns
* Faster onboarding of new payment processors
**Compliance and Audit:**
* Complete audit trail of all payment activities
* Automated compliance reporting
* Consistent data for regulatory submissions
## Account update propagation
Propagate account status changes and lifecycle events across all consuming systems.
### The challenge
Account status changes, balance updates, and service modifications must propagate instantly to all systems. Delays cause inconsistent account information, failed transactions, and poor customer experiences.
**Business impact:**
* Account holds not reflected immediately cause failed transactions
* Balance updates delayed lead to overdraft issues
* Service changes (card activated, account closed) take too long to propagate
* Customer frustration from inconsistent account information
### The solution
```mermaid theme={"system"}
%%{init: {
'theme': 'base',
'themeVariables': {
'primaryColor': '#ffffff',
'primaryBorderColor': '#295eff',
'primaryTextColor': '#091c35',
'lineColor': '#091c35',
'secondaryColor': '#f3f6f9',
'tertiaryColor': '#ebf0f5',
'fontFamily': 'Libre Franklin, sans-serif'
}
}}%%
graph LR
A[Core banking] -->|Account events| B[Event consumer]
B -->|Transform| C[Account event publisher]
C -->|Publish| D[Sync Hub]
D -->|Distribute| E[Digital banking]
D -->|Distribute| F[Card management]
D -->|Distribute| G[Loan origination]
D -->|Distribute| H[CRM]
D -->|Distribute| I[Fraud prevention]
```
**Integration patterns used:**
* Event streaming from core banking
* Real-time event processing
* Multi-consumer distribution
* Guaranteed delivery to critical systems
**Example: Account Freeze Due to Fraud**
1. **Fraud system** detects suspicious activity
2. **Core banking** places immediate hold on account
3. **Account event** published to Sync Hub within 500ms
4. **Sync Hub distributes** to all systems simultaneously:
* **Digital Banking:** Prevent new transactions, show alert
* **Card Management:** Block card usage immediately
* **ATM Network:** Update ATM authorization rules
* **CRM:** Alert customer service team
* **Fraud System:** Confirm hold placement
5. **Complete propagation** within 2 seconds total
**Risk management** - benefits include:
* near-instant account holds for fraud prevention
* Significantly reduced fraud exposure through faster propagation
* Real-time synchronization across all transaction channels
**Customer experience:**
* Immediate balance updates across all channels
* Consistent account status information
* Reduced transaction declines from stale data
**Operational efficiency:**
* Eliminated manual account synchronization processes
* Reduced support calls related to account discrepancies
* Automated compliance reporting for account status changes
## Batch payment file integration
Process batch payment files and distribute results to originating systems and accounting.
### The challenge
Corporate customers submit bulk payment files containing thousands of payment orders. Each file requires validation, individual payment creation, processing orchestration, and results file generation - all while maintaining audit trail and handling errors gracefully.
**Business impact:**
* Manual file processing is time-consuming and error-prone
* Lack of real-time status updates frustrates corporate customers
* Error handling requires manual intervention
* Results file generation delays cause reconciliation issues
### The solution
```mermaid theme={"system"}
%%{init: {
'theme': 'base',
'themeVariables': {
'primaryColor': '#ffffff',
'primaryBorderColor': '#295eff',
'primaryTextColor': '#091c35',
'lineColor': '#091c35',
'secondaryColor': '#f3f6f9',
'tertiaryColor': '#ebf0f5',
'fontFamily': 'Libre Franklin, sans-serif'
}
}}%%
graph TD
A[Corporate customer] -->|SFTP upload| B[Secure file storage]
B -->|File detected| C[File processor]
C -->|Validate file| D[Generate payment events]
D -->|Publish each payment| E[Sync Hub]
E -->|Distribute| F[Payment order service]
E -->|Distribute| G[Approval workflow]
E -->|Distribute| H[CRM notification]
F -->|Process| I[Payment processor]
I -->|Status updates| J[Webhook connector]
J -->|Publish status| E
E -->|Status distribution| K[Results file generator]
```
**Integration patterns used:**
* File processing for bulk payment files
* Event generation for each payment order
* Multi-consumer distribution for orchestration
* Webhooks for payment status updates
* File generation for results delivery
**Example: Corporate Payroll File (5,000 payments)**
**Inbound processing** - the flow is:
1. Corporate customer uploads payroll file via SFTP
2. File processor validates file structure and format
3. Individual payment events created for each record
4. Events published to Sync Hub for distribution
**Payment processing** - the flow is:
1. Payment Order Service receives each payment event
2. Approval Workflow evaluates against rules and limits
3. Approved payments sent to payment processor
4. Payment processor sends status updates via webhooks
**Status tracking and results** - the flow is:
1. Status updates received for each payment (success/failure)
2. Results aggregated by Results File Generator
3. Results file generated and delivered via SFTP
4. Corporate customer notified of completion
**Timeline:** Rapid parallel processing of thousands of payments
**Processing efficiency** - benefits include:
* Automated validation significantly reduces errors
* Dramatically faster processing through parallel execution
* Scalable handling of large payment files
**Customer experience:**
* Real-time status tracking during processing
* Immediate notification of file acceptance/rejection
* Detailed results file with line-by-line status
**Operational benefits** - benefits include:
* Eliminated manual file processing
* Automated error handling and recovery
* Complete audit trail for compliance
* Reduced support burden for bulk payment inquiries
## Real-time notification distribution
Distribute alerts and notifications across multiple customer communication channels.
### The challenge
Critical notifications - fraud alerts, large withdrawals, low balance warnings, loan approvals - must reach customers immediately across multiple channels while being logged for compliance and triggering appropriate workflows.
**Business impact:**
* Delayed notifications reduce fraud prevention effectiveness
* Multiple notification systems create inconsistent experiences
* Compliance requires audit trail of all customer communications
* Manual notification triggering is slow and error-prone
### The solution
```mermaid theme={"system"}
%%{init: {
'theme': 'base',
'themeVariables': {
'primaryColor': '#ffffff',
'primaryBorderColor': '#295eff',
'primaryTextColor': '#091c35',
'lineColor': '#091c35',
'secondaryColor': '#f3f6f9',
'tertiaryColor': '#ebf0f5',
'fontFamily': 'Libre Franklin, sans-serif'
}
}}%%
graph TD
A[Fraud system] -->|Alert event| B[Alert publisher]
C[Core banking] -->|Balance event| D[Balance publisher]
E[Loan system] -->|Approval event| F[Approval publisher]
B & D & F -->|Publish| G[Sync Hub]
G -->|Distribute| H[Push notification service]
G -->|Distribute| I[SMS gateway]
G -->|Distribute| J[Email service]
G -->|Distribute| K[In-app messaging]
G -->|Distribute| L[Notification history]
```
**Integration patterns used:**
* Event publishing from source systems
* Multi-consumer distribution to all notification channels
* Guaranteed delivery for critical alerts
* Event logging for compliance
**Example: Fraud Alert for Large Purchase**
1. **Fraud System** detects unusual \$5,000 purchase
2. **Alert Event** published to Sync Hub with severity=HIGH
3. **Sync Hub** distributes to all notification channels simultaneously:
* **Push Notification:** Alert sent to mobile app (\< 1 second)
* **SMS Gateway:** Text message sent to registered phone
* **Email Service:** Detailed email sent
* **In-App Messaging:** Banner displayed in digital banking
4. **Customer responds** via any channel within 2 minutes
5. **Response captured** and distributed to fraud system
6. **Transaction approved/declined** based on customer response
**Total time** - near-instant alert delivery across all channels
**Fraud prevention:**
* Real-time fraud alerts for immediate customer awareness
* Significantly faster customer response times
* Reduced false positives through immediate customer verification
**Customer experience:**
* Multi-channel notification delivery
* Consistent messaging across all channels
* Immediate awareness of account activity
**Compliance and Audit:**
* Complete audit trail of all notifications
* Proof of customer communication for disputes
* Regulatory compliance for customer notifications
## Integration pattern summary
Each use case demonstrates practical application of Sync Hub integration patterns:
| Use Case | Primary Patterns | Key Benefits | Complexity |
| ---------------------------- | ------------------------------------------- | -------------------------------------- | ---------- |
| **Customer Data Sync** | File processing, Webhooks, Multi-consumer | Data consistency, compliance | Medium |
| **Transaction Distribution** | Event streaming, Multi-consumer | Real-time visibility, fraud prevention | High |
| **Payment Processing** | Webhooks, File processing, Event streaming | Complete lifecycle tracking | High |
| **Account Updates** | Event streaming, Multi-consumer | Risk management, consistency | Medium |
| **Batch Payments** | File processing, Webhooks, Event generation | Processing efficiency | High |
| **Notifications** | Event publishing, Multi-consumer | Customer experience, compliance | Low |
## Common success patterns
Based on these use cases, several patterns emerge for successful Sync Hub implementations:
* **Start with high-value, low-complexity** - begin with real-time notifications or simple event distribution. Quick wins build confidence and demonstrate value before tackling complex integrations. For example, start with transaction notifications before implementing full payment processing lifecycle.
* **Combine patterns for complete solutions** - most real-world scenarios require multiple integration patterns. Banking integrations rarely fit a single pattern - vendors use multiple channels. Payment processors commonly use webhooks (real-time), files (settlement), and events (lifecycle).
* **Design for multi-consumer from day one** - assume every event will eventually have multiple consumers. New consuming systems emerge over time (analytics, compliance, new channels). Transaction events initially serve digital banking, but later add fraud detection, CRM, and analytics.
* **Prioritize guaranteed delivery** - implement retry logic and dead letter handling from the start. In banking, losing events means lost transactions, compliance violations, or customer issues. Payment status updates must reach digital banking even if systems are temporarily unavailable.
## Next steps
[**Integration patterns**](/platform/sync-hub-integration-patterns) - Learn the five integration patterns used in these use cases.
[**Sync Hub overview**](/platform/sync-hub/overview) - Return to Sync Hub overview and capabilities.
[**Platform overview**](/platform/overview) - Explore the complete Grand Central platform.