Case Study

Tablelist — Retiring a Legacy Mobile App One Feature at a Time

Tablelist was pulling its platform into one monorepo, but the mobile app its venue staff relied on still lived in an older codebase of its own. We embedded with their engineers and moved it across area by area into a React Native app built on the monorepo's shared types and API client, until the old codebase could be retired.

Updated
Nov 19, 2026
Version
v0.1.0
Read
6 min
By
Summit ML
TablelistPro mobile app in dark mode

A legacy app is not retired by the rewrite. It is retired when the new one does everything the old one did. This is how we got Tablelist's mobile app there, one shippable piece at a time.

Audience
Engineering Leaders · Mobile Engineers · Teams consolidating codebases

We recently had the opportunity to work with the Summit ML team on the TPro mobile app, and the results have been fantastic. The app looks great, works seamlessly, and we're really impressed with everything they built.

Tablelist team member

Executive summary

Tablelist powers nightlife: reservations, guest lists, ticketing, and table inventory for venues. Over the years the platform had spread across separate codebases, and Tablelist was pulling its API and web apps together into a single monorepo. The mobile app that venue staff use on the floor was the piece left outside.

A new React Native app had been started inside the monorepo, but it could not replace the old one until it matched it. We embedded with Tablelist's engineering team for three months and closed that gap area by area. Each area shipped as its own pull request, each move was a chance to simplify, and at the end the legacy mobile codebase could be deprecated.

TablelistPro mobile app in dark mode

The organization

Tablelist runs the software behind a venue's night. TablelistPro is the side of the platform that venue teams use to take reservations, manage guest lists, assign tables, and talk to guests. Its web app is where the full product lives.

Unlike a greenfield build, almost everything already existed here: the product, the API, the web app, the data model, and an engineering team with its own conventions. The work was to bring one more app into that structure, not to design a new one.

The problem

Two mobile apps existed at once, and neither was enough on its own.

  • The legacy mobile app sat outside the monorepo, with its own patterns and its own copy of the business logic.
  • Every platform change had to be made twice until the old app could be retired.
  • Reservation and customer screens in the new app were missing fields the old app already captured.
  • There was no way to assign a server or record a comp type from the floor.
  • Guest chat, settings, and support flows were unfinished on mobile.
  • Rich text descriptions written on web had no editor or preview in the new app.

The cost of the gap was not the missing features themselves. It was that the old codebase had to stay alive for as long as any one of them was missing.

Constraints

  • Work inside Tablelist's repository and follow their conventions, not ours.
  • Land work through pull requests into the team's development line, in pieces small enough to review.
  • Keep venue staff working throughout. The old app had to stay usable until the new one covered it.
  • Use the monorepo's shared types and typed API client instead of adding mobile-only copies.
  • Hold up in the conditions the app is used in: a dark room, a busy door, and both light and dark themes.

Architecture

Read against SKF-001, Tablelist's lower layers were sound and already being consolidated: a clear business, an operational data model, and an API serving it. The problem sat higher up, in the applications layer, where a second mobile app carried its own copy of logic that belonged below it.

So the governing rule was simple. The mobile app should consume the platform's shared foundations and own nothing that the platform already owns. Screens read and write the same data shapes as the web app, through the same typed client. Where that client was missing an endpoint the old app depended on, we added it to the shared client, where every Tablelist app can use it, instead of working around it inside the mobile app.

TablelistPro reservation form, reservation list, and table picker on mobile

Implementation

We worked through the old app one area at a time, carrying each feature and the data behind it into the new app.

AreaWhat moved
ReservationsServer assignment, comp types, and the fields the new app was missing
CustomersFuller profiles, including structured birthday entry
AdmissionsGuest list and ticket entry, brought in line with reservations
Guest chatRestyled threads with search
SettingsAppearance, notifications, printing, and support
Rich textAn editor and preview for descriptions written on web

The choices behind it:

ChoiceWhy
React Native + ExpoContinue the app Tablelist had already started in the monorepo instead of introducing another stack.
TypeScript with shared typesOne definition of a reservation or a customer, used by web and mobile alike.
The monorepo's typed API clientReplace the old app's private copy of business logic with the platform's own.
Expo Router and TanStack QueryMatch the navigation and data-fetching patterns already in the new app.
One branch and pull request per areaLet the new app close on the old one in pieces that could ship, not in one large handoff.

A nightclub is a hard place to use software, so the experience got the same attention as the plumbing. We reworked the app's shared styles so screens hold together in both light and dark themes, tightened the navigation drawer and screen headers, and refreshed sign-in. The result reads at a glance, whether staff are at the host stand before doors or on the floor at midnight.

TablelistPro settings, notification, and support screens in dark mode

Screens are shown with demonstration data.

Results

3 mo
Embedded delivery
6
App areas migrated
1
Legacy codebase retired
Scope figures from the engagement record.

With the new app covering what the old one did, Tablelist could deprecate the legacy mobile codebase and keep its engineering effort in one place. TablelistPro mobile now lives in the same monorepo as the API and web apps, so a change to the platform's data model reaches web and mobile together.

For venue staff the change shows up on the floor. A host can take a reservation, assign a table and a server, and answer a guest, without walking back to a laptop.

Tradeoffs

Migrating area by area means running two apps for the length of the migration, and paying the double-change cost the whole time. A single cutover would have ended that sooner on paper. We chose the slower-looking path because each area could be reviewed, shipped, and used on its own, and because a cutover that slips leaves a team with two half-trusted apps instead of one trusted and one improving.

Adding missing endpoints to the shared API client, instead of calling them directly from the mobile app, also cost time on individual features. It was worth it because the alternative was to rebuild, inside the new app, the private logic we were there to remove.

On a small app with few users and no shared platform underneath it, a clean rewrite and a single switch would have been the right call.

Lessons learned

  • The goal of a migration is retirement. Until the old codebase can be switched off, the work is not done, however good the new app looks.
  • Parity is the gate. List what the old app does that the new one does not, and treat that list as the plan.
  • Move in shippable pieces. One area per pull request keeps review honest and keeps progress visible to the team that owns the code.
  • Moving a feature is the cheapest moment to simplify it. Carry the behavior across, not the old implementation.
  • When the shared foundation is missing something, fix the foundation. A workaround in one app becomes the next legacy.
  • Embedded work follows the host's conventions. The code should read as theirs on the day we leave.

Related knowledge

  • SKF-001 — The Summit Architecture Pyramid (framework applied here)
  • SKC-002 — Samsonite, another case of extending what exists instead of adding a foundation
  • SKC-001 — ParkPro, the greenfield counterpart
  • The Tablelist case study — the shorter version, with more screens

Changelog

  • 0.1.0 (2026-11-19) — First draft.

Let's Build

Want this thinking applied to your systems?

Talk to the architects who wrote it.

Let's Chat