SibehGoodBank

Banking made Sibeh Good.Sibeh Smart, Sibeh Secure, Sibeh Good

Comment

About SibehGoodBank

Inspiration

The inspiration for SiBehGoodBank came from observing the disconnect between traditional banking experiences and the digital-native expectations of today's users. In Malaysia, while digital banking is growing, many existing solutions feel clunky, fragmented, or lack the intelligent assistance that modern users expect.

We asked ourselves: What if banking could be as intuitive as chatting with a friend?

The name "SiBeh Good" (Hokkien for "very good") reflects our Malaysian roots and our commitment to building something sibeh different—a banking app that doesn't just process transactions, but actually understands what you need.

What it does

SiBehGoodBank is a comprehensive AI-powered digital banking platform that transforms how users interact with their finances:

🤖 AI Banking Assistant

A Claude-powered conversational agent that lets users:

  • Transfer money using natural language: "Transfer RM100 to Ahmad"
  • Pay bills effortlessly: "Pay my TNB electricity bill"
  • Perform cardless ATM withdrawals: "I want to withdraw RM500"
  • Get instant answers: "What's my balance?" or "Show my recent transactions"

The AI doesn't just respond—it acts. It executes real banking operations through a sophisticated tool-calling system.

📱 Feature-Rich Mobile Experience

Feature Description
Holographic UI Glassmorphism design with gradient animations
Biometric Security Fingerprint & Face ID for transaction verification
Smart Analytics Spending insights with visual breakdowns
Goal-Based Savings "Tabung" (savings pots) for financial goals
Gamification Rewards, challenges, and achievements
QR Payments DuitNow-style scan-to-pay functionality

🏗️ Enterprise-Grade Backend

A full microservices architecture supporting:

  • Real-time transaction processing
  • Multi-channel notifications (Email, SMS, Push)
  • Fraud detection capabilities
  • Comprehensive analytics

How we built it

The Tech Stack

Our architecture follows a modern, scalable design:

$$ \text{Flutter Frontend} \xrightarrow{\text{REST/gRPC}} \text{API Gateway} \xrightarrow{\text{Load Balanced}} \text{Microservices} \xrightarrow{\text{Event-Driven}} \text{Data Layer} $$

Frontend (Cross-Platform Mobile)

  • Flutter 3.x + Dart 3.6 for a single codebase across iOS, Android, Web, Windows, macOS, and Linux
  • Custom design system with AppColors, AppSpacing, and AppTextStyles for consistency
  • speech_to_text for voice input, flutter_tts for voice responses

Backend (Java Microservices)

  • Spring Boot 3.2 with Java 21 (latest LTS)
  • Spring Cloud Gateway for API routing with JWT validation
  • Eureka for service discovery
  • PostgreSQL 15 as the primary database
  • Redis 7 for caching and rate limiting
  • Kafka + RabbitMQ for event-driven architecture

AI Agent (Python)

  • FastAPI for high-performance async API
  • Anthropic Claude (claude-3-5-sonnet) with tool-calling capabilities
  • Custom banking tools: check_balance, transfer_funds, pay_bill, calculate_loan, etc.

Microservices Architecture

Services: 8+
Total Endpoints: 50+
Ports Used: 8080-8086, 8761, 8888
Containers: 10+ (via Docker Compose)

Each service is independently deployable:

Service Responsibility
User Service Authentication & profiles
Account Service Balance & account management
Transaction Service Transfers & payments
AI Agent Service Claude integration
Notification Service Multi-channel alerts
Analytics Service Insights & reporting

Challenges we ran into

1. AI Tool Orchestration

Getting Claude to reliably call the right banking tools was tricky. We had to carefully design tool definitions with explicit parameter schemas and handle edge cases like:

  • User says "transfer" but doesn't specify amount → ask for clarification
  • Ambiguous recipient names → show confirmation before executing

2. Token Limit Management

Long conversations would exceed Claude's context window. We implemented a sliding-window history truncation strategy:

def _truncate_history(self, history: list, max_tokens: int = 100000):
    # Keep system prompt + recent messages within budget

3. Cross-Platform Consistency

Flutter's "write once, run anywhere" promise works—mostly. We encountered platform-specific issues with:

  • Biometric authentication APIs (iOS vs Android)
  • Text-to-Speech engines (native vs plugin-based)
  • File system paths and permissions

4. Microservices Complexity

With 8+ services, debugging became challenging. A single request might traverse:

App → Gateway → User Service → Account Service → Transaction Service → Notification Service

We relied heavily on distributed tracing and centralized logging to maintain sanity.

5. Security vs UX Trade-offs

Banking requires strong security (AES-256, Argon2id, JWT), but we didn't want users to feel like they're entering Fort Knox. Finding the balance between:

$$\text{Security} \propto \text{Friction}$$

$$\text{UX} \propto \frac{1}{\text{Friction}}$$

...required careful UX design with biometrics as the "frictionless" authentication layer.

Accomplishments that we're proud of

✅ Full AI Banking Workflow

Users can complete entire banking journeys through conversation:

  1. "Transfer RM50 to my mom"
  2. AI finds the contact, confirms details
  3. Biometric verification triggered
  4. Transfer executed
  5. Voice confirmation: "Done! RM50 sent to Mom."

✅ Production-Ready Architecture

This isn't a hackathon prototype—it's enterprise-grade:

  • 12-factor app principles
  • Circuit breakers for fault tolerance
  • Rate limiting to prevent abuse
  • Field-level encryption for sensitive data

✅ TLDR Voice Responses

Instead of reading long AI responses, we implemented a summarization layer:

# Backend generates concise voice summaries
tldr = summarize_for_speech(full_response)  # "Transfer complete!"

The UI displays the full response but speaks only the TLDR.

✅ Beautiful, Consistent UI

Our custom design system ensures every screen feels cohesive:

  • Glassmorphism cards with blur effects
  • Gradient animations
  • Dark mode support
  • Accessibility considerations

What we learned

Technical Learnings

  1. Microservices aren't always the answer—but for banking, the isolation and scalability benefits outweigh the complexity cost.

  2. AI tool-calling is powerful but requires guardrails—Claude can do amazing things, but explicit confirmation steps for financial transactions are non-negotiable.

  3. Cross-platform development has hidden costs—Flutter is great, but platform-specific plugins (TTS, biometrics) require native rebuilds, not just hot reload.

  4. Event-driven architecture scales well—Kafka/RabbitMQ let us decouple services and handle spikes gracefully.

Process Learnings

  1. Start with the AI happy path—We built the conversational flow first, then wrapped services around it.

  2. Security is a feature, not an afterthought—Baking encryption and auth into the foundation saved us from painful retrofits.

  3. Mock data enables parallel development—Our Python agent uses mock data, letting frontend and AI development proceed independently of backend completion.

What's next for SibehGoodBank

Short-Term Roadmap

Feature Description
Real Bank Integration Replace mock data with actual banking APIs (Open Banking standards)
Multi-Language Support Bahasa Malaysia, Mandarin, Tamil
Advanced Fraud Detection ML-based anomaly detection on transactions
Investment Module Stock trading, unit trusts, robo-advisory

Long-Term Vision

  • Open Banking Platform: Expose APIs for third-party fintech integration
  • Embedded Finance: White-label solutions for e-commerce platforms
  • Regional Expansion: Adapt for Singapore, Indonesia, Thailand banking regulations

Technical Improvements

  • Migrate to Kubernetes for orchestration
  • Implement GraphQL for more flexible mobile queries
  • Add real-time streaming with WebSockets for live balance updates
  • Enhance AI with RAG (Retrieval-Augmented Generation) for personalized financial advice

SiBehGoodBank: Banking made sibeh good. 🏦✨

Built With

Share this project:

Updates