In the fast-paced world of fintech, technology decisions can make or break a company's ability to innovate, scale, and compete. When Funding Circle, a peer-to-peer lending platform that has lent over $500 million to more than 5,000 companies, decided to expand their tech stack from Ruby to include Clojure, it wasn't just about adding another programming language—it was a strategic decision with far-reaching implications.
Let's dive into the technology journey that helped Funding Circle scale their platform while maintaining the agility needed in the financial services sector.
The starting point: Ruby's role in Funding Circle's success
Like many innovative startups, Funding Circle initially built their platform using Ruby, leveraging its readability, clean syntax, and robust ecosystem that makes web development remarkably efficient.
Ruby's advantages are well-documented:
- Quick development cycles
- An expressive, developer-friendly syntax
- A vibrant package ecosystem
- Strong community support
As Denislav Naydenov, a Tech Lead at Funding Circle explains:
For a fintech startup moving fast to capture market share, these qualities were invaluable. However, as Funding Circle grew exponentially, new technical challenges emerged.
The turning point: when scaling demands new solutions
By 2015, Funding Circle was processing millions in loans and managing complex financial data flows. They faced new requirements:
- Processing high volumes of financial transactions with absolute reliability
- Handling complex data aggregation across multiple sources
- Ensuring atomic updates with complete transaction history
- Supporting concurrent operations without sacrificing performance
While Ruby had served them well for traditional web applications, these new demands required additional capabilities. Enter Clojure.
Why Clojure? The technical decision
Denislav Naydenov shares the reasoning:
Clojure brought specific advantages that complemented Ruby:
- Designed for concurrency: Essential for handling multiple financial transactions simultaneously without conflicts
- Functional programming without side-effects: Critical for financial systems where predictability and deterministic behavior are non-negotiable
- Immutable data structures: Providing additional safety when processing sensitive financial information
- JVM foundation: Offering stability, performance, and access to Java's vast ecosystem
- REPL-driven development: Enabling rapid experimentation with live data
As Denislav notes:
The implementation strategy: not "either/or" but "yes/and"
Crucially, Funding Circle didn't abandon Ruby—they embraced a polyglot approach where each language served its purpose:
- Ruby continued to excel for web interfaces, rapid feature development, and areas where its rich ecosystem provided advantages
- Clojure took on the heavy lifting for data processing, financial transactions, and systems requiring concurrency and functional guarantees
This strategic decision allowed Funding Circle to continue leveraging their engineers' expertise in Ruby while gradually building Clojure capabilities for specific domains.
Impact on team composition and hiring
The expansion to Clojure had significant implications for team building:
1. Creating specialised squads
Funding Circle's team at Pwrteams evolved into specialised squads focused on different technology areas:
- Ruby engineering teams
- Clojure teams for financial data processing
- PHP squads for specific services
- Technical support teams
This specialisation allowed each group to develop deep expertise in their domain while maintaining cross-team collaboration.
2. Talent acquisition strategy shift
Adding Clojure to the stack required a deliberate talent acquisition approach. While Ruby developers were relatively abundant, experienced Clojure developers were scarcer.
Funding Circle adopted a two-pronged strategy:
- Hiring experienced Clojure developers for key architectural roles
- Training existing Ruby developers interested in functional programming
Pwrteams supported this strategy by:
- Conducting specialised searches for Clojure talent
- Creating an onboarding program that helped Ruby developers transition to Clojure
- Establishing a mentorship system where experienced functional programmers guided newer team members
3. Building a learning culture
The technology expansion reinforced a learning culture within the engineering team. As Hristo Stamenov, a Senior Front-end Developer at Funding Circle team, notes:
This culture of continuous learning became a powerful recruitment and retention tool, attracting developers who wanted to expand their skills while working on meaningful financial products.
Architecture evolution: event courcing and Kafka
The addition of Clojure enabled Funding Circle to implement sophisticated architectural patterns better suited to financial systems:
Key architecture components include:
- Event sourcing: Capturing all changes to application state as a sequence of events
- Kafka: Providing a distributed event streaming platform for financial data
- Microservices architecture: Enabling independent scaling and deployment of system components
This architecture delivered critical benefits for a financial platform:
- Complete audit trails of all transactions
- Ability to reconstruct the system state at any point in time
- Improved scalability and fault tolerance
Lessons for CTOs: balancing innovation with stability
Funding Circle's technology evolution offers valuable lessons for technology leaders navigating similar decisions:
1. Adopt Technology for Specific Problems, Not Trends
Funding Circle didn't add Clojure because it was trending—they identified specific technical challenges where Clojure's strengths aligned perfectly with their needs.
Key takeaway: Start with the problem, not the technology. Choose tools that address your specific challenges rather than following industry hype.
2. Plan for polyglot reality
Rather than forcing a one-language-fits-all approach, Funding Circle embraced a polyglot strategy where multiple technologies coexisted, each serving the purposes where they excelled.
Key takeaway: Design your architecture to support multiple languages and frameworks, with clear boundaries between domains.
3. Evolve team structure with technology
As Funding Circle's technology stack evolved, so did their team structure, with specialised squads developing deep expertise in specific domains.
Key takeaway: Align your organisational structure with your technology architecture to maximise effectiveness.
4. Partner for team building
Working with us gave Funding Circle access to specialised recruiting capabilities that could find and attract scarce Clojure talent.
Key takeaway: Consider strategic partnerships for accessing specialised talent pools, especially when expanding into technologies with limited talent availability.
The results: technical capability driving business growth
The technology stack evolution delivered tangible business results:
- Improved platform scalability to support growing transaction volumes
- Enhanced system reliability for financial operations
- More sophisticated data analysis capabilities
- Faster time-to-market for new financial products
Georgi Kostov, a Tech Lead at Funding Circle, summarises the impact:
Your technology evolution journey
Every growing company faces similar decisions about when and how to evolve their technology stack. Funding Circle's journey demonstrates that technology evolution can become a powerful competitive advantage with thoughtful planning, the right talent strategy, and appropriate technical partnerships.
Is your organisation considering a similar technology expansion? Let's discuss how building the right team can support your technology strategy.
