DEV Community: Liton Roy

How We Process 7,500 Product Images Daily Without Breaking the Pipeline

Liton Roy — Wed, 01 Jul 2026 06:20:36 +0000

How We Process 7,500 Product Images Daily Without Breaking the Pipeline

A behind-the-scenes look at the technical workflow that keeps eCommerce image editing consistent at scale — and what breaks when you try to fully automate it.

We process over 7,500 product images every single day.

When you're running at that volume, even a 2% error rate means 150 broken images going out to clients' Amazon listings, Shopify stores, and product catalogs. A 2% error rate at that volume is a business problem, not a rounding error.

This post is about what we learned building a pipeline that handles that volume reliably — the parts that automated well, the parts that didn't, and the specific technical decisions that made the difference.

If you're a developer building an eCommerce image processing workflow, or a technical founder trying to figure out how to scale product photo operations, this is the breakdown I wish I'd had earlier.

The Core Problem With Fully Automated Image Processing

Every developer who builds an image processing pipeline goes through the same arc.

Phase 1: "AI background removal is incredible. I'll automate everything."

Phase 2: "Why are 30% of these outputs rejected by Amazon?"

Phase 3: "Why is my client's return rate going up?"

Phase 4: "I need to add human review back in. But where?"

The issue isn't that AI image processing is bad. It's that it's inconsistent in ways that are difficult to detect automatically — and the failures that matter most are the ones that look fine at thumbnail resolution but fail at 1:1 zoom or fail RGB verification.

Here's what a naive automated pipeline misses:

# What developers think background removal does:
result = ai_remove_background(image)
# Returns: clean product on transparent background

# What actually happens on complex products:
# - Jewelry chains: partial removal, missing links
# - Fabric with lace: holes in the garment, not the background
# - Transparent products: product partially removed
# - Products matching background color: random artifacts
# - Hair/fur: jagged staircase edges at 1:1 zoom

None of these failures are visible in a thumbnail. All of them are visible when a customer zooms in on an Amazon listing. Some of them trigger Amazon's automated image compliance rejection.

The Architecture That Actually Works

After significant iteration, our pipeline looks like this:

INPUT
  └── Client uploads batch (RAW/JPEG/TIFF)

STAGE 1: Automated Pre-processing
  ├── Format normalization → TIFF for editing
  ├── Metadata extraction (product type, shoot group)
  ├── Resolution validation (reject < 1000px)
  ├── Color profile normalization → Adobe RGB
  └── Smart grouping by shoot condition/lighting

STAGE 2: Complexity Classification
  ├── Edge complexity score (simple / medium / complex)
  ├── Color match risk score (product vs background)
  ├── Product category tag (jewelry, clothing, electronics...)
  └── Route: simple → automated | medium/complex → human queue

STAGE 3A: Automated Processing (Simple Products)
  ├── AI background removal
  ├── Background verification (RGB check)
  ├── Auto crop to 85% frame fill
  ├── Color normalization
  └── QC scoring → pass / flag for review

STAGE 3B: Human Processing (Complex Products)
  ├── Manual pen tool clipping path
  ├── Hair/fur masking (Select and Mask)
  ├── Ghost mannequin compositing (where applicable)
  ├── Color correction against reference
  └── Senior editor QC sign-off

STAGE 4: Export Pipeline
  ├── Platform-specific export (Amazon / Shopify / print)
  ├── WebP conversion + JPEG fallback
  ├── Final RGB verification on white background
  ├── File naming (ASIN or client convention)
  └── Delivery package assembly

OUTPUT
  └── Marketplace-ready, verified images

The key insight is Stage 2: Complexity Classification. This is the decision point that determines whether a product goes through automated or human processing. Getting this right is what separates a pipeline with 98% quality from one with 70% quality.

Building the Complexity Classifier

The classifier uses a combination of heuristics and a trained model to route images:

def classify_complexity(image_path, metadata):
    img = load_image(image_path)

    # Heuristic checks (fast, no model inference needed)
    edge_score = calculate_edge_complexity(img)
    color_match_risk = check_foreground_background_similarity(img)

    # Metadata-based rules (highest confidence)
    category_rules = {
        'jewelry': 'complex',      # Always human - chains, gems
        'fur': 'complex',          # Always human - fine edges
        'lingerie': 'complex',     # Always human - lace, mesh
        'transparent': 'complex',  # Always human - glass, acrylic
        'electronics': 'simple',   # Usually box/flat, clean edges
        'books': 'simple',         # Rectangular, clean
        'cosmetics_tube': 'medium' # Curved but usually clean
    }

    if metadata.get('category') in category_rules:
        base_score = category_rules[metadata['category']]
    else:
        # Fall back to image analysis
        if edge_score > COMPLEX_THRESHOLD:
            base_score = 'complex'
        elif edge_score > MEDIUM_THRESHOLD or color_match_risk > 0.3:
            base_score = 'medium'
        else:
            base_score = 'simple'

    return base_score

We started with pure image analysis and found that metadata rules outperformed it significantly on the categories we see most. Jewelry is always complex. Full stop. No edge detection algorithm reliably handles gold chains against a white background — the color similarity between gold-lit chain and slightly warm white causes consistent AI failures.

The RGB Verification Step Everyone Skips

Amazon requires background RGB of exactly 255, 255, 255. Not 253, 254, 254. Not 250, 252, 255. Exactly 255.

The problem: AI background removal tools frequently produce backgrounds that look white on screen but fail the actual RGB check. A background of RGB 248, 250, 248 looks white at normal monitor brightness. It causes listing rejection.

def verify_background_compliance(image_path, sample_points=50):
    """
    Sample multiple background points and verify against
    Amazon's pure white requirement (RGB 255,255,255)
    """
    img = Image.open(image_path).convert('RGB')
    width, height = img.size

    # Sample points around the perimeter (where background should be)
    sample_coords = generate_perimeter_samples(width, height, sample_points)

    failures = []
    for x, y in sample_coords:
        r, g, b = img.getpixel((x, y))
        if r < 250 or g < 250 or b < 250:
            failures.append({
                'coord': (x, y),
                'rgb': (r, g, b),
                'delta': (255-r, 255-g, 255-b)
            })

    compliance_rate = 1 - (len(failures) / sample_points)

    if compliance_rate < 0.95:
        return {
            'status': 'FAIL',
            'compliance_rate': compliance_rate,
            'failures': failures,
            'action': 'route_to_correction'
        }

    return {
        'status': 'PASS',
        'compliance_rate': compliance_rate
    }

This runs on every image before it leaves the pipeline. Simple, fast, catches the most common Amazon rejection cause.

Ghost Mannequin Compositing — Why Automation Fails Here

Ghost mannequin (hollow mannequin) is one of the most requested services in fashion eCommerce. You photograph the garment on a mannequin, then remove the mannequin so the garment appears three-dimensional and self-supporting.

Every attempt to automate this properly has failed — including our own experiments with segmentation models. Here's why:

The ghost mannequin problem requires:
1. Segmenting the garment from the mannequin (reasonably solvable with AI)
2. Identifying what garment areas were obscured by the mannequin body (not solvable)
3. Using a second "inside label" photo to fill the neck/armhole gaps (requires human composition)
4. Blending interior and exterior photos seamlessly (requires contextual judgment)
5. Adjusting for how the fabric would naturally fall without a body (requires physics/experience)

Step 2 is the blocker. An AI model can identify that there's a gap where the mannequin neck was. It cannot reliably reconstruct what the interior collar or neckline looks like based on the exterior shot alone.

The result of automated attempts: composited images where the neckline looks incorrect, fabric doesn't meet properly, or interior details are hallucinated in ways that don't match the actual garment.

For a fashion brand listing on Amazon or running paid ads, a wrong-looking neckline on a sweater photograph is a conversion killer and a brand credibility issue.

This is why ghost mannequin service at scale still requires human compositing editors — the step that AI cannot reliably handle is precisely the most visible part of the final image.

Export Pipeline — Platform-Specific Requirements as Code

One of the more tedious parts of eCommerce image processing is managing platform-specific export requirements. We codify these as configurations rather than hardcoding them:

PLATFORM_CONFIGS = {
    'amazon_main': {
        'background': 'pure_white',  # RGB 255,255,255
        'min_dimension': 1000,
        'recommended_dimension': 2000,
        'format': 'JPEG',
        'quality': 95,
        'color_space': 'sRGB',
        'product_fill_min': 0.85,  # 85% of frame
        'max_file_size_mb': 10,
        'naming': 'ASIN'
    },
    'amazon_secondary': {
        'background': 'any',
        'min_dimension': 1000,
        'recommended_dimension': 2000,
        'format': 'JPEG',
        'quality': 90,
        'color_space': 'sRGB',
        'max_file_size_mb': 10
    },
    'shopify': {
        'background': 'white_recommended',
        'recommended_dimension': 2048,
        'format': 'WebP',
        'quality': 85,
        'color_space': 'sRGB',
        'aspect_ratio': '1:1'
    },
    'print_catalog': {
        'background': 'any',
        'format': 'TIFF',
        'bit_depth': 16,
        'color_space': 'AdobeRGB',
        'dpi': 300,
        'sizing': 'full_resolution'
    },
    'google_shopping': {
        'background': 'white_or_light_grey',
        'min_dimension': 100,
        'recommended_dimension': 800,
        'format': 'WebP',
        'quality': 85,
        'color_space': 'sRGB'
    }
}

def export_for_platform(image_path, platform, asin=None):
    config = PLATFORM_CONFIGS[platform]
    img = Image.open(image_path)

    # Apply platform-specific processing
    img = resize_for_platform(img, config)
    img = convert_color_space(img, config['color_space'])

    if config['background'] == 'pure_white':
        img = ensure_pure_white_background(img)

    filename = generate_filename(platform, asin, config)
    output_path = f"/exports/{platform}/{filename}"

    save_with_config(img, output_path, config)

    # Verify compliance before returning
    verify_output_compliance(output_path, config)

    return output_path

The QC Scoring System

Rather than binary pass/fail, we use a scoring system that determines routing:

def calculate_qc_score(image_path, platform_config):
    scores = {}

    # Background score (0-25 points)
    bg_result = verify_background_compliance(image_path)
    scores['background'] = 25 if bg_result['status'] == 'PASS' else \
                           int(25 * bg_result['compliance_rate'])

    # Edge quality score (0-25 points)  
    edge_result = analyze_edge_quality(image_path)
    scores['edge_quality'] = edge_result['score']

    # Product fill score (0-25 points)
    fill_result = check_product_fill(image_path, platform_config)
    scores['product_fill'] = 25 if fill_result['fill_ratio'] >= 0.85 else \
                             int(25 * (fill_result['fill_ratio'] / 0.85))

    # Color accuracy score (0-25 points)
    # Requires reference — set to max if no reference available
    color_result = check_color_accuracy(image_path)
    scores['color_accuracy'] = color_result.get('score', 25)

    total_score = sum(scores.values())

    return {
        'total': total_score,
        'breakdown': scores,
        'routing': 'auto_approve' if total_score >= 90 else \
                   'human_review' if total_score >= 70 else \
                   'reject_and_redo'
    }

Images scoring 90+ ship automatically. 70-89 go to a human reviewer who makes the final call. Below 70 go back to the editing queue.

This routing system is what keeps the 7,500 daily volume manageable without a QC team that's checking every single image.

What We Still Haven't Fully Automated

After several years of iterating on this pipeline, here's the honest list of what still requires human judgment:

Color accuracy against physical product. We can normalize colors and correct color casts algorithmically, but verifying that the final image matches the physical product in the box requires a human with a calibrated monitor and the actual product.

Ghost mannequin compositing. As described above — the interior/exterior blend step is not reliably automatable at quality levels that fashion brands accept.

Complex edge products. Jewelry, fine lace, transparent products, and multi-colored products against similar-colored backgrounds — automated edge detection fails too often at 1:1 zoom.

Brand-specific aesthetic judgment. Some clients have specific retouching styles, shadow treatments, or color profiles that require knowing what "looks right for this brand" — which is not something a general model captures well.

Professional photo retouching at the detail level — dust removal, surface scratch correction, reflection management on jewelry — these remain human tasks because they require understanding what should and shouldn't be in the final image.

The rule of thumb that's held up: automate the repeatable decisions. Human-review the judgment calls. Verify everything before it ships.

The Metric That Matters

We track one metric above all others: client return rate change after implementing our edited images.

Not throughput. Not AI adoption percentage. Not cost per image.

Whether our clients are seeing fewer returns after switching to our edited product images. Because if our "optimized" pipeline is producing images that look better than the product, we're optimizing for the wrong outcome. Higher conversion from better-looking images + higher return rate from misleading images = zero net benefit, with added customer trust damage.

The only win condition is images that are accurate, compliant, and fast to produce. All three. Not two out of three.

Conclusion

Building a product image pipeline at scale taught us that the question is never "AI or human." It's "which decisions can be automated reliably and which require judgment."

The answer is roughly: pre-processing, routing, format conversion, and QC scoring automate well. Background removal on simple products automates well. Color space management automates well.

Complex edge removal, ghost mannequin, final color accuracy verification, and brand-specific aesthetic decisions do not automate well — at least not to the quality level that fashion brands and Amazon listings require.

The pipeline that works is the one that's honest about those limits and routes accordingly.

Clipp Out Line (clippoutline.com) has provided product photo editing for eCommerce brands since 2010. Services: background removal · clipping path · ghost mannequin · color correction · photo retouching · Amazon photo editing

ecommerce#python#imageprocessing#automation#webdev`

Building a Fast Lightroom Workflow for Professional Photo Editing

Liton Roy — Mon, 29 Jun 2026 05:38:29 +0000

Building a Fast Lightroom Workflow for Professional Photo Editing

Photo editing isn't just about making images look better. It's about creating a workflow that delivers consistent, high-quality results while saving hours of repetitive work.

Whether you're a photographer, an eCommerce business owner, or a photo editor, having a structured Lightroom workflow can dramatically improve productivity.

Why Workflow Matters

Many beginners edit photos randomly.

They adjust exposure.

Then colors.

Then crop.

Then go back and change exposure again.

This creates inconsistency and wastes time.

A professional workflow follows the same sequence every time.

Step 1: Import Images

Create a folder structure before importing.

Example:

Client/
    RAW/
    Lightroom Catalog/
    Export/
    Final/

Rename files during import.

Add copyright metadata.

Apply basic presets automatically.

Step 2: Cull Photos

Never edit every photo.

Use ratings:

⭐ Keep

⭐⭐ Client Select

⭐⭐⭐ Portfolio

Reject duplicates immediately.

This alone can save hours.

Step 3: Global Adjustments

Start with changes that affect the entire image.

Exposure
White Balance
Contrast
Highlights
Shadows
Blacks
Whites

Avoid local adjustments at this stage.

Step 4: Lens Corrections

Always enable:

Remove Chromatic Aberration
Enable Lens Profile Corrections

These two options instantly improve image quality.

Step 5: Crop and Composition

Now refine the composition.

Common aspect ratios:

1:1
4:5
3:2
16:9

Straighten horizons before moving on.

Step 6: Local Adjustments

Only after global edits should you use:

Masking
Brush
Radial Gradient
Linear Gradient

These tools help direct the viewer's attention.

Step 7: Color Grading

Keep colors natural.

Instead of increasing Saturation heavily, consider using Vibrance.

Small adjustments usually look more professional.

Step 8: Noise Reduction and Sharpening

Every camera needs different settings.

Generally:

Apply sharpening carefully.
Reduce luminance noise only when necessary.
Zoom to 100% before making decisions.

Step 9: Export

Choose export settings based on the destination.

Website

JPEG
sRGB
80–85% Quality

Social Media

Long edge: 2048px
JPEG
Optimized for fast loading

Print

TIFF or high-quality JPEG
Adobe RGB (if required)
300 DPI

Bonus Tips

Here are a few habits that have improved my workflow:

Build your own presets.
Use Smart Previews for faster editing.
Learn keyboard shortcuts.
Sync edits across similar images.
Keep Lightroom catalogs organized.

Final Thoughts

The biggest productivity boost doesn't come from buying a faster computer.

It comes from following a repeatable editing workflow.

Once every project follows the same sequence, editing becomes faster, more consistent, and much easier to scale.

What's your Lightroom workflow? I'd love to hear how you organize your editing process and what techniques save you the most time.

Building a Fast Lightroom Workflow for Professional Photo Editing. Photo editing isn't just about making images look better. It's about creating a workflow that delivers consistent, high-quality results while saving hours, details: clippoutline.com

Liton Roy — Mon, 29 Jun 2026 05:36:22 +0000