//ruby on rails engineer - warsaw / remote

Software that ships. Systems that last.

Mossfork is the independent practice of a pragmatic Rails engineer - focused on building resilient systems, from seed-stage MVPs to platforms moving real money. Architecture, code, deploys and the 3 a.m. pager: one pair of hands, zero handoffs.

//the build

Watch a feature happen.

Keep models focused

State machines, UUIDs, and strict relationships. Only data integrity, no business logic callbacks.

Skinny controllers

Routing, rate limiting, and parameter parsing. HTTP layers shouldn't know how the sausage is made.

Robust services

Service Objects encapsulate transactions, external APIs, and jobs. Easy to test and reuse.

Ship with Kamal

Private networks, proxy healthchecks, zero downtime. Infrastructure defined as clean code.

order.rb orders_controller.rb process_command.rb deploy.yml

main ✓ · rails 8.1

1class Order < ApplicationRecord
2  include AASM
3
4  belongs_to :customer
5  has_many :items, dependent: :restrict_with_error
6
7  self.implicit_order_column = "created_at" # UUID PKs
8
9  aasm column: :status, whiny_transitions: true do
10    state :draft, initial: true
11    state :pending, :paid
12
13    event :confirm do
14      transitions from: :draft, to: :pending
15    end
16  end
17end

1class OrdersController < ApplicationController
rate_limit to: 5, within: 1.minute, only: :create
3
def create
  result = Checkout::ProcessCommand.call(
    customer: Current.user,
    params: order_params,
    idempotency_key: request.headers["X-Idempotency-Key"]
  )
10
  if result.success?
    redirect_to result.payload, notice: "Order secured."
  else
    render :new, status: :unprocessable_entity, locals: { errors: result.errors }
  end
end
17end

1class Checkout::ProcessCommand
def self.call(customer:, params:, idempotency_key:)
  new(customer, params, idempotency_key).call
end
5
def call
  Order.transaction do
    validate_idempotency!
9
    order = @customer.orders.create!(@params)
    order.confirm! # triggers state machine
12
    PaymentGatewayJob.perform_later(order.id)
    OrderMailer.with(order: order).confirmation.deliver_later
15
    Result.success(order)
  end
rescue ActiveRecord::RecordInvalid => e
  Result.failure(e.record.errors)
end
21end

1service: core
2image: ghcr.io/mossfork/core
3
4servers:
5  web:
6    hosts: [ 10.0.1.11, 10.0.1.12 ]
7    options:
8      network: "private_net"
9  workers:
10    hosts: [ 10.0.1.13, 10.0.1.14 ]
11    cmd: bundle exec solid_queue:work
12
13proxy:
14  ssl: true
15  host: api.mossfork.dev
16  healthcheck:
17    path: /up

$ kamal deploy ✓ live in 47s zero downtime · private network secure

//pragmatic architecture

Most software dies in the gaps - between the architect and the builder, the builder and the operator. Mossfork removed the gaps. Whether it's a modular monolith or a decoupled service architecture, the goal is maintainability. One engineer who designs it, builds the service layer, ships it, and answers the pager.

//capabilities

01 / 05 - keep scrolling

~/app

Pragmatic Rails

Skinny models, skinny controllers, and robust service layers. Flexible architectures that rely on POROs and patterns to stay understandable and adaptable in year five.

Rails 8Service ObjectsSolid Queue

~/hotwire

Hotwire frontends

Server-rendered interfaces with SPA feel and none of the build-step grief. One broadcast from a model, and every open tab updates itself.

TurboStimulusAction Cable

~/data

Data & performance

EXPLAIN-driven query tuning, honest indexes, and caching that earns its keep. Milliseconds are a feature - and terabytes get a columnar store, not excuses.

PostgreSQLRedisClickHouse

~/ai

Applied AI

Language-model features built the boring way - pgvector for memory, retrieval over your own data, responses streamed live into the page over Turbo.

pgvectorRAGStreaming UI

~/infra

Infrastructure & ops

Docker images, Kamal deploys, Linux boxes configured on purpose and monitored for real. If it pages at night, it pages the person who built it.

DockerKamal 2LinuxCI/CDGrafana

//process

Pragmatic, on purpose.

Discover

A week of questions before a line of code. The expensive mistakes happen before the repository exists.

Architect

Pragmatic choices, written down. Modular monoliths by default, extracted services when they actually solve a real scaling problem.

Build

Small pull requests, real tests, zero-downtime migrations. Momentum you can see in the changelog, week after week.

Ship

Continuous, health-checked, reversible in one command. Deploys so uneventful they stopped being meetings.

Operate

Dashboards, alerts, and a phone that actually rings the builder. Mossfork runs what Mossfork ships.

0apps shipped to production

0uptime, last twelve months

0end-to-end ownership

0handoffs between teams

//the stack

Ruby on Rails◆Hotwire◆Turbo◆Stimulus◆PostgreSQL◆Redis◆Sidekiq◆Solid Queue◆

Kamal◆Docker◆Linux◆Nginx◆Action Cable◆pgvector◆CI/CD◆Grafana◆

//contact

Got a system
in mind?

hello@mossfork.dev↗

booking new engagements from q4 2026 · warsaw / remote