u/thisisBrunoCosta

A question that I think is going to get more important across OutSystems shops as Mentor and Data Fabric move from announcement into adoption.

If your AI / ML / data science team asked for production-shape data from your OutSystems applications tomorrow (real volumes, real customer patterns, real edge cases) to train or fine-tune a model or process, how long until they had it?

A few things I'm trying to understand from teams actually doing this:

1) Where does the training data come from in practice? A Service Studio extension? Direct SQL Server / Oracle queries against the runtime DB? A timer that exports to a file? Something on the Forge? Mentor / Data Fabric integration?

2) For OutSystems entities specifically (with all the platform metadata, BPT process instance data, system tables), do you train on the user-data-only subset, or is the platform context part of the value?

3) Anonymization before training: who owns it? The OutSystems team? The data team? Both, in a handoff?

4) For ODC vs O11, does the AI access pattern look different given the operational model differences?

5) Is your AI / ML initiative moving forward steadily, or is it stalled because the data plumbing isn't ready?

My newsletter edition this week is the series finale, on whether low-code data infrastructure is ready for AI. Asking r/OutSystems before I extrapolate from generic patterns. The OutSystems-specific shape of this is what I want to learn.

Your Mendix team needs production-shape data in dev or acceptance to test properly. Real volumes, real distributions, real edge cases that synthetic test data won't surface.

But that data has personal information in it. GDPR doesn't care which environment it's sitting in.

How do you actually handle this in practice**?**

A few specific things I'm trying to understand:

1) Do you anonymize before the data leaves production, during transfer, or after it lands in the lower environment**?**

2) If you anonymize after, where does the un-anonymized export sit in the meantime, and is that intermediate storage in scope for your compliance audits**?**

3) For consistency (a name appearing in 47 records becoming the same fake name across all 47), are you using a tool, a Java action, a microflow that runs at first startup, or something else**?**

4) For referential integrity across the domain model, what breaks first when teams improvise**?**

5) For Mendix Cloud restores specifically, how are you handling the gap between "full backup restore" and "restored-then-anonymized"?

I'm not pitching anything. My next newsletter edition is on this topic and I'd rather hear how Mendix teams actually solve it before I extrapolate from generic patterns.

Have you found a clean approach, or is everyone improvising and hoping the auditor doesn't ask too many questions?

Thanks!

Bear with me on a self-assessment question.

>When OutSystems teams describe a normal week, how much of the work actually happens inside Service Studio (or ODC Studio), and how much happens dropping below it - to advanced SQL, scripts, or custom code that lives outside the platform**?**

A few drop-down moments that come up when low-code teams describe their work. Which of these does your team actually do, and how often?

=> Data operations between environments. Scripts or direct DB access (SSMS, SQL Developer, whatever your team uses) for migrations, refreshes, masking. Platform handles the build; data ops live elsewhere.

=> Production debugging. Querying the runtime database directly because the model in Service Studio says everything looks fine, but the data tells a different story.

=> Environment refresh. Custom code or shell scripts to clone a subset of production data into dev or QA. Not something the platform ships at meaningful scale.

=> Reporting at scale. Complex BI queries hitting the database directly because the platform reporting layer hits its limits.

=> Integrations. External data flowing in through advanced SQL or custom REST handlers that bypass the standard integration patterns.

I'm not claiming this is universal, that's part of why I'm asking.

If your team's reality looks different, I want to hear it!

The honest ratio question:

=> If your team spends 80 percent of its time inside the platform and 20 percent below, that's probably acceptable. The platform handles most of it, you drop down for edge cases.

=> If it's 60/40, you're spending nearly half your time outside the abstraction your organization paid for.

=> If it's 50/50, you've adopted a hybrid approach. The costs of both worlds, the benefits of neither.

Two things I'm trying to understand:

1. Where does your team actually spend its time? Not where you'd like, where it really happens.

2. Are the drop-down moments inevitable (the abstraction can never cover them), or are they caused by gaps better tooling would close?

Especially curious to hear from teams running enterprise-scale apps, where the gap between platform-level model and database reality becomes more visible.

A developer told me yesterday that in ODC, you cannot really debug in the QA environment because of the Kubernetes containerization. The exact words were:

>"I have worked in ODC for some time and effectively it is not possible to access and do debug in the QA environment because of the Kubernetes containerization."

I am not 100 percent sure what "debug" means here. Is it the Service Studio-equivalent debugger, the one you attach to a running environment to set breakpoints and step through logic? Is it the ability to inspect runtime state of a specific request? Is it something else about the developer-to-environment debugging surface that containerization breaks?

I do not have firsthand ODC experience to verify exactly what is blocked... But the statement landed because it points at something bigger I've been posting about.

So I am genuinely asking:

1. What is your actual ODC debugging workflow when you need to trace a production issue in QA, or a first time issue detected in Qa and you've got to correct it in Dev? What tools do you reach for first, and what do you lose compared to O11?
2. When Kubernetes containerization blocks something, what specifically is blocked? The debugger? Runtime request inspection? Something else (I heard about the limits in database access)? I want to understand the shape of the gap, not just that there is one.
3. For teams that moved from O11 to ODC, how long did it take to rebuild a debugging workflow you trust, and what did you have to change about how you diagnose issues?

This ties into something I have been thinking about for a while. Low-code abstraction is great for building. But it is often the reason debugging gets harder, because the abstraction hides the layers where issues actually live.

I wrote about this pattern more broadly in this week's newsletter (link in first comment). The ODC containerization may be an instance of the same pattern: operational abstraction is cleaner, but it narrows the developer's access to the layers where production bugs actually surface.

Curious to hear from people actually working in ODC right now. What does debugging really look like**?**