Skip to content

Case study SaaS

Claude-assisted CRM API migration for WaiverKing, led by a Forward Deployed Engineer

unicrew's Forward Deployed Engineer on WaiverKing led the move of WaiverKing's live Mindbody Online integration onto a new API version, using Claude Code to analyse anonymized records and with no disruption for customers.

WaiverKing's platform exchanges client and signing data with Mindbody Online, the business system its gym and studio customers run on. When Mindbody published a new API version, WaiverKing moved its live integration onto it. unicrew ran the migration, led by its Forward Deployed Engineer on WaiverKing, with Claude Code comparing anonymized records from both versions, and delivered work estimated at 260 hours in about 80.

Illustration of the migration method: client records from the two API versions run side by side into a comparison, where differences are flagged and matched records are checked off. The matched record reaches a customer profile with its signed document, and a fallback line loops back to the start.
Client
WaiverKing
Focus
SaaS, Modernization
Market
United States
Engagement
Forward Deployed Engineer
Stack
Claude CodePHPYii2MySQLJavaScript

Outcome at a glance

What this project delivered, in numbers.

  • ~80 hoursTo complete WaiverKing's migrationagainst an initial estimate of 260 hours
  • 10 to 15xFaster log analysisthe team's estimate, against manual investigation
  • 3 to 4xFaster development and debugging overallthe team's estimate across both stages

The challenge

WaiverKing handles waivers and document management for the health and fitness industries, on a platform that carries two-factor authentication, customizable permissions and automated billing alongside the signing itself. A customer signs a legal document in minutes and expects it on the right profile in Mindbody Online straight away. That handoff is the product.

It ran on an integration built against Mindbody Online’s legacy API. When Mindbody published a new version of that API, WaiverKing moved onto it. unicrew has developed the platform since 2014 and ran the migration.

The changes ran deeper than the version number. Request and response structures changed. Validation got stricter. Several scenarios behaved differently, and the dangerous ones were quiet: a call could report success on both sides while the two versions disagreed about what had actually been stored, with nothing on either path raising an error. Finding those before they reached anyone was the job.

Diagram titled: Both versions reported success. Only a side-by-side showed they disagreed. Two rows compare the legacy API and the new API across three columns. In the first column each sends the same client record. In the second column each reports the call as successful. In the third column, headed what the comparison showed, the legacy API row reads in step and the new API row reads out of step.
The two rows are identical until the last column. No error was raised on either path, so an error log had nothing to report.

A specification tells you what an API accepts. How it behaves across every case a live integration actually hits shows up in real traffic, during development and after release, and real traffic is where this migration looked.

Our approach

unicrew’s Forward Deployed Engineer on WaiverKing is embedded in its delivery, works directly with WaiverKing and owns that delivery end to end. They came to the role from the WaiverKing team with the platform’s full context. On this migration they set the estimate, led the work with other unicrew engineers contributing, and released it to production.

The method had two stages: a parallel run during development, then a fallback in production. Claude Code worked in both, in unicrew’s delivery of the migration, as the analyst over the records each stage produced.

Diagram titled: Two stages, and every fallback left evidence behind. Stage one, during development: run the call on both versions with both records anonymized, compare what each returned across structures, fields, formats and behaviour, then separate expected differences from real incompatibilities. Stage two, in production: a request fails on the new API, it is retried on the legacy API so the user operation completes, and the failure becomes evidence of why it was rejected and what has to change.
Stage one ran before release. Stage two ran on live traffic, turning each remaining difference into a fix.

Stage one: every call recorded twice

During development the integration ran in parallel: every CRM call went to both API versions, and both results were kept so the two could be compared directly.

The platform handles personal data, so privacy set the shape of this from the start. Records kept for comparison were anonymized before anything read them, and that cost the method nothing: what the comparison needed was the structure of each call, not its contents. A renamed field, a stricter rule or a changed format all show up in the shape.

That produced a lot of debug output and one useful property: a difference between the versions became something you could see in a pair of records. Claude Code worked through the pairs, flagged where structures, fields, formats and behaviour diverged, sorted the expected differences from the real incompatibilities, and pointed at what the integration needed.

Stage two: a fallback that explained itself

The new API went live behind a fallback, so a difference nobody had found yet could not reach a user. A request that failed on the new API was retried on the legacy one, and the user’s operation completed.

The fallback did two jobs. Each time it fired it recorded, anonymized the same way, which call had failed and how the same operation had succeeded on the old path. Claude Code took those cases one at a time: why did the new API reject this, and what has to change so it stops. Every case closed took one more reason for the fallback away.

What Claude Code changed

unicrew’s engineers wrote WaiverKing’s migration. Claude Code read the evidence it threw off, and that reading was most of what the estimate had been built to cover.

  • The paired records became searchable.

    Complete request flows came back out of high-volume anonymized output, with nobody scrolling through it.

  • Near-identical calls stopped hiding their differences.

    One call succeeds, an almost identical one fails, and a person skims straight past it. Here that usually meant the new API’s stricter validation, not a broken call.

  • Investigations ran from symptom to cause.

    A request that failed on the new API and completed on the legacy one was traced to the application flow responsible, with no rounds of narrowing down.

  • Assumptions about the CRM were put against its actual responses.

    How the old API handled particular cases was read off its real responses, and testing each assumption against one settled which ones held.

  • Dead ends closed early.

    An issue whose cause sat outside the migration was ruled out quickly, before effort went into the integration. Nothing in a tracker records the time that saves.

The engineers, led by the Forward Deployed Engineer, decided every fix before it shipped. Analysis that arrives with its reasoning attached is quick to check, and that check is the difference between fast and reckless.

Results

WaiverKing has run on the new API version in production since the migration closed, and the fallback now sits idle.

Bar comparison titled: Estimated at 260 hours. Delivered in about 80. A long bar labelled initial estimate, 260 hours, above a much shorter bar labelled actual, about 80 hours.
Both are unicrew's own delivery figures for this migration.
  • A migration estimated at 260 hours, delivered in about 80.

    unicrew’s Forward Deployed Engineer on WaiverKing set that estimate with the platform’s full context already in hand, so that knowledge is inside the 260 hours. The hours came down in the analysis of how the two versions behaved differently, the part of the work Claude Code carried.

  • Log analysis was estimated to be approximately 10 to 15 times faster than manual investigation, and development and debugging overall approximately 3 to 4 times faster. Both figures are the team’s estimate of their own work on this project, not a benchmark.

  • Every user operation still completed.

    A failed request on the new API went to the legacy one automatically, so the migration happened underneath live traffic.

  • Silent differences still left a trace.

    An error log sees a failure. A paired record sees a difference, and that is how the quiet failures surfaced.

  • The same engineer still owns the delivery.

    unicrew’s Forward Deployed Engineer on WaiverKing remains in the role after the migration.

The API calls themselves took very little time. The work was finding out how the new version behaved, in a system where some differences announced themselves and some said nothing at all.

Where this fits

The method travels to any integration where a vendor publishes a new API version and your platform moves onto it.

  • Record both versions before you commit.

    Two captured request and response pairs answer questions that two specifications cannot.

  • Put the switch behind a fallback.

    If the new version rejects a request, retry it on the old one. You can go live before you have found every difference.

  • Treat each fallback as evidence.

    A recorded “failed on new, succeeded on legacy” pair tells you exactly which difference to close, and it costs nothing to collect.

  • Keep a person on the decision.

    Analysis can be quick. Deciding what to change in a live contractual flow should not be automatic.

It earns its place when an integration has years of real traffic behind it and a silent sync failure costs more than a loud one. An integration of a handful of calls, or a vendor release with a full compatibility layer, takes a lighter path, and choosing between the two is part of the job.

The engagement model travels too. A Forward Deployed Engineer fits a live product that needs one accountable engineer who knows it end to end, with more of the team brought in when the work calls for it. The same role runs Pet4Me’s continuous delivery with Claude.

Most engagements start within two to four weeks. This work sits where platform development and integration meets software maintenance and support. The wider WaiverKing engagement has run since 2014 and is described in our WaiverKing case study. What clients say about long engagements is on our client reviews page, in their own words.

What WaiverKing says about the wider engagement

They’ve been helping us grow our platform together since the beginning, from a couple hundred companies to around 2,000. Artelogic has been front and center in this process.

Craig Elsdon-DewCEO, WaiverKing Inc.United Kingdom
Clutch
5.0

Unified rating across 61 verified client reviews

Read this review on Clutch All client reviews

06/Technologies

Technologies on this project

Frontend

Backend

07/Quick answers

The questions behind the project

What did unicrew do for WaiverKing on the CRM API migration?

WaiverKing's platform exchanges client and signing data with Mindbody Online. When Mindbody published a new API version, WaiverKing moved its live integration onto it, and unicrew's Forward Deployed Engineer on WaiverKing led the migration, with other unicrew engineers contributing. The work ran in two stages: during development every CRM interaction was performed against both API versions and recorded, so the two could be compared directly; then the new version went live behind an automatic fallback to the legacy API, and every fallback was treated as evidence of a remaining difference to close. The engineer estimated the migration at 260 hours, and it was completed in about 80.

What is a Forward Deployed Engineer?

The term comes from Palantir, and AI companies such as Anthropic and OpenAI now use it for engineers who embed with one customer, write production code in that customer's live systems, own the outcome end to end, and carry what they learn back into a product. On WaiverKing, unicrew's Forward Deployed Engineer is embedded in its delivery, works directly with WaiverKing, owns that delivery end to end and came to the role from the WaiverKing team. Claude Code worked in unicrew's delivery of this migration, analysing anonymized debug records from WaiverKing's integration.

How was Claude Code used on this project?

In unicrew's delivery of WaiverKing's migration, as an analyst over the project's own debug records, which were anonymized before anything read them. The engineers wrote the migration. Claude Code reconstructed complete request flows from high-volume logs covering both API versions, compared them, and separated differences that were expected from real incompatibilities. In the production stage it worked through each fallback case to explain why the new API had rejected a request that the legacy API accepted, and what had to change in the integration. It traced issues to the part of the application responsible and proposed fixes. The engineers made the final decision on every fix before it was applied.

How do you move to a new API version without breaking a live integration?

Look in real traffic as well as the documentation. The practical method is to run both versions side by side before committing to the new one, so you can compare an actual request and response pair instead of reading two specifications and hoping they agree. Then put the switch behind a fallback: if the new version rejects a request, retry it on the old one so the user's operation still completes. Each remaining incompatibility then arrives as a recorded example, and the migration can go live before every difference has been found.

What happens when an API change produces no error but data stops syncing?

It is the hardest class of migration problem, because nothing alerts. A stricter validation rule, a renamed field or a changed data format can be accepted by the receiving system and quietly dropped, so both sides report success while the records diverge. Error logs will not show it, and a test suite written against the old contract will not catch it either. The reliable way to find it is to compare what each version actually returned for the same operation.

Who reviews the code in an AI-assisted workflow?

An engineer does. On this project Claude Code analysed evidence and proposed changes, and the engineers decided on every fix before it was applied. Analysis that arrives with its reasoning attached is quick to check, and a proposal that rests on a wrong assumption gets rejected in minutes. unicrew applies the same rule on its own work, and the validation chain that gates this website is described in our WordPress to Astro migration.

Have a project in mind?

Tell us what you are building. We will map the fastest route from where you are now to a working product, no obligation and no sales script.

Book a scoping call

Thank you

Thanks for your message. We will get in touch with you shortly.