How we do, what we do
The 37signals Dev blog is brought to you by the people who build Basecamp and HEY ✌️❤️
Sign up to get posts via email,
or grab the RSS feed.
Modern CSS patterns in Campfire
An in-depth look at how 37signals built ONCE/Campfire using modern features, vanilla CSS, and no frameworks or preprocessors.
Thruster is now open source
A minimal HTTP/2 proxy for easy, production-ready Rails deployments.
My adventures hunting down a Ruby memory leak 🎢
What I learned on the journey chasing a tricky memory leak in HEY.
Speeding up mobile development with Turbo
Native apps run silky smooth user experiences thanks to optimized compiled code, their multitouch actions, and smooth animations. It’s all about speed, speed, speed — except when it comes to speed of development — that’s a completely different story.
Turbo 8 released
Turbo 8 introduces morphing for smooth page refreshes,
view transitions, InstantClick, and more.
Mission Control — Jobs
Dashboard and Active Job extensions to operate and troubleshoot background jobs.
Introducing Solid Queue
A new DB-based queuing backend for Active Job that we open-sourced today.
Basecamp code runs 18% faster with YJIT
You should give it a try if you haven’t done it yet.
Demo of page refreshes with morphing
How page refreshes work, and how they compare to stream actions.
The radiating programmer
The right ceremony can save you from the wrong one.
Building Basecamp project stacks with Hotwire
How we improved project organization in Basecamp using Hotwire to build on top of a legacy drag-and-drop interface.
Exploring server-side diffing in Turbo
An investigation that taught us what we didn’t want to do.
A happier happy path in Turbo with morphing
Turbo 8 is coming with smoother page updates and simpler broadcasts.
Solid Cache
A new disk-backed ActiveRecord::Cache::Store.
Bigger, cheaper, faster.
Navigating personal information with care
Our default for accessing customer information is: we don’t.
2023 Summer Intern Program: Who, what and how
With the program just coming to a close, we take a look back
at our recent intern group and everything they accomplished.
Leaning imperative
Imperative infrastructure tools have trade-offs, but they help us directly and explicitly manage our infrastructure. We’ve embraced these tools and the philosophy they encourage. We are much better for it.
Web programming internship
My summer internship experience at 37signals as a web programmer on the Product team.
Minding the small stuff in pull request reviews
We pay attention to the minutia in pull request reviews,
and for good reasons.
Prometheus metrics at 37signals
How we use Prometheus to ingest, store, and alert based on metrics.
37signals datacenter overview
During our journey off the cloud, we’ve received a lot of questions about our datacenters. No, we do not run them on our own. I’m here to discuss at a high level what 37signals’ datacenter presence looks like.
Globals, callbacks and other sacrileges
Maximalist positions are a thing in our industry. Take a technique, outline its drawbacks, extrapolate you can’t use it under any circumstance, and ban it forever. We are lucky that Rails embraces exactly the opposite mindset as one of its pillars.
A Friday email incident
Because only talking about success stories can be boring, here’s one about a Friday incident that happened while we worked on our cloud departure.
De-cloud and de-k8s — bringing our apps back home
For the Operations team at 37signals, the biggest effort in 2023 is removing our dependencies on the cloud and migrating our application stacks back into the data center onto our own hardware. We’ve already made amazing progress in a fairly short time — let’s get into some details!
Pending tests
I rarely write my tests first or use them to help design my code.
Bringing Card Table to the small screen
A close look at the process we used to make our version of Kanban nice and useful on mobile devices.
Our cloud spend in 2022
Since we published why we’re leaving the cloud, we’ve received a lot of questions about our actual spending. We’re happy to share, both where we currently are and where we’re going.
Active Record, nice and blended
Active Record restates the traditional question of how to separate persistence from domain logic: what if you don’t have to?
Compared to what?
When discussing software design techniques, actual code should be a mandatory ingredient.
Better navigation in HEY
Some of the best releases are ones that people never notice at all.
The 10x development environment
My hunch is that if anything can make you 10 times more productive, it’s the environment not the programmer.
A week in the life of a product designer
An inside look at the work we do (during cooldown).
Making export jobs more reliable
Long-running jobs can create maintenance and support nightmares as they run up against resource and time constraints. What if we could break them up—automatically—into smaller chunks of work?
Vanilla Rails is plenty
A common critique of Rails is that it encourages a poor separation of concerns. That when things get serious, you need an alternative that brings the missing pieces. We disagree.
Faster pagination in HEY
Recently we focused on improving the performance of HEY. Fixing slow database queries for some of the HEY pages was a challenge, so I thought it would be worth writing up a technique we used.
Good concerns
We love concerns and have been using them for years in large codebases. Here we share some of the design principles we use.
Fractal journeys
Good code is a fractal: you observe the same qualities repeated at different levels of abstraction.
Domain driven boldness
How to create a good domain model is the subject of many books, but here’s a lesson I learned at 37signals: don’t be aseptic, double down on boldness.