Skip to content
Filipe Meireles

Work at GalleyCase study

Feature Control

Releasing a feature at Galley was three jobs in three tools: an engineer switched a flag on, a login popup announced it, and the flag stayed in the code. I turned it into one product: a ladder every feature climbs, early access customers choose for themselves, and flags that leave the code on schedule.

Role
Director of Product. I designed and built v1, called the rebuild, and own the module
Timeline
March 2026 to now
Used by
Customer admins and their teams, Galley's CX team, product managers and engineers
Status
In production, governing 225 features (November 17, 2026)
The ladder every feature now climbs, with a time limit on each rung. Redrawn for this page.

TL;DR

  • The problem

    Turning a feature on, telling customers, and removing the flag afterwards were three unconnected jobs in three tools. Nobody could easily say what was on for whom, and flags piled up in the code.
  • What I did

    I designed and built a release record that owns the flag, the note and the stage. When it turned out to solve the wrong problem, I called a rebuild around customer self-serve, then owned the process, the tooling and the cleanup.
  • The result

    225 features now move through one lifecycle, 35 flags were retired with their code removed first, and Feature Control is the only record of what has shipped.

The problem: three jobs, three tools, no owner

Galley sells kitchen-operations software to large food-service operators, and its engineers ship code continuously behind feature flags: switches that keep new code dark until someone turns it on. Turning one on meant editing targeting in LaunchDarkly by hand, company by company. No screen in Galley showed who had what, so CX asked engineering whether a feature was on for a customer.

Telling customers was a separate job. A "What's New" popup opened on login with content from a HubSpot table: no link to the feature, no per-company targeting, and nothing to come back to once dismissed. Release notes also went out by email.

Nothing moved a feature forward or cleaned up after it. Features sat in beta because nothing made them leave. In July 2026, 45 of about 105 live production flags were neither fully on nor archived and had no record behind them, and release status lived in three places that disagreed. Even I could not always tell. "That feature is GA, why is it not enabled on my company?" I asked in August.

My role

I wrote the first design in March 2026 and built v1 myself with Claude Code: the release-notes and targeting service, the notification drawer, the admin catalog and the first customer tab.

On June 3 a product process review showed that v1 solved the wrong problem. It gave Galley staff precise control over who got each early feature, when staff were the bottleneck. I made the call to rebuild it around customer self-serve. I was on vacation that week, so the CEO implemented v2, working from a product lead's process spec and my conditions.

Since July I have owned Feature Control end to end: the release process and its rules, the commands the team runs to promote and retire features, the flag cleanup, and the customer-facing content each feature carries.

Constraints

  • Deploying never stops. Flags separate shipping code from releasing it, so the release system had to sit on top of LaunchDarkly, not replace it.
  • Kitchens punish surprise. A screen that changes during a dinner service feels like a bug, so customers need notice, and a way to wait.
  • A small team. A promotion had to be cheap enough for one person to run in minutes, with no step that can fail silently.
  • Years of flags with no record behind them, any of which could switch a feature off for everyone if archived carelessly.

Four decisions that shaped it

Decision 1

Make the release a record in Galley that owns the flag

Announcements lived in a HubSpot table behind a login popup, targeting lived in LaunchDarkly, and nothing connected a note to the switch it described, to a company, or to who had read it.

Options

  1. Keep HubSpot as the source and add targeting around it.
  2. Build a new service for releases.
  3. Extend the small service that fed the popup, give it its own database, and put the admin inside the main app.

What I chose

The third. Each feature record wraps an existing flag (it never creates one), owns its release notes and its stage, and writes the flag's targeting itself. Old announcements were migrated so the new drawer felt populated from day one, and the login popup was retired.

Why
Company targeting, flag linking, read state per person and user-level targeting did not fit HubSpot's table model, and extending the existing service avoided running a new one.
What it cost
A wrapped flag is machine-managed: a hand edit in LaunchDarkly survives only until the next write. Every legacy flag had to be wrapped one at a time, carefully, because wrapping rewrites its targeting.
What I said no to
A new microservice, HubSpot as the source of truth, and engineers hand-editing targeting on a flag once Feature Control owns it.

Before

After

The notification drawer with Settings and All Notifications tabs, a feature card with Enable for me and Manage for team buttons, and a list of new release notes with dates.
Before: a popup on login, unlinked to the feature (redrawn; no screenshot of it survives). After: a drawer on every page, filtered to the page and to what this person can use, with the feature's own controls.

Decision 2

Let customers decide who gets early features, not Galley staff

v1 gave Galley staff a precise, layered audience editor for every feature: company targeting, filters inside a company, per-company overrides. It worked, and the June 3 review showed it was the wrong job. Staff were the bottleneck, bringing a customer into a beta took too many touchpoints, and features sat in their early stages.

Options

  1. Keep staff-managed targeting and make it faster.
  2. Keep Alpha internal and let CX run a company-level beta group (my first proposal).
  3. Make early access self-serve: availability set by stage, people and admins opt in, with friction instead of gatekeepers.

What I chose

Self-serve, on two conditions I set: anyone turning on a Beta feature is told plainly that it is expected to have bugs, and CX is briefed before customers can enable anything. People choose to see Beta or Alpha, then enable features for themselves, for people and roles, or for the whole company; Alpha takes typed consent. Staff help a customer by opening that customer's own panel.

Why
The goal was customers trying features early, and every staff hand-off stood between a customer and a beta. Friction can protect people from a half-finished feature without anyone having to approve them.
What it cost
My own audience editor came out about a week after it shipped. Per-person and per-role access, cut from the first version of v2, had to be added back. And one customer's v1 choices were not carried over, so a feature they used read "Off" until the migration was fixed.
What I said no to
CX-curated beta groups and caps on who may try Alpha. The typed confirmation is the safeguard.

Before

The first customer-facing Feature Control tab: a table of features with a company state and Enable, Disable and Use default actions set by Galley staff.

After

The current customer Feature Control tab: a switch to control rollout, switches to try Beta and Alpha features, a search, and features grouped as requested by you, built for you and other new features, each with About and Access menus.
The customer tab in May (Galley staff decide: Enable, Disable or Use default) and in October (customers decide, with switches for Beta and Alpha and features grouped by relevance). Account names blurred.
A dialog titled Enable beta feature for me, warning that the feature is a beta and expected to have bugs, with Cancel and I understand, enable it buttons.
The condition I set for self-serve: before anyone turns on a Beta feature, they are told plainly that it is expected to have bugs.

Decision 3

GA means everyone, and a date alone never promotes a feature

Opt-In Release lets a customer hold a feature back for a while. If GA became optional too, flags could never be removed and the product would fork per customer. And nothing moved features out of their stages.

Options

  1. Let customers keep their exclusions after GA.
  2. Promote automatically when a stage's end date arrives.
  3. Promote by hand.
  4. Promote on evidence, with a person confirming.

What I chose

GA is on for everyone, always; a customer who needs time can ask to extend the Opt-In window, which delays GA for every company. I defined the gates for Opt-In: no open high-priority bugs, a demo video, and proven use by at least one target company. Automatic promotion by date was built and then switched to report-only. I set full automation as the goal; in review, the CEO asked for a daily job that proposes each promotion with its evidence and an owner who confirms it in one click, and I agreed.

Why
GA is what makes a flag removable. Promoting on a date alone pushes features nobody has used into every kitchen.
What it cost
A person stays on every move that widens a feature's reach, which is slower and is exactly why features can still stall; that became this quarter's goal, 90% of features released within their time limits. Under that pressure I have relaxed the usage gate for one batch, while keeping the content gate.
What I said no to
Permanent per-customer opt-outs at GA, and silent automatic GA.

Decision 4

One record of release status, run by commands, with the flag deleted last

Moving one feature one rung touched five systems: the flag, the record, the release note, a ClickUp task and a Slack announcement. Release status lived in flag tags, a ClickUp list and a local file that disagreed with the app on 6 of the 11 features both knew about. And 24 flags were still read in code more than 30 days after their feature reached GA.

Options

  1. Document the process and keep the trackers in sync.
  2. Build more admin screens.
  3. Encode the process as shared commands with one policy table, and delete the second copies.

What I chose

Six commands the team runs to create, update, publish, report on and retire features, sharing one promotion procedure and one table of what each stage does. Feature Control's stage became the only release record: at my call, the status tags came off 70 flags and the ClickUp release tasks were retired. A flag retires only after 30 days at GA, with the code that reads it removed and deployed first and the flag archived last.

Why
The failures were silent: a pilot group stranded by one missed step, a release note invisible because one field was wrong, a whole run against the wrong environment. And every second copy of the truth drifted.
What it cost
Release history in ClickUp froze, and CX switched to the Slack announcement as their record. Promotions need elevated access, and editing a retired feature can quietly revive its flag, so the procedure checks for that.
What I said no to
Parallel trackers kept in sync, and archiving a flag while code still reads it, which is a behaviour change disguised as cleanup.

How it came together

I work design first: every change starts as a written design that a separate agent attacks in several devil's-advocate rounds, then I build it with Claude Code and audit the result. My usability audit of the feature page in May found, among other things, an audience preview that scrolled out of view and a stage change that looked like a text edit; the critical findings were fixed the same day.

The process lives in the tools. The promotion commands preview every change across the record, the note, the flag and the announcement before making it, and the admin catalog shows each feature's stage, time limit and owners.

Feature Control is also the source of what customers read: each feature carries its release notes, demo videos and a short customer description, and is marked "Requested by you" when a customer asked for it, or "Built for you" when it fits how they use Galley.

Outcome

Counted on November 17 to 19, 2026, from Galley's production feature records and the project's own records. Customer and usage data stay private.

  • 225

    features governed by Feature Control, across 16 product modules

  • 60

    features promoted to Opt-In Release or GA through it

  • 168

    release notes linked to the features they describe

  • 35

    flags retired after GA, with the code that read them removed first

  • 70

    flags whose status tags were removed when Feature Control became the only release record

  • 45

    untracked live flags found in July (of about 105) and wrapped one at a time

The number I do not have yet is the one that matters most: how many features reach customers within their time limits. The team set the goal at 90% for this quarter, and the scorecard that measures it shipped at the end of October.

What I learned

  • Solve the job, not the request

    v1 gave Galley staff exactly the control they asked for. The job was getting customers to try features early, and staff-held control was the bottleneck. One review found it; the rebuild took a week.

  • Deploying is not releasing, and releasing is not adoption

    Code can sit in production for weeks without a customer noticing. The later work (relevance labels, usage gates, demos, time limits) is about the third step: the customer who asked actually trying it.

  • Delete second copies instead of syncing them

    A local file was wrong on 6 of 11 features, and flag tags and ClickUp tasks disagreed with the app. The fix was removing the copies, not keeping them in step.

  • When failures are silent, put the policy in a tool

    Five overlapping instructions with seven contradictions became one procedure and one stage table that every command reads.

  • Cleanup is part of the feature

    A feature is done when its flag's code is gone and the flag is archived, in that order. Archiving first switches features off for real people.

  • Migrating people's choices is the riskiest part of a redesign

    The first v2 escalation was a customer whose earlier choices had not been carried over, so a feature they used looked switched off.

Talk to me about it

Feature Control lives inside Galley's product, so there is no public demo. I am happy to walk through it, and the calls behind it, in a conversation.

Next case studyMenu Plan & Company Settings