Design and frontend implementation for Rails teams. The surface that actually ships, not a reasonable approximation of a Figma file.
You have a strong engineering team that ships features fast, and the UI is the thing that keeps slipping. Figma files get handed to backend developers who do their best, and the result is a reasonable approximation of the design, not the design.
This is the work we do. Design plus Rails frontend implementation, by the same operator, with the same hands on Figma and the actual production code.
What we build
Real Rails frontends, on the current Rails stack:
- Production UI on Rails 6 through 8, with Hotwire, ViewComponent, Tailwind, Sass and PostCSS as the toolset
- Design systems that ship (see Design Systems for the deeper system work)
- Page redesigns and full app UX, scoped per app
- Component refactors that consolidate two-and-a-half versions of every button into one canonical version
- Production-ready code, no invented build systems, no unnecessary dependencies
Why Meticulous
We have been shipping Rails since before 1.0. Meticulous's first Rails-based project shipped in late 2005, around the version 1.0 release. We have been writing Ruby and Rails continuously since.
The Rails Foundation hired us to redesign the official Guides in 2024, working with Amanda Perino. Code review came from various core team members, including Carlos and DHH.
The thing that is hard for clients to find elsewhere: a designer who codes, on the same Rails stack the team is shipping. Most product design shops hand off comps and call it done, and most Rails consultants do not do design. We do both.
How the engagement runs
Project shapes vary. Typical ranges:
- Component sprint. Four to six weeks. A focused redesign of one app surface, with design and production implementation in the same engagement. Often the entry point.
- Full app redesign. Three to six months. Page-by-page or section-by-section, shipping behind feature flags, with design system work folded in as needed.
- Long-running build-out. Six to twenty-four months. Sustained design and frontend implementation for teams that prefer ongoing capacity over discrete engagements.
We have occasionally run engagements for two years or more. Calendar usually runs at least a quarter ahead.
FAQ
We already have designers. Can you just do the Rails implementation?
Yes. The "designer who codes" framing is what we lead with, but we also take pure frontend implementation work where the design is already settled and your design lead is in the loop. The thing we do not do is rebuild a UI from a Figma file without your design lead in the loop.
What if we do not use Hotwire?
Rails 6 through 8 with various combinations of Hotwire, Stimulus, Turbo, ViewComponent, Phlex, Tailwind, vanilla JS, or React are all in scope. We have stronger opinions about what Rails does well than about which JavaScript layer sits on top.
How long do projects typically run?
Four-week sprints through six-month engagements is the typical range. Sustained engagements occasionally run two years or more.
What is the investment?
Component sprints start around $25K. Full app redesigns and long-running build-outs run $40K to $200K depending on scope. Engagements are scoped per app rather than priced from a list.
What if we want to build the design function internally?
That is a different engagement shape. See Embedded Design for the build-the-function-and-hand-it-off work, including the operating model.
Who this is for
Rails teams of three or more engineers shipping production software, where the UI is the constraint and the team would rather invest in fixing it than keep apologizing to customers.
Start a conversation
If your Rails team's UI is the constraint, get in touch. For a smaller first scope, the UI Coherence Diagnostic ($2,500, one week) identifies the worst gaps and recommends fixes.
