20 million images a day. Smaller, faster, and nobody waits.

One image is small. Twenty million a day is not.

An international company needed a service that automatically makes incoming images smaller and faster, without any visible loss of quality. The requirements were simple. The volume was not:

• images arrive continuously, in large numbers, with peaks,
• whoever uploads must not wait for processing,
• the same image should never be processed twice.

We built the API backend, and we have run it ever since. Today it is scaled to 20 million images a day.

What it does

• Compression at three levels. Normal, strong and maximum, trading quality against size. A typical 855 KB JPEG shrinks to 111 KB, 87% smaller, in 26 milliseconds.
• Format conversion. JPEG, PNG, WebP and AVIF, even several formats from a single request.
• Resizing and AI-based smart cropping. Thumbnails are not cut from the middle of the image but around the subject: AI recognises where the important part is.
• AI image recognition. The system recognises what is in the image and writes its alt text, title, caption and description, so images make sense to search engines and screen readers too.
• Colour accuracy. Colour profiles are kept, and metadata can be kept on request.
• Never twice. When an image is already known, the finished result comes back within 20 milliseconds.
• No waiting. An upload is acknowledged within 100 milliseconds, processing runs in the background, and the system can send a notification when the result is ready.
• Delivery. Finished images reach visitors through a caching layer.

How it handles the volume

The key is that uploading and processing are separated.

1. The API answers straight away. It stores the image and puts a job on a queue.
2. Workers take jobs from the queue. Several run in parallel, and their number grows with the load.
3. The cache absorbs repetition. The same image is only produced once.
4. Statistics run separately. Measuring does not slow down image processing.

So a peak doesn’t land on the person uploading. It lands in the queue, which the system works through on its own.

What we run

We didn’t just build it. We monitor, update and scale it: capacity follows the traffic, the database is backed up daily, and alerts reach us at night too.

Optimising one image takes milliseconds. Twenty million a day takes design.

What is worth remembering

• Move what is slow into the background. Users wait for the acknowledgement, not the processing.
• Don’t recompute what you already have. A cache is the cheapest capacity there is.