At Nu México Meetups #12, we explored how simplicity is a core strategic principle in building scalable software—and why it’s essential to deliver reliable and accessible financial products to millions of people.

Our guest for this session was Jordan Miller, a technology and education specialist focused on people, programming, and pedagogy. With deep expertise in Clojure and Datomic, Jordan is the co-author of Clojure Brain Teasers, co-founder of Clojure Camp, and host of the podcast Lost In Lambduhhs. In her talk, she shared valuable insights into how simplicity—when applied deliberately—can become a powerful strategic advantage for engineering teams, especially in organizations that need to scale with responsibility and purpose.

In this post, we walk through the main concepts covered in the talk: the traps of accidental complexity, the three levels where complexity manifests (organizational, team, and individual), the difference between something being simple and easy, and how tools like Clojure and Datomic help us build sustainable, auditable, and resilient systems.

Why simplicity is both a technical and human superpower

Simplicity is not the same as ease. While “easy” is subjective and depends on one’s experience, “simple” is objective: it means having fewer dependencies and greater conceptual clarity. In software development, that translates to reducing the cognitive load for those who build, maintain, and evolve systems.

At Nubank, simplicity is intentional. It’s the outcome of structural decisions that favor clarity over immediate convenience. A simple system is easier to understand, debug, extend—and, most importantly, to trust.

As humans, we can only handle a limited number of concepts at once. That’s why systems overloaded with layers of abstraction, tightly coupled dependencies, or mutable states tend to become harder to reason about and maintain. When these layers grow unchecked, they create what we call technical debt: the growing cost of understanding and maintaining systems that no longer scale well.

Check our job opportunies

Where complexity shows up: three levels that require attention

System complexity doesn’t only live in code—it emerges at multiple levels within an organization:

1. Organizational

At a macro level, complexity often stems from team misalignment, fragmented technology choices, or isolated decision-making that impairs collaboration. To avoid this, Nubank has adopted a unified technology stack with Clojure, ClojureScript, and Datomic—enabling better communication across backend and frontend teams and greater mobility between them.

We also embrace autonomy with accountability, one of our core values, which requires both trust and technical clarity.

2. Team

Within engineering teams, simplicity is supported by collaborative design, shared reviews, and collective understanding—long before any code is written. This approach breaks down knowledge silos and reinforces familiarity with the system, which is essential for sustainable growth.

3. Individual

At a personal level, simplicity means letting go of ego, being open to feedback, and feeling safe to make mistakes. It also means recognizing the “zone of proximal development,” where learning and collaboration thrive.

This mindset allows engineers to grow without fear of irreversible impact—because the systems we build are intentionally designed to be auditable and resilient.

Solve the right problem before building the solution

Another pillar discussed during the Meetup was structured problem-solving. Complexity often grows when we jump into solutions without fully understanding the underlying issue.

Here, we apply an approach inspired by Socratic thinking and the scientific method: we ask questions, form hypotheses, run tests, and document our findings. We use decision matrices to weigh the trade-offs of different approaches—an investment that pays off when building long-lasting solutions.

But what makes a problem “good”? It needs to have explicit criteria, be relevant, and pose a meaningful obstacle on the path to progress. Well-defined problems help avoid unnecessary implementations and create clarity for everyone involved.

Clojure and Datomic in Nubank’s technical culture

Nubank’s choice of functional programming languages like Clojure and immutable databases like Datomic is not incidental. These tools align closely with our engineering vision: to build systems that prioritize clarity, auditability, security, and continuous evolution.

Datomic, for example, gives us full visibility into the historical state of our data—complete with native audit trails and without unpredictable side effects. This is especially critical in financial services, where trust and traceability are non-negotiable.

Beyond using these tools, Nubank also actively supports the open source projects behind them. Since acquiring Cognitect in 2020, we’ve continued investing in the Clojure ecosystem and the community that powers it.

Simplicity as a competitive advantage

Today, Nubank serves more than 118 million customers through a platform that’s highly reliable, scalable, and secure. This is only possible because we embrace simplicity at every level—from backend systems to how we collaborate across teams.

For us, simplicity isn’t just a technical choice. It’s a product and cultural philosophy. It allows us to innovate safely, grow responsibly, and most of all, keep customers at the center of the experience. As we like to say: the best systems aren’t the most complex—they’re the most clear, predictable, and human.

If you’re curious about functional programming, data-oriented development, or how Nubank builds at scale, check out future Meetups and posts here on the Building Nubank blog. And if you’d like to dive deeper, explore the book Clojure Brain Teasers or join our community learning group. Because learning together is also a way to keep things simple.

Check our job opportunies