I have a strange attitude towards managed solutions. In general, I don’t always see great benefits in using them. On the other hand, this is what Microsoft recommends for production environments, so should I even be bringing this up?
This is why I probably don’t mind it either way now (managed or unmanaged); although, if somebody decides to go with unmanaged, I will be happy to remind them about this:
Still, it’s good to have a clear recommendation, but it would be even better to understand the “why-s” of it. Of course it would be much easier if we could describe the difference between managed/unmanaged in terms of the benefits each of those solution types is bringing.
For example, consider Debug and Release builds of your C# code in the development world. Debug version will have some extra debugging information, but it could also be slower/bigger. Release version might be somewhat faster and smaller, so it’s better for production. However, it’s not quite the same as managed/unmanaged in PowerApps since we can’t, really, say that managed is faster or slower, that there is some extra information in the unmanaged that will help with debugging, etc.
I am not sure I can do it that clearly for “managed” vs “unmanaged”, but let’s look at a few benefits of the managed solutions which are, sometimes, misunderstood.
1. There is no ability to edit solution components directly
The key here is “directly”. The screenshot below explains it very clearly:
In other words, you would not be able to lock solution components just by starting to use a managed solution. You’d have to disable customizations of those components (and, yes, those settings will be imported as part of the solution). Without that, you might still go to the default solution and modify the settings.
However, locking those components makes your solution much less extendable. This is probably one of the reasons why Microsoft is not overusing that technique, and we can still happily customize contacts, accounts, and other “managed” entities:
Despite the fact that Account is managed (see screenshot above), we can still add forms, update fields, create new fields, etc.
Then, do managed solutions help with “component locking”? From my standpoint, the answer is “sometimes”.
2. Ability to delete solution components is always great
This can be as risky as it is useful. It’s true that, with the unmanaged solutions, we can add components but we can’t delete them (we can “manually” or through the API, but not as part of solution removal). Managed solutions can be of great help there. However, even with managed there can be some planning involved.
Would you delete an attribute just like that or would you need to ensure data retention? What if an attribute is removed from the dev environment by a developer who did not think of the data retention, and, then, that solution is deployed in production? The attribute, and the data, will be gone forever.
Is it good or bad? Again, it depends. You may not want to automate certain things to that extent.
3. Managed can’t be exported, and that’s ok
For a long time, this has been my main concern. If the dev environment gets broken or becomes out of sync with production, how do we restore it?
This is where, I think, once we start talking about using managed solutions in production, we should also start talking about using some form of source control and devops. Whether it’s Azure DevOps, or whether it’s something else, but we need a way to store solution sources somewhere just in case we have to re-build our dev environment, and, also, we need to ensure we don’t deploy something in prod “manually”, but we always do it from the source control.
Which is great, but, if you ever looked at setting up devops for PowerApps, you might realize that it is not such a simple exercise. Do you have the expertise (or developers/consultants) for that?
So, at this point, do you still want to use managed solutions?
If you are not that certain anymore, I think that’s exactly what I wanted to achieve, but, if you just said “No”, maybe that’s taking it too far.
All the latest enhancements in that area (solution history, for example) are tied into the concept of managed solutions. The product team has certainly been pushing managed solutions lately. I still think there is a missing piece that will make the choice obvious as far as internal development goes, but, of course, as far as ISV-s are concerned managed is exactly what they need. Besides, you might be able to put “delete” feature to good use even for internal development, and you may be ok with having to figure out proper source control, and, possibly, ci/cd for your solutions. Hence, “managed” might just be the best way to go in those scenarios.
What additional things would managed solutions need to offer that would make them a clear and obvoius choice for you (and everyone) to use? A couple things I can think of would be (using the .NET assemblies analogy) ‘strongly named’ solutions that include anti-tampering measures and would be cryptographically signed. Another could be Dynamics/CDS restricting the ability to only allow the import of managed solutions in production environments. In the end, the more differences Microsoft adds to them to differentiate how they function in an end-result, the more obvious it would become to need to use them.
Not quite sure. I think I would certainly want to mitigate the risks. So, for example, if I could somehow prevent removal or truncation of attributes to avoid non-intentional data removal(a setting somewhere to only allow “attribute upgrades” for example), that would be useful. Also, if would be nice if we could just turn managed into unmanaged(knowing that there could be some disclaimers as to what the result is going to look like) for re-export in case something goes wrong with the dev environment/source control. Agree there should be something obvious on the “benefits” side (which goes both ways, though: unmanaged should be beneficial for dev, managed should be beneficial for production). As in… maybe we should be able to modify unmanaged solutions on the fly, without having to “publish”? That might decrease dev time…