Mintos: Founding Engineer at Europe's P2P Lending Platform

In 2015, I joined Mintos as one of the founding backend engineers. The platform was in its early stages, building what would become Europe’s largest peer-to-peer investment marketplace. My role was to architect and build the core backend systems that would need to scale from zero to hundreds of thousands of users.

This was formative work. The challenges of building financial infrastructure from scratch, handling real money, ensuring fair distribution of investment opportunities, and processing high volumes of transactions shaped how I think about intelligent systems today.

Core Systems I Built

Queue System Architecture

The queue system was built to speed up and maintain reliability for the platform’s day closing procedures. In a financial platform processing thousands of transactions daily, end-of-day reconciliation is critical: balances must be accurate, transactions must be accounted for, and reports must be generated reliably.

What the queue system handled:

• Day closing orchestration: Sequencing the complex series of calculations, validations, and reconciliations required at end of day
• Transaction batch processing: Processing accumulated transactions in correct order with proper atomicity
• Report generation: Generating investor statements, loan performance reports, and regulatory compliance data
• Failover and retry logic: Financial reconciliation cannot fail silently; the system needed robust error handling and recovery to ensure every day closed cleanly

This was my first deep experience building systems where reliability was non-negotiable. The patterns I developed here, processing queues, handling sequential dependencies, designing for failure, still inform how I approach backend architecture.

Auto-Investor Engine

The auto-investor was one of Mintos’s differentiating features. Investors could define their own investment logic, set execution cadence, and configure filters to automatically invest their funds based on their personal criteria.

What investors could configure:

• Custom filters: Loan originators, interest rates, loan terms, countries, risk ratings
• Investment logic: Minimum and maximum investment amounts per loan, total portfolio allocation rules
• Execution cadence: How frequently the system should check for matching loans and execute investments

Technical challenges I solved:

• Criteria evaluation engine: Building a flexible system that could evaluate complex, user-defined filter combinations against incoming loan inventory
• Concurrent execution: Multiple auto-investors targeting the same loans required careful concurrency control to prevent overselling
• Fair distribution: Ensuring large auto-investors did not monopolize loan supply, giving all users fair access to opportunities
• Portfolio constraint enforcement: Respecting user-defined diversification rules and risk limits while maximizing investment velocity

The auto-investor removed workflow friction for investors. Instead of logging in daily to manually review and select loans, users could define their strategy once and trust the system to execute. This is intelligent automation: the system handles repetitive decisions so humans can focus on strategy.

Backend Infrastructure

Beyond the queue system and auto-investor, I worked across the platform’s backend:

• RESTful API architecture: Designed APIs connecting the React.js frontend with backend services and external loan originators
• Payment provider integrations: Deposits, withdrawals, and transaction processing across European payment networks
• Data synchronization: Real-time accuracy of investment portfolios, loan statuses, and account balances
• Security and compliance: Authentication systems and data protection meeting MiFID regulatory requirements
• Performance optimization: Database query optimization and caching to handle growing transaction volumes
• Deployment pipeline: Automated testing and deployment processes for reliable, frequent releases

Technical Environment

The platform was built on PHP/Symfony with a React.js frontend and MySQL database. Infrastructure ran on AWS EC2 with S3 for file storage. Version control through Git with Bitbucket, and project management in Jira.

Working in a small founding team meant wearing multiple hats: architecture decisions, code reviews, deployment, and direct collaboration with product on feature priorities.

Impact and Legacy

Mintos has grown into the largest P2P investment platform in Europe, with over €600 million in managed assets and 500,000+ investors across European markets. The platform has expanded from pure P2P lending to include bonds, ETFs, and real estate investments.

The foundational systems built during my time, the queue architecture, the auto-investor patterns, the API structure, helped establish the technical foundation for this growth.

What This Work Taught Me

The Mintos experience crystallized principles I still apply:

Reliability is non-negotiable in financial systems. When real money is involved, “eventually consistent” is not good enough. This shaped my focus on robust error handling, atomic transactions, and systems that fail gracefully.

Intelligent automation removes workflow friction. The auto-investor was not just a convenience feature; it fundamentally changed how users interacted with the platform. This early experience in building systems that automate repetitive decisions directly connects to the intelligent systems work I do today.

Scalability must be designed in, not bolted on. Starting with a small user base but building for growth taught me to think about architecture choices that would not become bottlenecks later.

Fintech requires both technical depth and regulatory awareness. Building payment integrations and investor management systems meant understanding not just the code, but the compliance requirements that shaped how systems needed to behave.

This founding engineer experience, building critical financial infrastructure from scratch, established the technical foundation I have continued to build on across a decade of backend engineering and operations work.

Implemented solutions:

• Custom API Creation
• Custom Payments Integration
• Website Security Optimization
• Custom Customer Management
• Custom Internal System Creation
• Single Sign-On
• Website Performance Optimization
• Website Core & Stability
• Automatic Data Synchronization
• Development and Deployment Pipeline

Used technologies: