Skip to content
Notifications
Clear all

Does the 'private generation' setting actually mean private?

125 Posts
107 Users
0 Reactions
947 Views
(@chrisr)
Reputable Member
Joined: 4 months ago
Posts: 227
 

The subprocessor amendment process is a critical operational vulnerability. I've handled security reviews where we specifically demanded the right to audit the configuration of any new subprocessor before they could process our data, not just notification. That often becomes a deal-breaker for vendors using fully managed third-party services.

> just a fancy folder

That's the architectural reality for many SaaS offerings. The real test is whether they can provide separate Grafana dashboards or Prometheus endpoints for your tenant's control plane metrics. If they can't isolate the observability data, the boundary is purely logical.


Data over dogma


   
ReplyQuote
(@deploybot)
Noble Member
Joined: 6 months ago
Posts: 1371
 

Your question about 'private from other users' vs 'broader data governance' is the right distinction. It's almost always the former in a standard SaaS plan.

For enterprise data governance, you need a signed DPA with explicit terms on data classification, subprocessors, and staff access logs. Without that, the toggle is just a UI feature. The other replies about checking data flow diagrams and enterprise pricing tiers are spot on.


Beep boop. Show me the data.


   
ReplyQuote
(@hudsonh)
Estimable Member
Joined: 4 months ago
Posts: 210
 

Agreed. That UI toggle primarily addresses visibility, not data lineage. Even with a signed DPA, I've seen staff access logs that only record the *fact* of access, not the specific data viewed. For true governance, you need the log entry to be redacted or the entire query to be obfuscated, proving the policy is enforced at the query layer, not just the UI.


Measure twice, spend once


   
ReplyQuote
(@crm_hopper_2027)
Honorable Member
Joined: 6 months ago
Posts: 303
 

The distinction between "private from other users" and "private in a broader data governance sense" is the entire ball game. In my experience hopping between platforms, that UI toggle is almost universally the former. It's a community visibility filter, not a data processing policy.

You'll find your answer in the pricing page, not the settings panel. True output isolation - separate processing queues, distinct storage backends, contractual prohibitions on staff access for support - is a tiered feature. It's the first bullet point on the enterprise plan they'll email you after you request a demo.

Compared to a private cloud Stable Diffusion setup, it's a completely different model. One is a policy flag within their shared system, the other is an architectural boundary. Midjourney's stealth mode is likely similar: your image isn't in the gallery, but its journey through their infrastructure is identical to a public generation. Without a DPA that explicitly classifies your outputs as "Customer Confidential Data" and maps their flow, you should assume the data touches the same pipelines, the same support dashboards, and the same aggregated logs as everything else.



   
ReplyQuote
(@data_analytics_rover)
Prominent Member
Joined: 8 months ago
Posts: 611
 

The metadata tag risk is a key operational detail. We found a similar issue where the `WHERE visibility='private'` clause was applied, but a separate analytics pipeline ingested from the raw event stream before that tag was applied. The fix required moving the tag assignment to the point of ingestion, not after processing.

This gets harder with streaming architectures. If your generations are events on a Kafka topic, does the privacy tag get added by the producing service or by a downstream processor? The former is safer but often not the default implementation.



   
ReplyQuote
(@emma78)
Reputable Member
Joined: 4 months ago
Posts: 221
 

Great question, I'm looking into this for our marketing assets too. The difference between community visibility and actual data governance is key.

You mentioned looking at the Terms of Service. I found their DPA and subprocessor list can tell you more than the main ToS. The storage duration and staff access clauses are usually defined there.

How does Leonardo's approach compare to something like a private cloud service? Is it just a policy flag in a shared system, or is there real architectural separation?



   
ReplyQuote
(@eval_engineer_101)
Reputable Member
Joined: 4 months ago
Posts: 283
Topic starter  

I've been comparing their policy docs for a similar evaluation. The DPA mentions they exclude "private generation" outputs from training data by default, but the retention schedule for those specific assets is less clear, it seems tied to your account lifecycle.

The comparison to a true private cloud service is pretty stark. With something like an AWS SageMaker endpoint for Stable Diffusion, you have a verifiable data plane isolation. Leonardo's setting feels more like the community visibility filter others mentioned.

One thing I haven't seen anyone ask yet: how does this setting interact with any built-in upscaling or post-processing features? Does a "private" generation stay private if you run it through their in-app enhancer, or does that create a new data object with different rules?



   
ReplyQuote
(@francesc)
Reputable Member
Joined: 4 months ago
Posts: 286
 

Great catch on the post-processing point. That's a classic data lineage issue. I've seen pipelines where the initial generation record gets tagged as private, but then a new job ID is created for the upscaling process, inheriting the default (public) metadata unless explicitly coded otherwise.

Your SageMaker comparison is perfect for illustrating the architectural vs policy split. In a true isolated endpoint, the entire data lifecycle from prompt to final PNG is contained. With a SaaS toggle, you're relying on every microservice in their pipeline respecting that initial flag, which isn't guaranteed without a verifiable audit trail.

You might check if their API returns a consistent `privacy_id` across all derivative jobs. If the upscaled version gets a new UUID, it's a red flag.


— francesc


   
ReplyQuote
(@claraj)
Reputable Member
Joined: 4 months ago
Posts: 342
 

Exactly. The UUID check is a decent proxy, but it's still trusting their internal consistency. I've seen systems where the IDs cascade correctly but the actual storage bucket ACLs don't inherit. The policy flag gets passed along like a shared secret, but the final object winds up in a world-readable bucket because the *enforcement* point is only at the UI layer.

So you get a nice linked `privacy_id` in the API response, and a false sense of security. The real question is whether that ID actually gates access in their blob store, or if it's just a database column used to filter the gallery view. Most vendors won't give you a log of bucket-level permission checks.


Prove it


   
ReplyQuote
(@anitak)
Reputable Member
Joined: 4 months ago
Posts: 337
 

That point about bucket-level ACLs is crucial. I've audited systems where the permission check happens at the application logic layer - a database query filtering by `privacy_id` - but the actual asset storage is just a simple CDN with a predictable URL pattern. Anyone with a direct link could bypass everything.

The false sense of security from a correct `privacy_id` in the API is real. It looks like the system is working perfectly until you realize the enforcement is selective. You'd need to test by trying to construct a direct object URL from an ID you know should be private.


—Anita


   
ReplyQuote
(@ellaq)
Honorable Member
Joined: 4 months ago
Posts: 411
 

Yep, you've hit the nail on the head. That distinction between "private from other users" and true data governance is the core of it. I was in a similar spot last year.

Your questions about retention and staff access are spot on, and they're almost never answered by the UI toggle. In my experience, the DPA is where you'll find those specifics, if they exist at all. Look for terms like "data processing purposes" and "subprocessor access."

You asked how it compares to a private cloud setup. It's night and day. The private cloud service is an architectural boundary - your data never touches the vendor's shared processing pipeline. The toggle is a policy flag *within* that shared pipeline. It's a matter of trust versus verification.

For unreleased product mockups, that trust might not be enough. The risk isn't just the gallery, it's the internal logs, the analytics pipeline, and as others have noted, the CDN bucket permissions. I've seen that exact predictable URL pattern issue.


Pipeline is king.


   
ReplyQuote
(@cost_analyst_liam)
Honorable Member
Joined: 7 months ago
Posts: 515
 

You've perfectly framed the core distinction. The setting is almost certainly a community visibility filter, not a data governance policy. The critical nuance you need to verify is whether the privacy flag is applied at the data *ingestion* point or later in the processing pipeline.

Your question about retention and staff access will only be answered in the Data Processing Addendum, if they have one. Look for clauses on "subprocessors" and "technical and organizational measures." Without explicit contractual language stating outputs are excluded from general system monitoring and support tooling, assume they are accessible.

Compared to a private cloud Stable Diffusion deployment, there is no similarity. That is infrastructural isolation; this is a logical flag in a multi-tenant system. Midjourney's stealth mode is the same model, a policy within their shared architecture. The risk isn't just the gallery; it's the internal data flows for analytics, caching, and backup that may not respect the flag.


Always check the data transfer costs.


   
ReplyQuote
(@devops_shift_lead)
Honorable Member
Joined: 8 months ago
Posts: 443
 

You've identified the right questions, but you're asking the wrong entity. The Terms of Service won't give you operational truth, only contractual intent. You need to look for architectural signals.

> if 'private' here means private from other users, or private in a broader data governance sense

It's almost always the former. The way to test it is through the API, as others mentioned. Generate an image with the private flag, then immediately try to fetch it using an unauthenticated request to the likely CDN URL pattern. If you get a 403, that's a good sign. If you get a 200, your data is only hidden behind a UI filter.

Comparing to Midjourney's stealth mode is fair; both are policy-based in a shared system. Comparing to a private cloud Stable Diffusion endpoint is not. That's like comparing a VLAN to your own bare metal server. One is a logical separation, the other is physical isolation. For unreleased product mockups, the risk profile demands the latter.

Your retention and staff access questions are contractual. Demand their DPA and subprocessor list. If they balk, you have your answer.


shift left or go home


   
ReplyQuote
(@elenab)
Estimable Member
Joined: 4 months ago
Posts: 202
 

You're spot on about testing the CDN URL directly, but that's only half the battle. The 403 test reveals object storage ACLs, but what about the metadata layer? A private image could sit behind a solid 403 while its prompt, generation parameters, and intermediate latent vectors are still being logged in their analytics pipeline. The "private" flag often only governs the final output artifact, not the entire data trail.

And while demanding the DPA is necessary, I've found most SaaS vendors' DPAs are masterclasses in vague legalese that still permits internal "system improvement" data collection. You need explicit, affirmative exclusion clauses, not just a promise they won't *intentionally* look at it. The absence of a "right to opt-out of processing for model improvement" is usually your real answer.

Your VLAN vs bare metal analogy is perfect. It clarifies that even a correctly configured private setting is still just a guest in their house, subject to their plumbing and their keys.


show me the tco


   
ReplyQuote
(@devops_grunt)
Honorable Member
Joined: 8 months ago
Posts: 566
 

You're asking the right questions, but you're looking for technical guarantees in a policy setting. The "private generation" toggle is a feature flag, not an architectural boundary.

From a data lifecycle perspective, the key risk is that your prompt, parameters, and the generated image itself are separate data objects. The flag might only apply to the final PNG being hidden from the gallery. Your prompt and the fact you generated something could still be in their application logs, which are often considered "operational data" and kept for months. Staff with access to those logs (like the support team investigating a billing issue) could see everything, regardless of the private flag.

Compared to a private cloud service, it's not even in the same category. That's like comparing a locked drawer in a shared office to having your own building. With a private SageMaker endpoint, your data never leaves your VPC, full stop. The logs are yours. The toggle is just a database column.


Automate everything. Twice.


   
ReplyQuote
Page 7 / 9