How to find Clojure developers in 2026: A sourcing guide

Clojure is a Lisp for the JVM, designed by Rich Hickey and released in 2007. It is a functional, dynamically typed language built around a few core convictions: data matters more than objects, simplicity matters more than ease, and stable APIs that rarely break matter more than constant churn. That philosophy attracted a particular kind of engineer. Experienced, opinionated, and deeply invested in getting the fundamentals right. It also attracted Nubank, which bet its entire banking infrastructure on Clojure and now serves over 105 million customers across Brazil, Mexico, and Colombia on more than 3,000 Clojure microservices.

Unlike most niche languages, Clojure has a corporate anchor. Nubank acquired Cognitect, the company behind Clojure founded by Rich Hickey himself, in 2020. With 11,337 employees, Nubank is the single largest employer of Clojure developers in the world. But Clojure is not just a fintech language. Walmart runs its 5,000-plus store data system on Clojure. Metabase, the open-source analytics platform with 46,700+ GitHub stars, has its entire backend in Clojure. CircleCI built its CI/CD platform on it. Cisco's ThreatGRID malware analysis uses it. Funding Circle makes lending decisions with it. We covered Clojure briefly in our niche language sourcing guide. This is the deep dive.

This guide covers where Clojure developers work on GitHub, what separates a senior Clojure engineer from someone who completed a tutorial, how the ecosystem spans the JVM, the browser, and the command line, and how to build a sourcing workflow that reaches Clojure developers before they start looking.

The Clojure developer market in 2026

Clojure has one of the smallest professional developer pools of any language in production use. The global community is roughly 10,000 to 20,000 professional users. The State of Clojure 2025 survey had 1,545 respondents, with 73% reporting they use Clojure at work. For comparison, Go has 3 to 4 million developers, Python has 16 million-plus, and JavaScript has over 20 million. Clojure's pool is roughly 100 times smaller than JavaScript's, and even smaller than Elixir's. That ratio shapes everything about hiring in this ecosystem.

The community is small, but skewed heavily toward seniority. The language's Lisp syntax, emphasis on immutability, and data-oriented programming model attract engineers who have already spent years in mainstream languages and deliberately chose something different. Very few junior developers start with Clojure. The typical Clojure practitioner has years of Java, Python, or JavaScript behind them and picked Clojure because they found its approach to state management, concurrency, and system design better in ways that mattered to them. That self-selection means the average quality of the candidate pool is high, but it also means nearly everyone in it is already employed and not actively looking.

Compensation matches the scarcity. The US average salary for Clojure developers is $129,348 according to ZipRecruiter in 2026. The Stack Overflow 2025 Developer Survey ranked Clojure alongside Erlang as the top-paying programming language globally. Senior Clojure developers at fintech companies, hedge funds, and data-intensive startups can command well above that. Clojure has appeared in the top three highest-paid languages for multiple years running. The companies competing for this talent include Nubank, Walmart, Metabase, and a long list of fintech firms and quantitative trading shops.

Hiring cycles for Clojure roles run 60 to 120 days, and specialized positions in distributed systems or financial infrastructure can take longer. The bottleneck is not pipeline efficiency. It is finding qualified candidates at all. In a pool of 10,000 to 20,000 professionals, a large chunk work at Nubank, which is headquartered in Brazil and offers competitive compensation plus an engineering culture built entirely around Clojure. The rest are scattered across small-to-mid-size companies worldwide, many of them remote-first.

Where do Clojure engineers concentrate by domain? Fintech is the largest vertical: banking, payments, lending, trading, and risk analysis. Nubank and Funding Circle are the headline examples, but dozens of smaller fintech companies use Clojure for transaction processing, compliance engines, and quantitative modeling. Data analytics and business intelligence is the second major cluster, anchored by Metabase. Then DevOps and infrastructure tooling (CircleCI), security and threat analysis (Cisco ThreatGRID), retail and supply chain (Walmart). These are all data-heavy domains where correctness matters more than speed-to-market, and where reasoning about complex transformations on immutable data structures pays off over years of maintenance.

Where Clojure developers contribute on GitHub

Clojure's open source ecosystem is compact enough that individual contributors stand out. A single meaningful contribution to a core project carries more weight here than in larger ecosystems, because there are fewer people doing the work. GitHub is one of the most effective sourcing channels for Clojure engineers because the most important tools in the ecosystem are all developed in the open.

The language itself. clojure/clojure is the core language repository: the compiler, standard library, and runtime. Contributions here are rare and significant. Rich Hickey and a small group of core maintainers control this repo tightly. Even filing a useful bug report or contributing to design discussions on JIRA (Clojure uses JIRA, not GitHub Issues, for core development) indicates someone who understands the language at a foundational level. clojure/clojurescript is the compiler that targets JavaScript, enabling Clojure in the browser and Node.js.

Analytics and business intelligence. metabase/metabase is the biggest Clojure project on GitHub with 46,700+ stars. Its entire backend is written in Clojure. Contributors to Metabase work on one of the most widely-deployed Clojure applications in production, dealing with database drivers, query compilation, caching, and API design at scale. If a candidate has meaningful contributions to Metabase's backend, that is real production Clojure experience.

Web development. ring-clojure/ring is the HTTP server abstraction behind nearly every Clojure web application, the equivalent of Rack in Ruby or WSGI in Python. weavejester/compojure is the routing library built on Ring. Production web services depend on both. Contributors understand HTTP, middleware composition, and the Clojure approach to building web systems from small, composable pieces rather than monolithic frameworks.

Scripting and tooling. babashka/babashka is a fast-starting scripting runtime for Clojure that eliminates the JVM startup penalty for command-line tools. It made Clojure viable for shell scripting, CI/CD automation, and quick utilities where JVM startup time was previously a dealbreaker. Contributors to Babashka understand both Clojure and systems-level concerns like GraalVM native compilation, and they tend to be productive generalists.

Data and databases. tonsky/datascript is an immutable in-memory database implementing a subset of Datomic's query language. ClojureScript frontend applications use it heavily for client-side state management. Contributors understand both database internals and Clojure's data-oriented philosophy. Datomic itself, Rich Hickey's database, is proprietary, but its influence runs through the Clojure ecosystem's approach to data as immutable facts over time.

Build tools and dependency management. technomancy/leiningen was the dominant Clojure build tool for years and remains widely used. The newer clojure/tools.deps (the official Clojure CLI and dependency resolver) reflects the ecosystem's shift toward simpler, data-driven tooling. Contributors to either project know the build and dependency ecosystem well.

Clojars packages. Clojars is Clojure's package registry, hosting 24,190 packages with publicly listed authors. Unlike npm or PyPI, the ecosystem is small enough that popular package authors are individually identifiable. If someone maintains a well-documented, widely-used Clojars library, especially one dealing with concurrency, data transformation, or JVM interop, they are almost certainly a senior Clojure practitioner. Cross-referencing popular Clojars packages with their GitHub maintainers is manual work, but it is one of the most effective sourcing methods for this community.

Quality signals in Clojure code

Clojure is a Lisp. If you evaluate Clojure code with object-oriented expectations, you will misjudge almost everything. Data over objects, pure functions over methods, composition over inheritance. The whole paradigm is different. Seniority signals on GitHub apply broadly, but Clojure has specific markers of expertise tied to the language and its Lisp heritage.

Data-oriented design. Rich Hickey's central design idea is that data should be represented as plain data (maps, vectors, sets, and lists), not as objects with methods. An experienced Clojure developer uses maps with keyword keys rather than defining classes or record types for most data. They pass data through pipelines of pure functions. They avoid creating unnecessary abstractions. This is the most fundamental signal: does the code treat data as data, or does it try to recreate object-oriented patterns in a functional language? A developer who defines a class hierarchy in Clojure is bringing habits from Java. A developer who uses plain maps and pure functions is thinking in Clojure.

Immutable data structures. Clojure's core data structures are immutable and persistent. They share structure rather than copying on modification, which eliminates a whole class of concurrency bugs and makes code easier to reason about. Look for code that works with immutable data naturally rather than fighting it. Developers who reach for atoms, refs, or agents only when mutable state is genuinely needed demonstrate proper understanding of Clojure's state management model. Overuse of mutable references is a red flag.

REPL-driven development. Clojure's REPL (Read-Eval-Print Loop) is not a debugging afterthought. It is the primary development workflow. Experienced Clojure developers write code interactively, evaluating expressions in a connected REPL, building up functions incrementally, testing ideas before committing them to files. Look for code structured for REPL evaluation: small, composable functions with clear inputs and outputs, comment blocks with example expressions (often called "rich comment blocks"), and designs that make it easy to call any function in isolation. Developers who write Clojure like they would write Java (define everything, compile, run, check output) are missing the workflow that makes Clojure productive.

Transducers and lazy sequences. Clojure's sequence abstraction is one of its strongest features. Lazy sequences let you process large datasets without loading everything into memory. Transducers go further: they are composable algorithmic transformations that decouple the transformation logic from the data source and destination. A developer who uses transducers appropriately (for performance-sensitive pipelines, reducing intermediate collections) and lazy sequences correctly (understanding realization, chunking, and the pitfalls of holding onto the head) has real depth in Clojure's data processing model.

Concurrency primitives. Clojure provides multiple concurrency models: atoms for uncoordinated synchronous updates, refs and software transactional memory for coordinated synchronous updates, agents for asynchronous updates, and core.async for CSP-style channel-based concurrency. An experienced developer picks the right primitive for the situation rather than defaulting to one approach. Knowing when to use core.async channels versus simple atoms, or when the STM model is worth its overhead, is a strong signal. Wrapping everything in an atom, or reaching for core.async where a simple future would suffice, indicates surface-level knowledge.

Spec and schema validation. clojure.spec is Clojure's built-in system for describing the shape of data and functions. It gives you runtime validation, generative testing, and documentation in one tool. Developers who write comprehensive specs for their data and functions show a mature approach to system design. In a dynamically typed language, spec provides many of the same guarantees as static type systems while keeping Clojure's flexibility. Alternative approaches like Malli or Schema show similar awareness of data validation discipline.

Macro hygiene. Clojure is a Lisp, which means it supports macros: code that writes code. Macros are powerful and dangerous in equal measure. An experienced Clojure developer uses them sparingly and correctly: only when a function cannot achieve the same goal, with proper use of syntax-quote and gensym to avoid variable capture, and with clear documentation explaining why a macro was necessary. Overuse of macros is one of the clearest signals of a developer who is excited by Clojure's power but has not yet learned restraint. The Clojure community has a saying: "data > functions > macros." A developer who follows that hierarchy gets the language.

The Clojure ecosystem: JVM, ClojureScript, and Babashka

Clojure is not a single-target language. It runs on the JVM, compiles to JavaScript via ClojureScript, and has a fast-starting native runtime in Babashka. This matters for sourcing because a Clojure developer's target platform shapes their skill set and the kinds of projects they contribute to.

JVM Clojure is the primary platform. Clojure runs on the Java Virtual Machine with full interop. This is why companies like Nubank and Walmart adopted it: they get Clojure's functional programming model and data-oriented philosophy while keeping access to the entire Java ecosystem, its libraries, profiling tools, deployment infrastructure, and decades of JVM performance engineering. An experienced Clojure developer understands the JVM well: garbage collection tuning, classloading, JIT compilation behavior, and how Clojure's persistent data structures interact with the JVM's memory model. Calling Java from Clojure and vice versa is a practical skill that matters in production. The strongest candidates move fluidly between both when the situation requires it.

ClojureScript compiles Clojure to JavaScript, putting Clojure in the browser and on Node.js. The ClojureScript ecosystem has its own frameworks: Reagent (a React wrapper), Re-frame (a state management pattern built on Reagent), and Fulcro (a full-stack framework). DataScript provides client-side immutable databases. Developers who work in ClojureScript understand both Clojure's functional paradigm and the realities of frontend development: DOM manipulation, browser APIs, JavaScript interop, and build tooling. Full-stack Clojure developers who write both JVM Clojure and ClojureScript are especially useful because they can share code and data models across the entire application.

Babashka solves Clojure's biggest practical complaint: JVM startup time. By compiling Clojure to native binaries via GraalVM, Babashka makes Clojure viable for scripting, command-line tools, and CI/CD pipelines where a multi-second JVM boot is unacceptable. It has grown into its own ecosystem with a package registry and active community. Contributors tend to be pragmatic generalists who care about developer productivity and real-world usability, not just language purity.

Rich Hickey's influence on the Clojure ecosystem deserves a note. Hickey is one of the most deliberately thoughtful language designers alive. His talks ("Simple Made Easy," "The Value of Values," "Hammock-Driven Development") have influenced programming philosophy well beyond the Clojure community. Haskell developers appreciate mathematical rigor; Clojure developers value pragmatic simplicity. Hickey's design decisions (immutability by default, data-oriented programming, stable APIs that rarely add breaking changes) attract engineers who share those values. When you source Clojure developers, you are sourcing for a philosophy as much as a technology.

The Clojure community is small but tightly connected. Clojure/conj is the annual conference organized by Cognitect (now Nubank). London Clojurians runs approximately 50 events per year. Clojureverse is the primary discussion forum. Clojure TV hosts conference talks. The Clojurians Slack is one of the most active language-specific Slack communities. Because the community is small, reputation carries far. Conference speakers, forum regulars, and Slack contributors are identifiable. They have GitHub profiles, Clojars packages, and public contribution histories. One referral from a community member often leads to several strong candidates, because everyone in a 10,000-person community tends to know each other. Scala developers share the JVM ecosystem and many of the same companies, making them a natural adjacent talent pool.

How to search for Clojure developers on GitHub

GitHub's search is a starting point, but Clojure's extremely small community requires different calibration than any mainstream language. The niche language sourcing strategies we covered previously apply here, but the pool is so small that you need to cast a wider net on adjacent skills while holding a higher bar on contribution quality.

Language filter. Filtering by language:clojure in GitHub repository or code search surfaces developers who actively write Clojure. Because the community is so small (10,000 to 20,000 professionals), this filter is extremely targeted. Nearly everyone who appears is a real practitioner. The signal-to-noise ratio is the highest of any language you will search for. The challenge is volume, not quality.

Clojars package authors. Clojars hosts 24,190 packages with publicly listed authors. Because the ecosystem is small enough to be navigable, you can identify the maintainers of widely-used libraries directly. Packages with high download counts that handle core concerns — HTTP, database access, data transformation, concurrency — are maintained by senior engineers. Cross-referencing popular Clojars packages with GitHub profiles is one of the most effective manual sourcing methods for Clojure specifically.

Metabase contributors. Metabase is the most visible Clojure project on GitHub. It has 46,700+ stars and active development. Backend contributors have demonstrated production Clojure experience at scale. This single repository works well as a sourcing channel because it is large enough to have hundreds of contributors but niche enough that every backend contributor has real Clojure skills.

Community sources. Clojure/conj speaker lists are publicly available. London Clojurians event speakers and organizers are identifiable. Clojureverse forum has active posters with linked GitHub profiles. Clojure TV features conference talks by practitioners. These are small, well-defined communities where the most engaged members have public identities and traceable contribution histories.

Contribution recency. In a pool of 10,000 to 20,000 professionals, every active developer matters. With Elixir you can be selective about recency. With Clojure, a developer with any meaningful recent activity is worth considering. Widen your recency filters to six to twelve months rather than three to six. The community is so small that you cannot afford to filter aggressively on timeframe.

Adjacent language signals. Many of the best potential Clojure hires do not have Clojure as their primary GitHub language. Java developers with functional programming interest are the most common pipeline. They already understand the JVM and may have Clojure side projects or library contributions. Haskell developers bring deep functional programming fundamentals that transfer directly. Scala developers share the JVM ecosystem and often have exposure to functional programming concepts. Lisp enthusiasts with Common Lisp, Scheme, or Racket backgrounds have the syntactic and philosophical foundation. Search for developers whose primary language is Java, Scala, or Haskell but who have Clojure repositories. They may be further along the transition than their profile suggests.

A practical Clojure sourcing workflow

Here is what works, from discovery to first outreach.

Step 1: Define the technical profile. "Clojure developer" is too broad to be useful even in a small community. Are you hiring for fintech and data processing (Nubank-style microservices, transaction pipelines)? Data analytics and business intelligence (Metabase-style query engines)? Web applications (Ring, Compojure, Pedestal)? Full-stack with ClojureScript (Reagent, Re-frame, Fulcro)? DevOps and tooling (Babashka, CI/CD)? Each maps to different GitHub repositories, different Clojars packages, and different contributor communities. An engineer who contributes to Metabase has a different skill set than one who contributes to Babashka, even though both write Clojure.

Step 2: Identify target repositories. Based on the technical profile, list the GitHub repositories and Clojars packages where your ideal candidate would contribute. For data and analytics: metabase/metabase, tonsky/datascript. For web services: ring-clojure/ring, weavejester/compojure. For frontend: reagent-project/reagent, day8/re-frame. For scripting and tooling: babashka/babashka. For the language itself: clojure/clojure, clojure/clojurescript. For general ecosystem infrastructure: technomancy/leiningen, clojure/tools.deps. Map the role to the repos.

Step 3: Extract contributors. Use GitHub's contributor graphs or tools like riem.ai that index GitHub event data at scale. Focus on recent contributors with meaningful contributions: code changes, code reviews, and design discussions, not documentation typos. Because the Clojure community is even smaller than Elixir's, your initial list may be 10 to 30 people rather than 50 to 100. That is expected. In a 10,000-person community, you are looking for specific individuals, not statistical samples.

Step 4: Evaluate profiles. Review each candidate's GitHub profile for the quality signals described above: data-oriented design, immutable data handling, REPL-driven development patterns, appropriate use of concurrency primitives, spec or schema usage, and macro restraint. Seniority signals like code review participation and cross-project contributions carry extra weight in a community where reputations are well-known. Check whether they maintain Clojars packages, speak at conferences, or contribute across multiple ecosystem projects.

Step 5: Expand to adjacent backgrounds. Do not limit sourcing to pure Clojure developers. Java developers with functional programming interest or side projects in Clojure are the most common and often most successful transition path. They already know the JVM inside out. Haskell and Scala developers bring functional programming fundamentals that transfer directly. Common Lisp, Scheme, and Racket developers have the Lisp foundation and understand homoiconicity, macros, and the REPL workflow. Even experienced Ruby developers sometimes gravitate toward Clojure for its data processing strengths. Search for developers whose primary language is Java or Scala but who have Clojure repositories or Clojars packages.

Step 6: Craft personalized outreach. Generic recruiter messages get ignored. Clojure developers receive fewer recruiter messages than React or Python developers, which means they have less tolerance for generic ones, not more. Effective developer outreach references specific contributions: "I noticed your Ring middleware for rate limiting. We're building a high-throughput API gateway in Clojure and your approach to composable middleware is exactly what we need." Clojure developers respond better to outreach that demonstrates understanding of the language's philosophy. Mention data-oriented design, simplicity, or specific technical decisions rather than generic "functional programming" buzzwords. The community is small enough that poorly targeted outreach will be discussed.

Step 7: Scale with tooling. The manual workflow above works, but the tiny community means you will exhaust your target repos even faster than with Elixir. Tools like riem.ai automate the discovery and evaluation steps by analyzing 30 million-plus GitHub events per month and surfacing Clojure developers based on actual contribution patterns. Instead of manually cross-referencing Clojars packages and reviewing profiles one by one, you describe the technical profile in natural language ("Clojure developers who contribute to data analytics projects and have experience with database query engines or data transformation pipelines") and get a ranked list of candidates with contribution summaries and quality scores.

Frequently asked questions

How many Clojure developers are there?

An estimated 10,000 to 20,000 professional Clojure users globally as of 2026. The State of Clojure 2025 survey had 1,545 respondents, with 73% reporting they use Clojure at work. The community is tiny compared to mainstream languages, roughly 100 times smaller than JavaScript's developer population, but the quality per capita is high. Clojure developers tend to be senior engineers with strong computer science fundamentals who deliberately chose a Lisp dialect for production work. The small pool is offset by high average experience and technical depth.

What salary should I expect to pay Clojure developers?

Clojure is consistently one of the highest-paid programming languages. The US average is $129,348 per year according to ZipRecruiter in 2026. The Stack Overflow 2025 Developer Survey ranked Clojure alongside Erlang as the top-paying language globally. Senior Clojure developers at fintech companies and hedge funds can command significantly more, particularly in roles involving data processing, quantitative analysis, or distributed systems. The salary premium comes from both scarcity and the fact that Clojure roles tend to require senior-level engineers. Very few companies hire junior Clojure developers.

Do I need to hire someone who already knows Clojure?

Not always, but the ramp-up is steeper than switching between mainstream languages. Clojure is a Lisp. The syntax, data-oriented philosophy, and immutable-first design are fundamentally different from object-oriented languages. Developers with functional programming backgrounds (Haskell, Scala, Elixir, F#) can transfer core concepts. Java developers have the advantage of JVM familiarity and can build on existing knowledge of the runtime, classloading, and garbage collection. The biggest adjustment is thinking in data rather than objects. Clojure's philosophy of "just use maps" and composing small functions is a paradigm shift. For core infrastructure roles, prior Clojure experience matters. For application development on an existing Clojure codebase, strong developers from adjacent ecosystems can ramp in 2 to 3 months.

What is Nubank and why does it matter for Clojure hiring?

Nubank is the world's largest digital bank, serving over 105 million customers across Brazil, Mexico, and Colombia. Its entire technology stack, more than 3,000 microservices, runs on Clojure. In 2020, Nubank acquired Cognitect, the company behind Clojure founded by Rich Hickey (Clojure's creator). With 11,337 employees, Nubank is by far the largest employer of Clojure developers globally and proves that Clojure scales to enterprise-level production workloads. For recruiters, Nubank matters because it creates both supply and demand: it trains large numbers of Clojure developers, and its success convinces other companies that Clojure is a viable production choice.

What Clojure projects should I look for on GitHub?

For the language itself: clojure/clojure and clojure/clojurescript. For analytics: metabase/metabase (46,700+ stars, entire backend in Clojure). For web development: ring-clojure/ring and weavejester/compojure. For scripting: babashka/babashka. For data: tonsky/datascript (an immutable in-memory database). For build tooling: technomancy/leiningen. For HTTP clients and servers: http-kit/http-kit. Contributors to these projects build the infrastructure the Clojure ecosystem depends on. Clojars package authors with well-maintained, widely-used libraries are also strong candidates. Clojars hosts 24,190 packages and the author list is effectively a directory of active Clojure practitioners.

How long does it take to hire a Clojure developer?

Expect 60 to 120 days for experienced Clojure roles, longer for specialized positions in fintech or distributed systems. The bottleneck is the extremely small candidate pool (10,000 to 20,000 professionals globally) combined with high demand from fintech companies and data-intensive startups. Most experienced Clojure developers are already employed and not actively looking. Sourcing from GitHub contribution data, Clojars package authors, Clojure/conj speaker lists, and community channels like Clojureverse and London Clojurians can shorten the timeline by finding candidates who are actively building but not on job boards. Widening the search to include Java developers with functional programming interest or Haskell/Scala developers willing to transition can also expand the viable pool.