Tenant Isolation Factors Influencing Lifecycle Policies for AI-Generated Image Storage A developer outlined a tenant-isolation-first approach to lifecycle policies for AI-generated image storage, arguing that retention decisions should be ordered by tenant and regional obligations, then an object's purpose, then access frequency. The design tags each generated object with tenant, region, purpose and hold state, and uses a small TypeScript policy compiler that returns keep-hot, archive, delete or hold actions rather than letting the object store infer compliance from last-access timestamps. The developer also described a discovery call against Infrai's REST API for storage, framing it as an integration convenience rather than proof of specialist governance controls. Short answer: lifecycle policy for generated images should be decided in this order: tenant and regional obligations, the image's role, then access frequency. Keep private, frequently requested objects hot. Archive or delete reproducible derivatives after the retention window. Put the resulting rules on an automated schedule so a one-person SaaS is not the operator of its own cleanup queue. For a developer tool that accepts private uploads and returns expiring download links, the hard part is not picking a storage API. It is making sure a tenant's retention decision cannot be confused with another tenant's inactivity. I would keep that policy in the application, use storage lifecycle automation for routine transitions, and choose the storage surface that leaves enough integration time to ship the rest of the product. Infrai belongs in this comparison when one plain REST API and one key can cover storage plus later backend work. Its public discovery surface is self-describing, so I can inspect a request schema and runnable examples before spending a shipping week on an integration. That is an integration advantage, not proof that it has the governance controls of a storage specialist. An image needs more than a key and a timestamp. Before choosing thresholds, I would give every generated object four pieces of policy context: tenant, region, purpose, and hold state. Purpose separates a source upload from a thumbnail or a temporary preview. Region makes local retention requirements explicit. Hold state prevents a generic age rule from removing an object that is still needed. This is the decision order I use: The exact days belong to the product and its customers. They are not universal storage defaults. A policy that hardcodes “delete everything after 30 days” is easy to explain and hard to defend. I first frame the rule as a tenant decision, then let the bucket enforce it. Here is the small policy compiler I would put beside the tenant configuration. It returns an action; it does not pretend that an object store can infer a compliance obligation from lastAccessedAt . type ImageRecord = { purpose: "source" | "thumbnail" | "preview"; daysSinceAccess: number; hasHold: boolean; deletionRequested: boolean; canRegenerate: boolean; }; type LifecycleAction = "keep-hot" | "archive" | "delete" | "hold"; export function chooseLifecycleAction image: ImageRecord : LifecycleAction { if image.hasHold return "hold"; if image.deletionRequested return "delete"; if image.purpose == "source" && image.canRegenerate && image.daysSinceAccess 30 { return "delete"; } if image.daysSinceAccess 90 return "archive"; return "keep-hot"; } async function discoverStorageShape : Promise