Assets load differently, in surprising ways. Materials may work fine in Editor but not in Client.
Code executes differently. Timings are different, the Editor shares managed Heap with the Client, and so garbage collection is different.
And so on.
Rule 0 with Unity: _do not rely on the Editor for testing_.
I agree that you can't easily use editor performance profiles though; there's far too much editor noise.
Unity is still crap at loading things in order but you simply have to make peace with that. Instead you have to write a bit more defensively and assume that your code will get initialized in a random order. As long as you use Unity serialization all the references will be set when the lifecycle callbacks fire.
You can - Use coroutine Starts to wait for initialization
- Ensure all the inits are done in Awake so things are ready during Start
- You can also move away form initialization towards a more lazy pattern and make sure any calls into your behavior are asynchronous and include self init when needed.
It is a bit clunky but you can get used to it. Lean into the idea of behaviors being asynchronous actors and it makes a bit more sense.
All coroutines on a gameobject are halted if it is disabled, _and do not restart_ when it is re-enabled.
For this reason it is easy to mistakenly leave a game object half-initialized, due to an enormous amount of plausible situations where some event, script or other may disable the game object.
Now, there is a work-around: have Start yield a coroutine started on a "safe" object that will never disable.
The caveat is that the caller can be destroyed during execution of the coroutine but the coroutine will persist to execute because it is on another object.
The only lifecycle a behavior can trust is its own. Relying on other objects turns into a mess when your weak assumptions are violated.
Besides causing a spaghetti mess of lifecycle tracking and callbacks and such, it leaves you wide open to the major problem if callbacks running pass the life of the thing to call back to. You've thrown away Unity's lifecycle tools by dumping everything into a big pot. Now you have to null-check in the callbacks to make sure your things are still alive. Track your own state and you'll be fine.
Coroutines will stop when the owner dies and that is by design. Leverage that to ensure brain dead clean up.
Objects are very often going to be disabled through user action anyway, eg quitting a level. Its better to just assume that will happen at any time and plan accordingly.
I think with time/experience you'll learn to spot what to ignore (frame lengths, etc) and what you could count on. And just to test fully-build games often, and across clients.
* C# does something similar with hash across builds (so you don't depend on serializing/deserializing hashes and expect them to work; they want the freedom to change hash functions).