Tag: Delivery

The evaluation document has forty rows and thirty-six of them are about the interface. You will use the interface twice. You will use the API every day for the next four years.

Short answer: an asset platform is worth adopting when three things are true. You can upload and get back a stable identifier in one call, you can construct any rendition as a URL without a round trip, and you can search and manage assets over a documented API with real SDKs. Everything else is convenience. Those three determine whether it disappears into your stack or becomes a system you maintain.

The three primitives

Upload returns an identifier. One call, a file or a remote URL in, a stable identifier out. The identifier must be yours to choose or at least yours to predict, because your product records will store it and they will be written before the upload completes in at least one code path. Upload presets are the mechanism for making an upload carry a policy rather than a pile of parameters, which matters as soon as more than one thing uploads.

Renditions are URLs. Given an identifier and a set of parameters, the delivery URL is constructible client-side, deterministically, with no API call. This is the property that makes the whole thing composable, and it is what separates a delivery platform from a file host with a resize endpoint. The transformation reference is worth reading not to memorise but to check that the parameter space covers what your design system needs.

Assets are queryable. Not just listable. A search API that can filter on your own structured fields is the difference between an asset library and a bucket with a nice front end, and it is the thing you will need the first time someone asks for every image using an expiring licence.

If a platform gives you those three cleanly, most integration questions have short answers. If it gives you two, you will be writing a service to paper over the third.

The first call test

Before any evaluation meeting, try to get from nothing to a working delivery URL. Time it, and note how many browser tabs you needed.

The shape you want looks roughly like this: install the SDK, set one credential, upload a file, receive an identifier, print a URL with a size and a format parameter, load it in a browser. Cloudinary publishes SDKs across about seventeen languages plus a CLI, and the whole loop is a handful of lines in any of them.

That test tells you more than a feature matrix, for a reason worth stating explicitly. The path from zero to a working call is the path every developer on your team will take, repeatedly, for years, and the path an AI coding assistant will take when it writes the integration for you. A platform whose first call requires provisioning, a support conversation and a bucket policy is a platform that will be integrated once, badly, by whoever drew the short straw.

Cloudinary has done unusual work on that second audience specifically. It ships MCP servers and an llms.txt alongside the normal documentation, so an assistant retrieving context gets the real parameter syntax rather than a plausible guess. Whether or not you care about that today, it is a reasonable proxy for how seriously a vendor takes the machine-readable surface of its own product.

Why day one beats month eighteen

This is the part that gets argued about, so here is the argument without adjectives.

The usual advice is that a media platform is something you adopt once you have a scale problem. That advice assumes the value is scale-contingent, and it is not. What you get from the first upload is structure: the asset has an identifier, a description, a version, and a defined way to render itself. What you get without it is a file in a folder whose meaning lives in a naming convention and in the head of whoever wrote it.

The cost of not having that structure shows up immediately, not at scale:

• The first crop someone needs becomes a file. By month three there are two hundred files nobody can trace to a master.
• Image paths get hard-coded into the front end, because there is nothing to construct them from.
• Nothing records what an image depicts, so alt text is either absent or invented per placement.
• Nobody can tell which of two similar files is current, at forty assets just as much as at forty thousand.

Then the migration arrives. Moving to a structured media layer at month eighteen means finding every hard-coded path across every codebase, matching every stored derivative to a master that may no longer exist, and backfilling metadata that was never captured. Doing it on day one costs an account and a URL helper.

For a solo developer or a small team building an MVP, this is the whole argument. You are not adopting infrastructure for the scale you hope to reach. You are avoiding a migration you would otherwise schedule for the exact quarter when you can least afford it. The free Programmable Media tier makes the day-one version cost nothing, which removes the last reason to defer.

What to check that the demo will not show you

Signed and time-limited URLs. If any asset is not public, you need signed delivery and you need to understand how signature verification interacts with caching. Ask early, because retrofitting it is unpleasant.

Access control granularity. Be precise here, because vendor material tends not to be. Permissions in most asset platforms, Cloudinary included, are organised at the folder level rather than per asset. That is usually fine, and it is only fine if you design your structure around it rather than assuming per-asset rules you can query at runtime.

Relationships between assets. Similarly, do not design an integration that depends on traversing arbitrary asset-to-asset relationships as a first-class API concept. Model relationships on the product side, where they belong anyway, as described in DAM vs PIM.

Eventing. Notifications on upload, transformation and moderation, with retries and signed payloads, so your systems react rather than poll.

Exit. Can you enumerate every asset and download every master through the API. The answer sets your migration cost, in both directions, and migration tooling that works on the way in usually works on the way out.

When is a bucket and a CDN enough?

When all of the following hold, and they hold more often than this page implies.

• Assets are public, few, and rarely change.
• One front end, one set of breakpoints, no marketplace or partner consuming your images.
• No third-party rights and no expiry dates to track.
• Nobody needs to search assets by anything other than filename.

That is a real configuration and object storage behind a CDN serves it well. The threshold is crossed by the second consumer of the same images, or by the first licence that expires, and both tend to arrive without warning.

What is worth avoiding either way is the middle option: a bucket, plus a resizing service, plus a hand-rolled metadata table. That combination has the operational burden of a platform and the capability of a folder, and the reasoning behind that judgement is in build versus buy for the product catalogue.

What does the integration look like once it is right?

Small. The product record holds an identifier. A shared helper turns an identifier plus a named shape into a URL. The front ends call the helper. A webhook updates a three-field read model when an asset changes state. There is no sync job and no staging directory.

That is the whole thing, and the surrounding design is in wiring a DAM to a PIM for the catalogue side and media in a headless commerce stack for the front-end side. The asset-level capabilities it depends on are in what a DAM actually does, and the parallel set of questions for the product platform is in what to demand from a PIM API before you buy. If you are weighing this against assembling something from tools you already have, alternatives to buying a DAM and a PIM covers those honestly.