Avg. p99 latency
0ms
A small senior team building production systems in Ruby and Go. We design APIs, ship microservices, and run the infrastructure that keeps them online — on demand, on contract, on call.
Engaged à la carte or as a unit. Each track is staffed by senior engineers who write code, review code, and stay on long enough to see it run in production.
Greenfield products and serious upgrades to existing monoliths. We write the kind of Ruby that scales past the seed round — clear domain models, boring infrastructure, and tests that mean something.
class Booking < ApplicationRecord belongs_to :account has_many :line_items, dependent: :destroy scope :billable, -> { where.not(invoiced_at: nil) } # settle the booking, idempotently def settle! transaction do lock! return if settled? Ledger.post(self) update!(settled_at: Time.current) end end end
For the parts of your system where latency, throughput, and resource cost actually matter. We design services around clear boundaries, then we ship them with the observability you need to operate them.
func (s *Server) Settle(ctx context.Context, req *pb.SettleRequest) (*pb.SettleReply, error) { ctx, span := otel.Tracer("booking").Start(ctx, "Settle") defer span.End() b, err := s.repo.Lock(ctx, req.Id) if err != nil { return nil, status.Errorf(codes.NotFound, "%v", err) } if b.SettledAt.Valid { return &pb.SettleReply{Idempotent: true}, nil } if err := s.ledger.Post(ctx, b); err != nil { return nil, err } return &pb.SettleReply{SettledAt: timestamppb.Now()}, nil }
The deploy pipeline, the dashboards, and the pager. We bring up the platform that lets your engineers ship without blocking on infra — and we stay long enough to hand it back cleanly.
module "booking_svc" { source = "./modules/svc" name = "booking" image = "ghcr.io/acme/booking:${var.sha}" cpu = "500m" memory = "512Mi" replicas = { min = 3, max = 30 } observability = { traces = true metrics = true logs = "json" } slo = { availability = "99.95", latency_p99_ms = "75" } }
We pick stable, well-understood technology and use it well. Below is roughly everything that ends up in a typical engagement.
A four-step engagement that matches how good software actually gets built. We size the team to the problem and stay until production is calm.
One week. We read your code, talk to your team, and write back what we heard. You decide if our model of the problem matches yours.
Architecture sketches, API contracts, and a phased plan with concrete milestones. Costed and dated.
We ship in two-week increments behind feature flags. Every increment is reviewable, deployable, and reversible.
We stay on-call through launch and beyond. When we leave, your team owns the runbooks, the dashboards, and the code.
A scoped piece of work with a fixed shape. New service, monolith carve-out, platform spin-up.
A senior team that joins your standups, owns areas of the system, and ships alongside your engineers.
Platform & SRE coverage on a steady monthly basis. Pipelines, dashboards, on-call, incident review.
Short note is fine. We’ll follow up with the right questions before any meeting.