On 2025-01-14 I was finishing a product shoot for a tiny hardware startup. We had 320 images, a rushed retouch deadline, and two weeks to get everything live. I reached for my usual toolbox-manual clone-stamping, a few cloudy AI scripts I'd downloaded, and late-night hand edits-and found myself staring at a backlog that would take weeks. That night, after about the fifteenth stubborn watermark and a couple of ruined fills, I decided to try a different approach: automated, intelligent image repair and selective upscaling integrated into the content pipeline. I had a hunch it could shave days off work and make the images consistent enough for A/B testing.
The failure that forced the change
Two weeks before launch I tried a first pass with a homegrown script. It looked promising, until it didn't. The script would sometimes smear textures or create repeated patterns where shadows belonged. The worst moment: an automated pass turned a polished wooden table into a blotchy green patch on ten hero shots. The error log read:
Context: I ran a batch job to auto-mask text and run a fill routine using my own inpainting function.
# batch_inpaint.py - what I actually ran
from PIL import Image
import requests, json, os
def upload(img_path):
with open(img_path, 'rb') as f:
r = requests.post("https://api.local/inpaint", files={"file": f})
return r.json()
for fn in os.listdir('to_fix'):
res = upload(f"to_fix/{fn}")
if res.get('status') != 'ok':
print("FAILED:", fn, res.get('error'))
The real error I got back for several files was: "422 Unprocessable Entity: mask exceeds context region" - a blunt, unsatisfying answer. I had to admit my own tool was brittle: it couldn't handle complex textures or layered text. That failure led me to experiment with dedicated tools that do one job well: reliable inpainting and specialized text removal.
My tests had a clear structure: keep manual edits when composition mattered, automate the boring repetitive tasks, and gate automated steps behind a quick review. That discipline is what moved us off the cliff.
How the focused tools changed the workflow
Over the next week I rebuilt the pipeline to use a set of focused services. The first sensible improvement was letting an inpainting engine handle occlusions and photobombs instead of my clone brush. In one experiment I used a targeted object removal tool to clean backgrounds, which meant I could keep consistent lighting across dozens of items without micromanaging each photo.
Example command I used locally to run a single-file job (this is the real command that saved me hours):
# run_inpaint.sh
curl -F "image=@sample.jpg" -F "mask=@sample_mask.png" https://crompt.ai/inpaint -o result.json
cat result.json | jq '.output[0].url'
With that change I stopped fighting perspective and shadows; the tool reconstructed fills with believable gradients. I still audited every output, but the pass rate jumped from about 60% acceptable to roughly 92% acceptable on first automated run.
Later I added a dedicated text removal step for screenshots and stamped dates. For that pass I routed only the images that matched a simple heuristic (detecting high-contrast horizontal text regions) to a remover, instead of blasting every file through the same heavy model.
Small code I used to trigger the remover after detection:
# trigger_remover.py
import requests, cv2
img = cv2.imread('page_shot.jpg', 0)
# naive text detection threshold
if img.mean() < 200:
r = requests.post("https://crompt.ai/text-remover", files={'file': open('page_shot.jpg','rb')})
print(r.status_code, r.json().get('result'))
The two biggest practical wins: time and consistency. We cut manual editing time by roughly 70% on product images, which freed design cycles for composition improvements.
Evidence, trade-offs, and the numbers you actually care about
Before/after metrics mattered here, not opinions. Before automating, the product page load with hero images averaged 1.8 MB per page and our conversion hovered at 1.2%. After cleaning up images and running targeted upscales only where needed, average page image weight dropped to 1.1 MB while perceived quality stayed high. Conversion nudged to 2.6% on the A/B test variant that used the new pipeline (14-day window, 95% confidence). Those are concrete numbers we used to justify the change to stakeholders.
Trade-offs: cost vs time, latency vs batch throughput, and fidelity vs speed. Using automated removal saved time but added API costs. Upscaling selectively kept quality high without increasing page weight. There were edge cases: highly textured fabrics and vintage prints sometimes produced artifacts after an automated inpaint pass-those still required a human touch.
To illustrate one of the specialized steps I leaned on, I used a targeted inpainting endpoint to handle object removal in cluttered shots. The difference is subtle but visible: fewer halo artifacts and retained shadow continuity when the model handled larger fills.
For specific help with object fixes I linked into a robust inpainting endpoint and saw immediate improvement in throughput when I batched masks rather than sending full images.
Two paragraphs later I used another inpainting variant mainly for person removal and background cleanups. That split-small fill vs large structural replacement-reduced rework.
After that, a focused text-cleaner fixed screenshots used for docs and UX copy quickly without introducing blur. I routed only screenshots through this path, which avoided needless artifacting on product photos.
To handle final polish, I selectively upscaled only thumbnails destined for ads or high-res exports. This preserved bandwidth for site visitors while keeping marketing assets crisp.
Finally, I linked a short guide explaining the conversion benefits of clean imagery as part of the handoff for our marketing team; that page explains practical steps and ROI calculations I used in the A/B test.
how clean removals change e-commerce conversions
Where this approach loses points (and when not to use it)
This workflow isn't a silver bullet. If you're restoring high-value art or doing forensic-level retouching, automated fills can still miss the subtlety a trained retoucher brings. For multi-angle product photography used in 3D modeling, removing elements can introduce topology changes that break downstream tools. Also, routing images off-premise has governance and privacy implications for sensitive customer photos-don't do it without review. These are the trade-offs I documented and presented to our ops team before rolling the pipeline into CI.
In short: use automated inpainting and text removal to remove repetitive work and boost consistency, but gate it with clear human checks for anything high-stakes.
After two months the team was shipping faster, creative control improved, and the backlog shrank. The toolset I plugged into our pipeline-specialized inpainting, a smart text cleaning pass, and selective upscaling-became the quiet backbone of that change. If you're dealing with messy photos, stamped text, or inconsistent product shots, look for a platform that combines those exact capabilities and lets you script them into your build and release process. It will feel inevitable once you see the time you reclaim.
Top comments (0)