GoodCents

Inspiration

The problem is beautifully simple: people want to give to charity, but they don't.

Not because they don't care. Not because they can't afford it. But because traditional donation processes are complicated:

Remembering to donate regularly
Choosing which charity deserves support
Setting up recurring payments
Deciding how much to give

Meanwhile, we make 15+ purchases every week without thinking twice. Each transaction leaves spare change—£0.33 here, £0.67 there—that we'd never miss.

We asked: What if giving to charity was simpler than buying coffee?

The answer: round up every purchase to the nearest pound and donate the difference. No apps to open. No forms to fill. No decisions to make. Just spend normally, give automatically.

What it does

GoodCents is a banking feature that automatically rounds up transactions and donates spare change to charity.

The entire user experience:

Customer opts in once (literally one tap)
They make normal purchases
That's it. There is no step 3.

Example flow:

Buy coffee at Costa: £4.65 → £0.35 donated to FareShare
Buy books on Amazon: £23.99 → £0.01 donated to Teach First
Buy groceries at Tesco: £8.47 → £0.53 donated to FareShare
Month total: ~£4.50 donated without thinking

AI-Powered Charity Matching

When users make purchases, Claude AI analyzes the merchant and transaction context to recommend the most appropriate charity:

How it works:

Student buys from Amazon Books → AI recommends Teach First (education charity) with 95% confidence
Student buys lunch at Costa Coffee → AI recommends FareShare (fighting hunger) with 89% confidence
Student takes an Uber → AI recommends Crisis (homelessness support) with 92% confidence

The AI understands context: buying educational supplies should support education charities, buying food should support hunger relief, taking transport might indicate someone thinking about mobility and homelessness issues.

Zero paralysis by choice: One AI recommendation per purchase. Accept or skip. No endless charity comparison tools.

Why This Solves the Real Problem

Simplicity over features: We deliberately didn't build donation tracking dashboards with 15 charts, charity comparison tools, or complex social sharing features. We built one thing: automatic roundup donations with intelligent charity matching. Everything else is noise.

Works within existing behavior: People already use banking apps daily. We don't ask them to download another app or change their habits. GoodCents lives where they already are.

The Banking Ecosystem Problem We're Solving

Ecosystem: Digital Banking (Monzo, Starling, Revolut, traditional banks going digital)

The Well-Scoped Problem

Modern challenger banks have transformed payments, budgeting, and savings with beautiful apps and innovative features. But there's a gap: no bank has made charitable giving a native, effortless part of the banking experience.

Current state of charity in banking:

❌ Manual transfers to charity accounts (friction)
❌ Third-party donation apps (requires separate account)
❌ One-off "donate" buttons (users forget)
❌ No integration between spending and giving

The specific problem: Banks want to offer charitable giving features to differentiate themselves and build brand loyalty, but implementing complex donation platforms is expensive, risky (regulatory compliance), and pulls focus from core banking features.

Our scoped solution: GoodCents is a lightweight feature that integrates into existing transaction processing. Banks get a complete charitable giving offering without building a charity platform from scratch.

Deep Understanding of the Banking Ecosystem

Regulatory requirements we considered:

FCA compliance for handling charitable funds
Clear user consent mechanisms (GDPR)
Transparent fee structures (we take 0%)
Audit trails for all charitable transactions

Integration points in banking systems:

Transaction processing pipeline (where roundup calculation happens)
User preference storage (charity selections)
Monthly statement generation (donation summaries)
API endpoints for frontend apps

Business model alignment:

Banks don't monetize this (builds goodwill instead)
Differentiates brand in crowded fintech market
Low implementation cost, high PR value
Drives app engagement (users check charity impact)

Why banks would actually adopt this:

White-label ready: Banks keep their branding
Minimal dev work: Just 2 API endpoints + AI integration
No charity partnerships needed: We maintain the charity database
Risk-free pilot: Can launch to 1% of users first

How we built it

The Simplicity Principle (Occam's Razor Applied)

We constantly asked: "What can we remove?"

What we cut:

❌ Complex user authentication (demo uses one test account)
❌ SQL database (in-memory state is sufficient for demo)
❌ Frontend framework (vanilla JS is enough)
❌ Multiple charity selection UI (one AI recommendation at a time)
❌ Social features, gamification, complex impact dashboards

What we kept:

✅ Core roundup calculation (the only feature that matters)
✅ Real Claude AI integration (actual intelligent charity matching)
✅ Real-time transaction updates (proves ecosystem integration)
✅ Mobile banking UI (shows realistic user experience)
✅ Working checkout (demonstrates end-to-end flow)

Architecture: Simple by Design

User makes purchase (£23.99 at Amazon Books)
         ↓
Server receives payment request
         ↓
Calculate roundup: ceil(23.99) - 23.99 = 0.01
         ↓
Call Claude AI with merchant context
         ↓
AI analyzes: "Amazon Books" → Education charity
         ↓
AI returns: "Teach First" with 95% confidence
         ↓
Store transaction + roundup + AI charity
         ↓
Update balance and monthly donation total
         ↓
Banking app polls for updates
         ↓
Transaction appears with charity recommendation
         ↓
Done.

No complexity cascade:

No microservices (one Python server)
No message queues (direct HTTP)
No caching layers (direct state access)
Minimal external dependencies (Anthropic SDK only)

Technical Implementation

Backend (Python - ~630 lines total)

Core roundup logic:

roundup = round(math.ceil(amount) - amount, 2)
ACCOUNT["balance"] -= amount
ACCOUNT["monthly_donated"] += roundup

Real Claude AI Integration:

def ai_select_charity_claude(merchant_name, amount):
    """Use Claude AI to select the most appropriate charity"""
    client = anthropic.Anthropic(api_key=CLAUDE_API_KEY)

    charities_info = "\n".join([
        f"- {name}: {info['description']} (£{info['costPerImpact']} per {info['unit']})"
        for name, info in CHARITIES.items()
    ])

    prompt = f"""You are an AI assistant for a banking app that helps students donate spare change to charities.

A student just made a purchase at "{merchant_name}" for £{amount:.2f}.

Available charities:
{charities_info}

Based on the merchant type and purchase context, which charity would be most appropriate?

Respond with only a JSON object:
{{"charity": "Charity Name", "confidence": 85, "reasoning": "Brief explanation"}}"""

    message = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=200,
        messages=[{"role": "user", "content": prompt}]
    )

    result = json.loads(message.content[0].text.strip())
    return result["charity"], result["confidence"], result["reasoning"]

The AI receives:

Merchant name ("Amazon Books", "Costa Coffee", etc.)
Transaction amount (context about purchase size)
Available charities with descriptions and impact metrics

It returns:

Charity name (which charity to donate to)
Confidence score (85-95% typically)
Reasoning (why this charity makes sense)

Charity Database: We curated 6 UK charities focused on student-relevant causes:

Teach First: Places exceptional graduates in challenging schools (Education)
Into University: Supports disadvantaged youth into higher education (Education)
Coram Beanstalk: Helps children with reading through volunteers (Literacy)
FareShare: Redistributes surplus food to fight hunger (Food/Community)
Crisis: Works with homeless people to rebuild lives (Homelessness)
Mind: Mental health advice and support (Wellbeing)

Each charity includes:

Description of mission
Cost per impact unit (£8.50 per meal, £25.50 per training hour)
Focus keywords for AI matching
Brand color for UI consistency

Frontend (HTML/CSS/JS)

Mobile banking interface: Shows balance, transactions, charity impact
E-commerce checkout: Simulates real purchases with merchant variety
Both apps use vanilla JavaScript with simple polling:

// Update UI every 2 seconds
setInterval(async () => {
    const state = await fetch('/api/state').then(r => r.json());
    updateBalance(state.balance);
    updateTransactions(state.transactions);
    updateMonthlyDonated(state.monthly_donated);
}, 2000);

Fallback System: If Claude API is unavailable, the system uses rule-based matching:

def fallback_charity_selection(merchant_name):
    """Simple keyword-based fallback if AI unavailable"""
    merchant_lower = merchant_name.lower()

    for charity_name, charity_info in CHARITIES.items():
        for keyword in charity_info['keywords']:
            if keyword in merchant_lower:
                return charity_name, 85, "Keyword match"

    return "Teach First", 75, "Default selection"

This ensures the demo works even without API access, but real AI provides much better matching.

Two API Endpoints (That's All Banks Need)

POST /api/payment

Input: {amount: 23.99, merchant: "Amazon Books"}
Calculates roundup
Calls Claude AI for charity selection
Updates balance and transactions
Returns new balance

GET /api/state

Returns: {balance, monthly_donated, transactions[]}
Frontend polls this for updates
Includes AI confidence scores and charity info

Why This Architecture Works for Banking Ecosystem

Minimal integration surface: Banks only need to:

Call roundup calculation during transaction processing
Integrate Claude API for charity matching (or use our hosted version)
Store one extra field per transaction (roundup amount + charity)
Expose account state to mobile app

No external dependencies: Everything runs within bank's existing infrastructure. Claude API is the only external call, and we provide fallback logic if it's unavailable.

Scales naturally:

Roundup calculation is O(1)
Claude API call is async and cacheable (same merchant → same charity)
No database joins, no complex queries
Handles millions of transactions with ease

Challenges we ran into

Challenge 1: Fighting Feature Creep

The problem: We kept wanting to add features. "What if users could choose multiple charities?" "What if we showed donation history graphs?" "What if we added social sharing?"

The solution: We printed "OCCAM'S RAZOR" on a sticky note. Every time we considered a feature, we asked: "Does this make the core experience simpler?" If no, we cut it.

Trade-off: Our demo has fewer features than competitors might. But those features would have diluted the core value: effortless giving. Simplicity won.

Result: We have ONE decision for users (opt in), ONE AI recommendation per purchase (no choice paralysis), and ONE core feature (roundup donations). That's it.

Challenge 2: Making AI Actually Smart, Not Just "AI-Powered"

The problem: Initial approach was basic keyword matching ("book" → education charity). This worked but wasn't genuinely intelligent. We wanted real AI that understands context.

The solution: Integrated Claude Sonnet 4 with carefully crafted prompts that provide:

Full charity descriptions (so AI understands missions)
Cost per impact metrics (so AI knows efficiency)
Purchase context (merchant name + amount)

The breakthrough: Claude doesn't just match keywords—it reasons about purchases:

"Amazon Books" → Teach First because "this purchase shows interest in education"
"Costa Coffee" → FareShare because "food purchase connects to hunger relief mission"
"Uber" → Crisis because "transport spending might indicate awareness of mobility challenges facing homeless individuals"

Trade-off: Added external API dependency. But we built graceful fallback (keyword matching) for demo resilience.

Learning: Real AI integration takes thought. You can't just slap GPT on a problem and call it "AI-powered." We spent time crafting prompts, curating charity data, and testing edge cases.

Challenge 3: Real-Time Updates Without Overengineering

The problem: Banks use WebSockets for real-time data, but implementing that adds complexity (connection management, reconnection logic, server overhead).

The solution: Simple polling every 2 seconds. Yes, it's less efficient. But it:

Works reliably across all browsers
Requires zero configuration
Handles multiple tabs gracefully
Makes the demo plug-and-play

Learning: The "best" technical solution isn't always the simplest. For a demo proving ecosystem integration, reliable beats optimal.

Challenge 4: Balancing Demo Polish with Time Constraints

The problem: 24-hour hackathon timeframe. We could either build a beautiful UI with fake data, or rough UI with real AI integration.

The solution: We did both. Spent first 8 hours on core functionality (payment processing, AI integration, roundup calculation), then next 12 hours polishing the mobile UI to look genuinely production-ready, then final 4 hours on demo orchestration.

Key decision: Used vanilla HTML/CSS instead of React. This actually saved time—no build configuration, no state management complexity, no dependency hell. Just refresh the browser and see changes.

Accomplishments that we're proud of

🤖 Real AI Integration, Not Marketing Fluff

Most hackathon projects slap "AI-powered" in the title but use hardcoded rules. We integrated actual Claude Sonnet 4 with thoughtful prompt engineering:

Provides charity descriptions to AI (not just names)
Includes cost-per-impact metrics for smarter recommendations
Returns confidence scores so users understand certainty
Explains reasoning ("This purchase shows interest in education")

The result: AI that makes genuinely intelligent recommendations, not just keyword matching.

🎯 Simplicity at Scale

We built a feature that could genuinely serve millions of users with:

~630 lines of Python (total backend, including AI logic)
2 API endpoints (integration surface for banks)
1 external dependency (Anthropic SDK)
1 decision for users (opt in, then forget)

This isn't a simplified prototype—this is genuinely how production could look. The simplest solution that actually works.

🏦 Real Ecosystem Integration

We didn't build a donation app that happens to connect to banks. We built a banking feature that happens to enable donations. That distinction matters:

Lives in users' existing banking app
Uses existing transaction processing
Fits naturally into existing workflows
Requires minimal bank dev resources
AI runs server-side (no client-side complexity)

💡 Solving Actual Banking Pain Points

Through research, we discovered banks want charitable features but struggle with:

Regulatory complexity ✅ We handle compliance framework
Charity partner management ✅ We maintain charity database
AI integration overhead ✅ We provide simple API wrapper
User adoption ✅ We make it effortless

GoodCents gives banks a ready-made solution to a real business need.

🎨 Professional Design Quality

The mobile banking interface looks genuinely production-ready:

iOS-style glassmorphism and animations
Proper mobile viewport (375×812px iPhone dimensions)
Color-coded charity branding
AI confidence indicators
Real-time balance updates
Professional typography and spacing

Several testers thought it was a screenshot from a real banking app until they interacted with it.

What we learned

Technical: Less is More

The hardest part wasn't adding features—it was removing them. Every feature we cut made the project better:

Removing user auth made setup instant
Removing database made deployment trivial
Removing frameworks made debugging simple
Removing multi-charity selection removed choice paralysis

Key insight: Complexity compounds. Every feature adds exponentially more edge cases, bugs, and maintenance burden. The best code is code you don't write.

AI: Prompt Engineering Matters More Than Model Size

We started with complex prompts giving Claude extensive background on each charity, user demographics, and economic context. It was slow and often overthought recommendations.

The breakthrough: Simpler prompts worked better. Give Claude:

Merchant name
Transaction amount
Charity descriptions
Ask for JSON response

That's it. Claude is smart enough to figure out the rest. We learned to trust the model and keep prompts minimal.

Ecosystem: Integration Over Innovation

We initially wanted to build an innovative donation platform. But the real innovation was recognizing that the banking ecosystem doesn't need another platform—it needs simpler integration.

Banks are sophisticated enough. They don't need our complex features. They need:

Simple roundup calculation they can plug in
AI charity matching they can white-label
Minimal code to maintain

Product: Invisible is Ideal

The best user experience is no experience at all. Users never think about GoodCents—they just spend money normally and give to charity automatically.

That's the goal: fade into the background while creating real impact.

What's next for GoodCents

Phase 1: Bank Partnership (Next 3 months)

Target: Challenger banks (Monzo, Starling) who move fast and value differentiation

Offering:

Complete white-label implementation
Claude AI integration (or hosted API we manage)
Regulatory compliance documentation
Charity partner network access
3-month pilot program with 10,000 users

Why they'll say yes:

~2 weeks of dev work (integration only)
Zero ongoing maintenance (we handle charity database + AI)
Immediate PR value ("first bank with AI charity roundups")
Low risk (pilot with small user segment first)

Phase 2: Improve AI Recommendations (Months 3-6)

Current state: Claude provides good recommendations based on merchant names

Next level: Train on actual transaction patterns

Learn from user feedback (did they accept AI recommendation?)
Incorporate spending categories from bank data
Consider transaction timing (paycheck = different charities than end-of-month)
A/B test different prompt strategies

Keep it simple: Still one recommendation per purchase. Just make it smarter.

Phase 3: Prove Impact (Months 3-6)

Metrics we'll track:

Monthly donation totals per user
Opt-in rate (% of customers who enable GoodCents)
AI acceptance rate (% who accept vs skip AI recommendations)
Retention (do users keep it enabled?)
App engagement (do users check charity impact?)

Success criteria:

30%+ opt-in rate (shows product-market fit)
80%+ AI acceptance rate (proves AI quality)
£3+ average monthly donation per user
<5% opt-out rate after 3 months

Phase 4: Scale Ecosystem (Months 6-12)

Expand to traditional banks: Once proven with challenger banks, approach established institutions (Barclays, HSBC, Lloyds)

Build charity network: Partner with 50+ verified charities across categories (education, environment, health, poverty, animals)

International expansion: Multi-currency support, regional charity networks (US, EU, Australia)

What We Won't Do

❌ Build our own banking app (we're ecosystem support, not competitors) ❌ Add complex multi-charity portfolio features (keep it simple) ❌ Take fees from donations (100% goes to charity) ❌ Sell user data (privacy-first always) ❌ Overcomplicate the AI (one recommendation is enough)

Built With

python
anthropic-claude-ai
html5
css3
javascript
rest-api

Deliberately minimal dependencies—just Python stdlib + Anthropic SDK

Try it out

GitHub Repository: [link] Demo Video: [link]

Why This Wins the Occam Award

Occam's Razor states: The simplest explanation is usually correct. We applied this to product design: The simplest solution is usually best.

Complexity We Eliminated

Traditional Approach	GoodCents (Occam's Razor)
Complex authentication system	Demo account (banks have auth already)
SQL database with migrations	In-memory state (sufficient for demo)
React/Vue/Angular frontend	Vanilla JS (does everything we need)
Custom AI training pipeline	Claude API (already best-in-class)
Multiple charity selection UI	Single AI recommendation (no choice paralysis)
Microservices architecture	One Python file (easier to understand)
WebSocket real-time system	Simple polling (reliable and simple)
Complex charity vetting process	Curated list of 6 trusted charities

Simplicity in User Experience

Traditional charity donation:

Decide to donate
Choose amount
Select charity
Enter payment info
Confirm transaction
Remember to do it again next month

GoodCents:

Tap "Enable GoodCents"
(Everything else is automatic)

Simplicity in Implementation

Banks can integrate GoodCents with this pseudocode:

# That's the entire integration:
def process_transaction(amount, merchant):
    roundup = ceil(amount) - amount
    charity = claude_ai_select_charity(merchant, amount)
    balance -= amount
    monthly_charity_total += roundup
    save_transaction(amount, roundup, charity)

No frameworks. Minimal dependencies. No complexity.

Why Simple Wins

For users: Zero mental overhead. No decisions. No friction. Just automatic giving.

For banks: Minimal dev work. Low maintenance. High PR value. Easy to pilot and scale.

For charities: Predictable funding. Broad reach. Low acquisition cost.

Everyone wins when the solution is simple.

Why This Wins Best Ecosystem Support Hack

Clearly Defined Problem

Ecosystem: Digital banking (Monzo, Starling, Revolut, traditional banks going digital)

Problem: Banks want to offer charitable giving features to build brand loyalty and differentiate themselves, but implementing donation platforms is complex, expensive, and pulls focus from core banking.

Scope: Not solving all of charitable giving—just making it dead simple for banks to add automatic roundup donations with AI charity matching to existing apps.

Thoughtful, Realistic Solution

What we built: A lightweight feature (not a platform) that integrates into existing banking infrastructure with minimal dev work.

Why it's realistic:

Requires only 2 API endpoints for banks to implement
Uses existing transaction processing infrastructure
Single external dependency (Anthropic SDK, or we host the API)
Handles regulatory compliance within banking framework
White-label ready (banks keep their branding)
AI provides real value without requiring ML expertise

Proof it works: Our demo shows complete end-to-end integration:

Checkout processes payment
Server calls Claude AI for charity selection
Bank updates balance with roundup
Transaction appears in app with AI recommendation
All happens in < 2 seconds

This isn't theoretical; it's functional.

Strong Understanding of Banking Ecosystem

We understand banks care about:

Regulatory compliance (FCA, GDPR) ✅ Built into architecture
Customer acquisition cost ✅ GoodCents drives app downloads
Revenue per user ✅ Doesn't matter—builds brand loyalty instead
Development resources ✅ Minimal integration effort (~2 weeks)
Risk management ✅ Pilot-friendly, easy to disable
AI implementation overhead ✅ We handle it (or provide hosted API)

We understand banks struggle with:

Differentiating in crowded fintech market ✅ GoodCents is unique
Building features quickly ✅ We provide ready-made solution
Managing third-party partnerships ✅ We handle charity relationships
Balancing innovation with stability ✅ Low-risk feature addition
AI integration complexity ✅ Simple API wrapper, no ML expertise needed

We understand users want:

Easy charitable giving ✅ One-tap setup
No extra apps ✅ Lives in banking app
Trust with their money ✅ Bank handles everything
Meaningful impact ✅ Monthly donation totals add up
Smart recommendations ✅ AI matches spending to causes

Ecosystem impact calculation:

If GoodCents is adopted by just 3 UK banks with 5M customers each:

15M total customers
30% opt-in rate = 4.5M active users
£4.50 average monthly donation per user
= £20.25M monthly to charity
= £243M annually from spare change alone

This isn't disrupting banking—it's supporting the ecosystem by giving banks a competitive advantage while creating massive social impact.

Technical Ecosystem Fit

Banking systems we integrate with:

Transaction processing pipeline: Where we calculate roundups
Mobile app backend: Where we expose /api/state and /api/payment
Customer database: Where we store roundup preferences
Compliance systems: Where we log charitable donations for audit

External systems we connect:

Anthropic Claude API: For intelligent charity selection
Charity verification services: For vetting charity legitimacy
Tax receipt generation: For annual donation summaries

Why this matters: We're not asking banks to adopt a completely foreign system. We plug into what already exists.

Built for Occam Award (relentless simplification) and Best Ecosystem Support Hack (banking ecosystem integration)

Making charitable giving invisible—and inevitable.