Technical consultancy & Ruby development

From fuzzy problem
to working software.

Rails & Ruby consultancy for teams facing complex codebases, performance problems, and architectural decisions — we find the actual problem, explain it clearly, and fix it without rewriting everything.

We anchor our ethos, judgment, and our efforts in the fundamentals of software engineering. We take on a limited number of engagements at a time, work inside your team, and leave code that is easier to read than the day before.

Ruby · Rails · PostgreSQL · Hotwire · AI · Elasticsearch

Start an inquiry → See selected work →

Real clients. In production. A small team, engaged directly by the people who do the work.

01 — Problems you solve

When the code stops cooperating.

You don't usually hire a consultancy for what works. You reach out when something is hard: slow, fragile, unclear, or just too much to carry alone. These are the problems we exist to solve.

• It's too slow to ship.Features that should take days take weeks, buried under coupling and untested code.
• It breaks when you touch it.No safety net, no confidence, and one wrong move takes the site down.
• It doesn't say what it does.Naming that lies, logic hidden in callbacks, and a codebase that only one person fully understands.
• It's too expensive to run.Unbounded cloud bills, runaway jobs, and queries that scale with traffic, not against it.
• It's too hard to change.A framework upgrade that feels like a rewrite, or a decision you can't safely reverse.
• It can't keep up.Queries that only slow down as traffic grows, background jobs that pile up, and scaling that means throwing money at it.
• It needs a capability it doesn't have.Search that should just work, or AI added to an existing product without rewriting it.
• It's too much to carry.You need senior Ruby expertise for a difficult project, without a permanent hire.

02 — What we do

Turning those problems into working software.

Hands-on work inside your team — building new systems, speeding up the ones that slowed down, and modernizing the ones you're afraid to touch. Every engagement ends with code that's easier to read than the day before.

• Ruby & Rails developmentGreenfield apps and steady-state services, idiomatic, tested, and easy to read.
• Performance engineeringMeasure what's slow, then make it fast. Profiling, query tuning, and concurrency that scales.
• Architecture & code reviewStructural reviews that protect the next hire's sanity and unblock the team.
• Difficult backend workPayments, integrations, batch jobs, and the side channels that are too much to carry alone.
• Technical consultancyAudits, roadmaps, and hands-on guidance where a team is stuck.
• Legacy modernizationUpgrading frameworks and debt without rewriting history.

03 — Selected work

Engagements in the field.

A selection of engagements, real clients.

04 — Engineering philosophy

Emergent over prescribed aesthetics.

These are not trends. They are the operating rules we apply to every engagement, dense on purpose, because clarity rarely fits in a single line.

Explicit over implicit

Show the work; hide nothing that costs money to understand.

Expose state and inner workings

A system you can read is a system you can fix.

Dense, not sparse

Respect the reader's attention and the network's bytes.

Engineered for human vision

Typography, rhythm, and hierarchy do the heavy lifting.

Regiment functionalism

Every element must earn its place with a job to do.

Performance is design

Fast is a feature, not an afterthought.

Verbosity over opacity

Preferring a few extra bytes to a confused engineer.

Ignore design trends

Timeless and unfashionable. We expect this to outlive yours.

Flat, not hierarchical

Importance is earned by content, not by being big.

As complex as it needs to be

Diametrically opposite of minimalism.

Objective reasoning

Driven by common sense, metrics, and evidence.

Don't infantilize users

Treat engineers and power users like adults.

Coffee first

A well-brewed decision beats a fast one.

We don't hide the machinery. Here is the kind of code we leave behind — small, explicit, and easy to read.

# kava-ir-kodas — we brew software, one commit at a time
module Kava
  class Consultancy
    def self.brew(clients)
      clients.map { |client| client.with(self) }
    end

    attr_reader :client, :reviewed, :shipped

    def initialize(client)
      @client    = client
      @reviewed  = false
      @shipped   = false
    end

    def with(consultancy)
      consultancy.review!(self)
      consultancy.ship!(self)
      self
    end

    def review!
      raise Unreviewed unless reviewed
      self
    end

    def ship!
      raise Unreviewed unless reviewed
      @shipped = true
      self
    end
  end
end

05 — How an engagement works

Tell us the problem. We handle the rest.

1. 01

   Tell us the problem.

   Send a message describing what's stuck. No scope, no pressure — just the real problem.

2. 02

   We investigate.

   We read the code, trace the failure, and find where it's actually broken — not just the symptom.

3. 03

   We explain.

   You get an honest assessment and a clear plan, in language you understand — not jargon.

4. 04

   We fix it.

   We work inside your team, writing code that's easier to read than the day before.

5. 05

   We leave.

   You're left with working software, documentation, and a team that can carry it forward.