A namespace will not load at startup
A deps.edn alias overriding the paths vector, a build step that did not include the cljc source, or a hyphen vs underscore mismatch between the file and the namespace declaration.
Classpath assembled correctly
Running Clojure?
Clojure code bases are usually small, dense, and written by the same two engineers who are no longer around. The problems we see are rarely bugs in the code. They are classpath conflicts from a fifteen year old transitive, a macro someone wrote once and nobody wants to touch, or a REPL driven workflow that drifted from source. We read the REPL, read the project files, and put the thing back on a path your current team can maintain.
What it is
Clojure is a Lisp that targets the JVM, JavaScript through ClojureScript, and the CLR through ClojureCLR. Rich Hickey released the first version in 2007 with a focus on immutability, functional programming and a pragmatic relationship with host platforms. Data is values; code is data; state is explicit and rare.
The language is used heavily in fintech, in data pipelines where immutable reasoning matters, and in product teams that want a small language a small team can own. Its tooling has settled around deps.edn and the Clojure CLI, with Leiningen still common in older projects. ClojureScript ships to browsers, often paired with Reagent, Re-frame or Rum.
The honest version
No technology is all upside. This is where Clojure earns its place and where it tends to cause trouble.
Sound familiar?
The Clojure problems that bring people to us, and what you have once each one is fixed.
A deps.edn alias overriding the paths vector, a build step that did not include the cljc source, or a hyphen vs underscore mismatch between the file and the namespace declaration.
Classpath assembled correctly
A thread first used inside a thread last, a quoted form that should be unquoted, or a binding vector that lost a value in the middle. Stack traces point into the macro's own body rather than yours.
Macro behaves on every input
A map that used to have a key, a value that is now nil, or an upstream service that changed its response shape. Specs are doing their job; the question is what to loosen and what to fix at the source.
Boundary contracts honest
Interop calls without type hints force reflection on every invocation. Not a correctness bug, but a 10x performance tax that only shows up under load.
Hot paths free of reflection
A large project with heavy macros and uberjar output pushing the compiler out of memory. Raising heap helps once; shrinking the AOT surface helps for good.
Build back inside the heap
Functions redefined at a REPL, instance state that only exists because somebody evaluated an expression once, and a production image nobody can reproduce from the repo.
Repo matches the running process
A function that assumed a shape it never actually enforced. Adds a spec or Malli schema at the boundary, finds the three other places making the same assumption.
Contracts applied at boundaries
What we do
Call us for one broken namespace, or let us own the Clojure estate.
How it works
Tell us what's going wrong. We look at it, then tell you plainly what's wrong and what it will cost.
We fix the cause, not the symptom. If something is down, getting it back up comes first.
Backups, monitoring, updates and access, so the same problem can't quietly come back.
You get a plain-language write-up. Or we stay on for hosting, upkeep and new work.
Often found together
We work on the whole stack, so the problem can be wherever it actually is.
Yes, this is where many engagements begin. We start with a dependency and namespace map, confirm the build is reproducible, and only then make behavioural changes. Clojure projects are usually small enough that a careful first week pays for itself several times over.
In most cases, yes. The Clojure CLI with deps.edn is the direction the community has taken, tooling targets it first, and the migration is usually straightforward once alias and uberjar needs are mapped. We do it in a branch and prove parity before anything is merged.
Clojure stack traces walk through Java frames, macro expansions and lazy sequences before reaching user code. We teach teams to read them, and we add spec or Malli at the boundaries so errors surface closer to where they were caused.
For a small team that will own the service for years, often yes. For a team that will churn through engineers quickly, the hiring and onboarding cost is real and should be factored in. We are happy to say so plainly before you commit.
Yes. Many of the trickier Clojure engagements turn out to be on the ClojureScript side, with shadow-cljs build issues, React interop, or Re-frame subscriptions that have drifted from the app db. We work on both ends.
The quote is at no charge. Share the deps.edn, the stack trace, or a link to the repo and we come back with a price before any commits land.
Free estimate
Tell us what you're running and what's going wrong. A person reads it and comes back with an estimate.
Your message is with a real person, and we'll get back to you soon.
Rather talk now? Call us: