FinMind AI — CFO Virtual para Freelancers y Pymes

Concepto

FinMind AI es un Micro-SaaS de inteligencia financiera que actúa como un CFO virtual asequible para freelancers, solopreneurs y pequeñas empresas (1-10 empleados). Resuelve el problema real y recurrente de la gestión de flujo de caja eliminando la dependencia de hojas de cálculo y la toma de decisiones basada en intuición.

Propuesta de valor core: Conecta cuentas bancarias vía Plaid, categoriza transacciones automáticamente con IA, predice el saldo futuro y alerta proactivamente sobre riesgos financieros.

---

Arquitectura

┌─────────────────────────────────────────────────────────────────┐
│                     FinMind AI Backend (Spring Boot 4.0.4)       │
│                                                                   │
│  ┌─────────────┐  ┌──────────────┐  ┌──────────────────────┐    │
│  │  REST API   │  │   Services   │  │   Virtual Threads    │    │
│  │             │  │              │  │   (Plaid I/O calls)  │    │
│  │ AuthCtrl    │  │ AuthService  │  │                      │    │
│  │ DashCtrl    │→ │ DashService  │→ │  ExecutorService     │    │
│  │ ForecastCtrl│  │ ForecastSvc  │  │  (newVirtualThread   │    │
│  │ TxnCtrl     │  │ TxnService   │  │   PerTaskExecutor)   │    │
│  │ PlaidCtrl   │  │ PlaidService │  │                      │    │
│  └─────────────┘  └──────────────┘  └──────────────────────┘    │
│         │                │                      │                 │
│  ┌──────▼──────┐  ┌──────▼──────┐  ┌──────────▼──────────┐     │
│  │  JWT Filter │  │    JPA      │  │   Feign Client      │     │
│  │  (Security) │  │ Repositories│  │   (PlaidClient)     │     │
│  └─────────────┘  └──────┬──────┘  └──────────┬──────────┘     │
│                           │                    │                  │
│                    ┌──────▼──────┐    ┌────────▼────────┐       │
│                    │ H2 / Postgres│    │   Plaid API     │       │
│                    └─────────────┘    │ sandbox.plaid.com│       │
│                                       └─────────────────┘        │
└─────────────────────────────────────────────────────────────────┘

Stack Técnico

Capa	Tecnología
Runtime	Java 25, Virtual Threads (Project Loom)
Framework	Spring Boot 4.0.4, Spring Framework 7.x
Seguridad	Spring Security 7 + JJWT 0.12.6 (JWT)
Persistencia	Spring Data JPA, H2 (dev), PostgreSQL (prod)
Integración	Spring Cloud OpenFeign 4.2.1 → Plaid API
Mapeo	MapStruct 1.6.3 (generado en compile-time)
JSON	Jackson 3.x (tools.jackson.*)

---

Endpoints API

Autenticación (público)

POST /api/auth/register
Body: { "email": "user@example.com", "password": "secret123", "name": "Ana García" }
→ 201: { "token": "eyJ...", "email": "...", "name": "...", "plan": "FREE" }

POST /api/auth/login
Body: { "email": "user@example.com", "password": "secret123" }
→ 200: { "token": "eyJ...", "email": "...", "name": "...", "plan": "FREE" }

Dashboard (requiere Authorization: Bearer <token>)

GET /api/dashboard?days=30
→ 200: {
    "totalIncome": 5000.00,
    "totalExpenses": 3200.00,
    "netCashFlow": 1800.00,
    "expensesByCategory": { "FOOD": 450.00, "RENT": 1500.00, ... },
    "incomeBySource": { "INCOME": 5000.00 },
    "transactionCount": 47,
    "linkedAccountCount": 2,
    "alerts": ["📊 Los gastos superan el 85%..."]
  }

GET /api/dashboard/alerts
→ 200: [{ "type": "EXPENSE_SPIKE", "message": "...", "severity": "WARNING", "timestamp": "..." }]

Transacciones

GET /api/transactions
GET /api/transactions?start=2026-01-01&end=2026-01-31
→ 200: [{ "id": 1, "description": "Starbucks", "amount": -4.50, "category": "FOOD", ... }]

POST /api/transactions/sync
→ 200: { "synced": 12, "message": "12 nuevas transacciones sincronizadas desde Plaid" }

Pronóstico

GET /api/forecast
→ 200: {
    "avgMonthlyIncome": 5000.00,
    "avgMonthlyExpenses": 3100.00,
    "forecast30Days": 1900.00,
    "forecast60Days": 3800.00,
    "riskAlerts": []
  }

Integración Plaid

GET /api/plaid/link/token
→ 200: { "linkToken": "link-sandbox-...", "expiration": "2026-06-04T...", "requestId": "..." }

POST /api/plaid/exchange?publicToken=public-sandbox-xxx
→ 201: { "accountId": 1, "institutionName": "Bank via Plaid", "accountName": "...", "message": "..." }

---

Modelo de Datos

users
├── id (PK)
├── email (UNIQUE)
├── password (bcrypt)
├── name
├── plan (FREE | PRO | BUSINESS)
└── created_at

linked_accounts
├── id (PK)
├── user_id (FK → users)
├── plaid_access_token
├── plaid_item_id
├── institution_name
├── account_name
├── account_type
├── active
└── created_at

transactions
├── id (PK)
├── user_id (FK → users)
├── account_id (FK → linked_accounts)
├── plaid_transaction_id (UNIQUE)
├── amount (DECIMAL 15,2 — positivo=ingreso, negativo=gasto)
├── description
├── category (INCOME|FOOD|TRANSPORT|UTILITIES|RENT|ENTERTAINMENT|HEALTHCARE|SHOPPING|SUBSCRIPTIONS|OTHER)
├── transaction_date
└── created_at

---

Motor de IA — Categorización por Reglas (MVP)

El TransactionService implementa un clasificador basado en palabras clave para categorizar transacciones en tiempo real:

"starbucks" → FOOD
"uber"      → TRANSPORT
"netflix"   → SUBSCRIPTIONS
"salary"    → INCOME
"rent"      → RENT

Ruta de evolución: Reemplazar con un modelo de text-classification (embeddings) via Spring AI, entrenado sobre el historial de transacciones del usuario para personalización progresiva.

---

Motor de Pronóstico — WMA (Weighted Moving Average)

Pesos = [0.5 (mes actual), 0.3 (mes -1), 0.2 (mes -2)]

avg_income   = Σ(income[i] × weight[i])
avg_expenses = Σ(expenses[i] × weight[i])

forecast_30d = avg_income - avg_expenses
forecast_60d = forecast_30d × 2

Alertas de riesgo automáticas:

• Flujo proyectado negativo → CRÍTICO
• Ratio gastos/ingresos > 90% → ADVERTENCIA
• Pico de gasto > 150% vs mes anterior → EXPENSE_SPIKE

---

Seguridad

• JWT HS256: firmado con clave configurable (jwt.secret), expira en 24h
• BCrypt: hash de contraseñas con salt automático
• Stateless: sin sesiones HTTP, todo autenticado por token
• Plaid access tokens: almacenados en BD (producción: cifrar con AES-256)

---

Virtual Threads (Java 25)

El TransactionService.syncAllAccounts() lanza un Virtual Thread por cuenta bancaria:

var futures = accounts.stream()
    .map(account -> virtualThreadExecutor.submit(() -> syncAccount(account)))
    .toList();
// → N cuentas sincronizadas en paralelo sin bloquear threads de plataforma

El %%INLINE5%% expone un %%INLINE6%% basado en %%INLINE7%%, inyectado por constructor en %%INLINE8%% y TransactionService.

---

Modelo de Negocio (Freemium)

Plan	Precio	Cuentas	Historial	Pronóstico
FREE	$0/mes	1	30 días	30 días
PRO	$19/mes	ilimitadas	12 meses	90 días
BUSINESS	$49/mes	ilimitadas	24 meses	12 meses + alertas email

---

Cómo Ejecutar

Desarrollo local (H2 en memoria)

# 1. Clonar / situarse en el directorio
cd solutions/2026-06-04-finmind-ai-api

# 2. Compilar y verificar
mvn clean compile

# 3. Ejecutar con perfil local (H2 + config de sandbox)
mvn spring-boot:run -Dspring-boot.run.profiles=local

# 4. Probar registro
curl -X POST http://localhost:8080/api/auth/register \
  -H "Content-Type: application/json" \
  -d '{"email":"founder@example.com","password":"secret123","name":"Ana García"}'

# 5. Login y guardar token
TOKEN=$(curl -s -X POST http://localhost:8080/api/auth/login \
  -H "Content-Type: application/json" \
  -d '{"email":"founder@example.com","password":"secret123"}' | jq -r .token)

# 6. Dashboard
curl http://localhost:8080/api/dashboard \
  -H "Authorization: Bearer $TOKEN"

# 7. Pronóstico
curl http://localhost:8080/api/forecast \
  -H "Authorization: Bearer $TOKEN"

# 8. H2 Console (solo dev)
# http://localhost:8080/h2-console  (JDBC URL: jdbc:h2:mem:finminddb)

Producción (PostgreSQL)

# Variables de entorno mínimas
export SPRING_DATASOURCE_URL=jdbc:postgresql://localhost:5432/finmind
export SPRING_DATASOURCE_USERNAME=finmind_user
export SPRING_DATASOURCE_PASSWORD=secure_password
export JWT_SECRET=your-production-secret-min-32-chars
export PLAID_CLIENT_ID=your_plaid_client_id
export PLAID_SECRET=your_plaid_secret
export PLAID_BASE_URL=https://production.plaid.com

mvn clean package -DskipTests
java -jar target/finmind-ai-api-0.0.1-SNAPSHOT.jar

---

Referencias

• Fintech AI Automation Trend 2026
• Plaid API Documentation
• Spring Boot 4.0.x Reference
• JJWT 0.12.x
• Project Loom / Virtual Threads
• MapStruct 1.6

---

Análisis de Negocio

TAM estimado: >500M freelancers + 400M pymes globales sin herramientas financieras accesibles.

Ventaja competitiva:

1. Simplicidad radical: onboarding en <5 minutos (conecta cuenta → insights inmediatos)
2. Precio accesible: $0-49/mes vs $300+/mes de software ERP/contabilidad
3. Proactivo vs reactivo: el sistema alerta antes de que ocurra el problema, no después
4. Datos propios: cada usuario genera datos que mejoran el modelo de categorización

Métricas clave a monitorizar:

• CAC (Coste de Adquisición por Cliente)
• MRR (Monthly Recurring Revenue)
• Churn rate mensual
• Tiempo hasta primer insight (time-to-value)
• Tasa de conversión FREE → PRO

---

FinOps Analysis

Resumen de Costos y Rentabilidad

FinMind AI proyecta un modelo de negocio con una fuerte rentabilidad inicial, apuntando a un margen de beneficio del 73%.

Los costos operativos mensuales estimados ascienden a $135, mientras que los ingresos mensuales proyectados son de $500 (basados en 20 clientes pagando $25/mes cada uno). Esto genera un beneficio neto de $365 al mes.

Desglose de Costos Mensuales:

• LLM Tokens (OpenAI gpt-4o-mini): $15/mes. Se estima un consumo de aproximadamente 40 millones de tokens, lo que demuestra la eficiencia de costos de los modelos de IA modernos a gran escala para tareas de texto.
• Infraestructura Cloud (AWS): $60/mes.

* Cloud Compute (EC2 t3.small, red básica): $35/mes. Para la ejecución de la aplicación Spring Boot. * Cloud Database (RDS PostgreSQL t3.small): $25/mes. Para persistencia de datos de usuarios, cuentas y transacciones.

• Plaid API: $50/mes. Este es un costo significativo y directo por el volumen de transacciones y cuentas conectadas. Se estima para un escenario con 20 clientes y 2 cuentas por cliente, con cierto volumen de uso de la API de transacciones.
• Monitoring & Misceláneos: $10/mes. Incluye logging básico, alertas y otros servicios menores de la nube.

Drivers de Costo Clave:

1. Plaid API: Es el mayor costo individual después de la infraestructura base. Su precio está directamente ligado al número de cuentas conectadas y la frecuencia de acceso a los datos transaccionales.
2. Infraestructura Cloud: Aunque optimizada con instancias pequeñas, representa un costo fijo base para el funcionamiento 24/7 de la aplicación y la base de datos.
3. LLM Tokens: Sorprendentemente bajo gracias a la eficiencia de gpt-4o-mini. Sin embargo, el volumen de tokens (40M) indica un uso intensivo para categorización y análisis, lo que podría escalar rápidamente con más usuarios o características de IA más profundas.

Estrategias de Optimización FinOps:

Para mantener y mejorar este margen de beneficio a medida que FinMind AI escala, se recomienda aplicar las siguientes estrategias FinOps:

• Optimización del Uso de LLM: Implementar un sistema de caché para las respuestas de LLM de categorizaciones comunes o resúmenes. Realizar un análisis continuo de los prompts para minimizar el número de tokens de entrada y salida, y explorar la posibilidad de usar modelos más pequeños y específicos (o incluso auto-hosteados) para tareas muy repetitivas si el volumen lo justifica.
• Gestión de Costos de Plaid: Monitorear de cerca el uso de la API de Plaid. Evaluar la frecuencia de sincronización de transacciones para cada cuenta: ¿es necesario sincronizar en tiempo real para todos los casos de uso, o se pueden aplicar actualizaciones menos frecuentes para datos históricos o menos críticos? Negociar planes de precios con Plaid a medida que el volumen de usuarios crece.
• Optimización de Infraestructura Cloud:

* Escalabilidad Elástica: Considerar la migración a servicios serverless (como AWS Fargate o Google Cloud Run) para el backend de Spring Boot, pagando solo por los recursos consumidos durante la ejecución de las solicitudes, en lugar de mantener una VM 24/7. * Instancias Reservadas: Si el uso de EC2 y RDS se estabiliza y es predecible, adquirir instancias reservadas puede ofrecer ahorros significativos a largo plazo. * Optimización de Base de Datos: Asegurarse de que las consultas SQL estén optimizadas y los índices sean adecuados para reducir la carga en la base de datos, lo que permite utilizar instancias más pequeñas o reducir los costos de IOPS.

• Monitoreo Continuo: Implementar herramientas de monitoreo de costos en la nube (ej. AWS Cost Explorer, GCP Cost Management) y crear alertas para detectar picos de gasto inesperados en LLM, Plaid o infraestructura. Revisar periódicamente el desglose de costos para identificar nuevas oportunidades de ahorro.