About Senado MIS: Senado Games is a small ecommerce business I run alongside my day job. Senado MIS is the Java-based management system I’ve built to manage stock, sales, purchasing and marketplace integrations across channels including eBay and Amazon. I’m documenting some of the engineering decisions and lessons from developing and using it in the real business.

A marketplace API migration sounds like a fairly contained engineering task: replace an obsolete call, adjust the request and response handling, and check that the replacement works. But the failure that prompted a recent change in Senado MIS was more awkward. An image-upload API had been retired, and the visible symptom was that an ordinary edit to an eBay draft listing could no longer be saved.

The seller might not have touched a single photograph. That did not matter. The draft-saving workflow sent the listing’s images along with its other details, so a dependency that appeared to concern only pictures had become a dependency of routine listing maintenance.

This is a useful reminder that API migration regression testing needs to follow the user’s task, not just the endpoint being replaced.

The dependency hiding in a routine save

In a listing editor, product details and images appear to be separate concerns. You change a description, perhaps adjust a price, and press Save. From the user’s point of view, the images are already there.

The implementation had a different shape. Saving the draft also sent its product photos through eBay’s older Trading API picture-upload mechanism. When that mechanism was retired, the whole save operation became vulnerable, including edits that did not require a new image.

The resulting error was generic enough to suggest that a particular photograph was at fault. That is an especially unhelpful failure mode: the message points the person using the system towards the data, when the underlying problem is an obsolete integration.

A more useful investigation begins by tracing what the Save action actually does. Which external calls are made? Which of them are necessary? Which are simply part of the existing sequence? The answer is often more revealing than the label on the failing button.

Replacing the image path without replacing the workflow

The change recorded in the development journal was to upload locally stored photos directly to eBay’s Media API and pass the resulting hosted image URLs into the existing draft workflow.

That matters for two reasons. First, it replaces the retired upload dependency while preserving the broader draft-saving behaviour. Second, direct file upload avoids making a public image-hosting service an additional prerequisite. The source files already exist locally; there is no benefit in inventing another hosting step merely to make them reachable by the marketplace.

The error handling also became more specific. Rather than reporting a vague image failure, the upload path identifies the file involved and includes eBay’s HTTP status where available. An integration can still fail, of course, but a useful failure tells the developer and operator where to look.

The regression test did more than assert that some URL came back. According to the journal, it exercised the actual multipart request against a mock endpoint and checked the returned URL. That is a more meaningful boundary test than mocking the upload method itself and assuming the request was correctly constructed.

It verifies the shape of the conversation with the external service while remaining independent of a live marketplace account.

The second failure was not an API problem

Once the upload path was addressed, another issue emerged in the same user journey.

Saving and verifying a draft refreshed the product data in the editor. That refresh cleared the condition the seller had selected, leaving the publishing action disabled.

This was a different category of bug. The marketplace upload could succeed, and the data refresh could succeed, yet the overall task still failed because the form had lost a choice the user needed to complete it.

The important distinction is between saved product state and an active decision in the open form. A refreshed product record may be authoritative for fields returned by the backend, but that does not automatically make it authoritative for every piece of in-progress user input.

In this case, the form was changed to retain the selected condition for the current product while refreshing saved fields. A UI regression test then followed the save, refetch and publish request together.

That test covers the transition where the defect occurred. Testing the initial selection alone would not have found it. Testing the data refresh alone might also have passed. The problem existed in the interaction between two individually reasonable operations.

Two failures, one user task

What makes these changes worth considering together is that they both broke the same ordinary activity: maintaining and publishing a draft listing.

The first failure was at an external integration boundary. An apparently unrelated edit depended on an image API that was no longer available.

The second was at an internal state boundary. A successful save and refresh erased a required form choice.

Both demonstrate the limitations of tests organised exclusively around individual functions or services. Those tests are useful, but they cannot establish that a person can complete the workflow they came to the application to perform.

For a small business system, that distinction is practical rather than academic. The application is not an API demonstration. It exists so someone can carry out a job without having to understand the sequence of technical dependencies behind it.

There is also a useful restraint here. The answer is not to replace every existing integration or redesign the whole listing editor whenever an API changes. The recorded fixes were targeted: move the retired upload operation to a supported path, improve diagnostic information, and protect the form choice across a refresh.

The broader improvement came from choosing tests that reflected the real points of failure.

What I would carry forward

The most useful question after a dependency migration is not simply, “Does the new API call work?” It is, “Can the user still finish the task that depended on it?”

That means looking for hidden calls made during ordinary actions, making integration errors specific enough to diagnose, and testing the state transitions that follow a successful external operation.

The eBay draft workflow exposed both sides of that problem in quick succession. One failure prevented a save. The next allowed the save but interrupted the path to publishing.

Neither would have been adequately described as an image-upload problem alone. The real subject was the reliability of the whole workflow.

When an API Retirement Breaks an Unrelated Edit

Leave a Reply

Your email address will not be published. Required fields are marked *