Moving from a WordPress Monolith to Ruby on Rails Microservices
GrowthHackers is a marketing platform that offers a set of tools and also serves as a marketing community for professional learning and growth. They needed to modernize their solution and also boost product development.
MobiDev transformed their solution architecture from a monolith to microservices and migrated it from WordPress to Ruby on Rails. We also helped them build a twice-a-week release cycle.
The Story Behind the Monolith to Microservices Migration
GrowthHackers ran two products. The Community is a communication hub that has multiple contributors, including guests from NASA and Twitter. The Projects is a platform that helps growth teams achieve their objectives.
The Community was located in a WordPress blog, which by 2014 had become a technological dead end that didn’t enable growth. The company partnered with MobiDev to modernize their communication hub.
We split the system into microservices and moved Community to Ruby on Rails for better performance.
Business Value of Migrating Monolith to Microservices
- Performance problem solved through optimized interactions between services.
- Main parts split into their own services. User authentication, integrations and billing each run as a separate service.
- A codebase new engineers can learn quickly. Business logic is divided into entities such as card, project and integration, so a new team member, or an entirely new team, can study the project quickly.
- Twice-per-week releases with a product team of 12 at its peak, while the client’s focus stayed on business growth.
What the Client Says
Looking for an awesome offshore development team? Check out MobiDev. I’ve been working with them for years.
Sean Ellis
CEO
Project Scope of WordPress to Ruby on Rails Move
Stage 1. Monolith to microservices, WordPress to Ruby on Rails. We deconstructed the monolith into microservices and rebuilt Community on Ruby on Rails. Smart caching and Redis handled the performance risk.
Stage 2. Growth and automation. As functionality grew, we containerized the main parts with Docker, running on Heroku with PostgreSQL. We applied domain-driven design on Rails.
Stage 3. Product evolution support. Dynamic work at that release pace took significant management effort. We kept the process visible to the client and handled much of the routine.
Deliverables of the GrowthHackers Migration Project
- Microservices architecture replacing the original monolith
- Community platform on Ruby on Rails
- Separate services for user authentication, integrations and billing, containerized with Docker
- Heroku hosting with PostgreSQL
- Caching layer on Redis
- Domain-driven business logic layer on Trailblazer
- Admin panel on Active Admin
- Background job processing with Sidekiq
- Third-party integrations including Stripe, Slack, Segment, Optimizely, Jira, Algolia, Zapier and Sentry
- Automated test suites with RSpec, MiniTest, Capybara and Selenium
- Full data migration from WordPress to Rails for Community
- Smooth transition support with both WordPress and Rails working in parallel for the transition period.
Tech Stack
Has Your Product Outgrown the Platform It Started On?
Tell us what your legacy code is blocking, and we’ll plan the migration to a new architecture.
FAQ
When parts of the system need to change, scale or ship on different schedules, and the monolith forces them to move together. A small product with one team usually does better as a well-structured monolith, because microservices add network calls, deployment work and monitoring. The signal to split is friction you can name: one module’s release blocking another’s, or one component’s load forcing the whole app to scale. On GrowthHackers, user authentication, integrations and billing each required their own testing and deployment procedures, which is the kind of difference that justifies separate services.
Split along business capabilities, not technical layers. Domain-driven design helps here: you map the core business entities and the rules around them, and each service owns a coherent part of the domain and its data. Splits drawn around database tables or UI screens tend to produce services that call each other for every request. On this project, Trailblazer brought domain-driven design to the Rails codebase.
WordPress works well for content sites. It gets harder when the site turns into a product with user accounts, billing, custom workflows and many integrations, because each of those ends up as a plugin or a workaround the core was not designed for. A custom application on a framework like Ruby on Rails, Django or Laravel gives you a data model and business logic you control. The cost is that you now own everything WordPress gave you out of the box, from the admin interface to the editor. For GrowthHackers, the Community site moved from WordPress to Ruby on Rails as part of the microservices migration.
The usual cause is chattiness: a request that used to be one function call becomes several network calls between services. Caching data that is read often and changes rarely, keeping service boundaries coarse enough that common requests stay inside one service, and measuring latency before and after each split all help. So does moving work the user does not need to wait for into background jobs. On GrowthHackers, performance was the main concern going in, and caching with Redis addressed it.
Rails suits product teams that change features often, because its conventions and large gem library keep routine work fast. Its weak spots are raw throughput and memory per process, so services that handle heavy computation or very high request volume are often written in Go, Java or .NET instead, and Node.js is common for I/O-heavy services with many concurrent connections. Many systems mix them: Rails for business logic that changes every sprint, a faster runtime for the hot path. Rails also needs discipline as a codebase grows, which is where structure libraries such as Trailblazer come in. GrowthHackers ran Ruby on Rails with Sidekiq for background jobs and Active Admin for administration.
Frequent releases depend on small changes, automated tests that run on every commit, and a deployment pipeline nobody has to babysit. Process matters as much as tooling: a release calendar the business can see, clear ownership of each area, and someone absorbing the coordination so product owners are not pulled into it. On GrowthHackers, test suites in RSpec, MiniTest, Capybara and Selenium and CI on Codeship and Semaphore were part of the setup behind the release cadence.
Structure the code around the business, so module and class names match words the product team already uses. Keep business rules out of controllers and views, document the decisions that are not obvious from the code, and keep test coverage high enough that a newcomer can change something and find out what broke. Consistent patterns matter more than clever ones. On GrowthHackers, the architecture followed the subject matter and its entities, so the code reads in the product’s own terms.
Give each service its own pipeline, tests and deployment rules, packaged in containers so it runs the same way on a laptop, in CI and in production. Contract tests between services catch breaking changes before release, and end-to-end tests cover the few journeys that cross many services, such as sign-up to payment. Billing and authentication usually get the strictest checks, because a bug there costs money or locks users out. On GrowthHackers, Docker containers carried the interactions between microservices.
Treat integrations as their own part of the system rather than scattering API calls through the codebase. A dedicated integration layer with retries, rate-limit handling, logging and alerts means a partner’s outage or API change breaks one feature instead of the whole product. Keep a list of every integration with its owner and the API version in use, because providers deprecate versions on their own schedule. On GrowthHackers, integrations were one of the platform’s main parts, alongside authentication and billing, covering services from Stripe and Slack to Segment and Algolia.
Usually yes, at least at first. Each service needs hosting, monitoring, logging, and a deployment pipeline, and the team spends time on coordination that a monolith never needed. The savings come later and only where the split matches real differences in load or change rate, for example, scaling one busy service instead of the whole application. Keeping services on a shared platform and a shared database engine holds the operational overhead down. The GrowthHackers services were unified under Heroku and PostgreSQL.
Often, but not always as a full rewrite. AI features need clean access to data and a place in the code where a new capability can plug in without touching everything else. If business logic is tangled through a monolith, every AI feature becomes a risky change across the codebase, so modernizing the relevant part first is usually cheaper than forcing AI in. If the data is reachable through stable APIs, AI can often sit on top as a separate service. A system split into domain entities and separate services, as GrowthHackers was, gives a new AI service clear boundaries to connect to.
The features that ship are the ones built on data the product already has, with a clear way to tell when they are wrong: content moderation and spam filtering, semantic search, summaries of long threads, tagging and related-post recommendations, and drafting help inside forms. Features that get promised and then quietly dropped tend to be open-ended, like an assistant that runs growth experiments on its own or predicts which ideas will work. Those need data most products do not have and an accuracy users will not forgive missing. A community platform like GrowthHackers, with search already running on Algolia, is a fit for search and moderation features first.
Enough examples of the thing you want the model to do, traceable to an outcome, and permission to use them. For recommendations, that means user behavior events. For moderation, it means past content with decisions attached. For search, it mostly means the content itself, which is why search is often the easiest place to start. With pretrained models and retrieval, volume matters less than people expect, and data quality and access matter more. The GrowthHackers stack included analytics integrations such as Segment and Kissmetrics, which is where behavioral data for features like recommendations usually starts.
It helps with the mechanical parts: reading unfamiliar code, generating tests around existing behavior before you move it, drafting boilerplate for new services, and translating repetitive code. It creates rework when it is trusted with the decisions that make a migration succeed, such as where service boundaries go, how data is split and what happens to transactions in flight. Generated code that compiles and passes a happy-path test can still change behavior in ways nobody notices until production. Every AI-written change still needs review by an engineer who understands the domain, and a test suite strong enough to catch regressions. GrowthHackers had RSpec, MiniTest, Capybara, and Selenium in its stack, and that kind of test coverage is what makes AI-assisted changes checkable.
Model usage is billed per request or per token, so cost grows with adoption instead of staying flat like hosting. On top of that come search index or vector database costs if you use retrieval, monitoring and evaluation to catch quality drift, and engineering time when a provider changes or retires a model. Caching frequent answers, routing simple requests to smaller models and setting per-user limits keep the bill predictable. GrowthHackers already ran error tracking and logging through Sentry, Rollbar, Logentries and Papertrail, the same kind of tooling where AI failures and usage should be watched.
Define what a good answer looks like with a set of real examples, test every prompt or model change against that set before release, and log production output so you can review failures. Constrain the model with retrieved context and structured output rather than open-ended generation, and give users a way to flag bad answers. Treat AI changes like code changes, with the same review and release process. On a product releasing as often as GrowthHackers did, that evaluation step has to be automated or it gets skipped.