It is really up to your own preference. To be clear, a bootstrapper typically is a central script which implements a few comfort features for scripting using module scripts and can be as simple or complex as you like. The absolute most basic version of this would be a script that simply iterates over all the modules you want to load and requires them. This introduces a few issues however;
Imagine you have two modules, module A, and module B. Both modules have been required by your bootstrapper and are running, doing whatever they do. Consider that, module A must communicate with, call a method of, or otherwise interact with module B. A simple solution for this is to just require module B from module A and run the function, however when you do this, module A is now creating a new running instance of module B, throwing away it’s own internal state that it has been maintaining since the bootstrapper started it.
Instead, bootstrappers typically maintain one singular reference to each module, effectively making them “singletons,” then whenever module A wants something from module B, the bootstrapper steps in and hands module A it’s master reference to module B, where it can then call that method without losing module B’s internal state. You could simply write your modules around this limitation, and have them not keep any internal state, however at that point you may as well abandon using modules entirely and just use normal scripts (which is also a valid approach).
Many other problems exist that you will inevitably discover attempting to create a bootstrapper. There are many such ways to solve these issues and you will find that many solutions exist. These are typically referred to as ECS frameworks. Here are a few popular ones I know of:
fwiw, Flamework is a Typescript implementation of an ECS framework. Look into roblox-ts if you are interested, but roblox-ts is generally falling out of popularity as the new type solver is developed. It has a good community and a developed package ecosystem however is generally irrelevant for new projects.
I think the main important thing to keep at the center of your thoughts is to keep your project simple. Is it actually complex enough to require an entire framework, or can you get by simply by using scripts and events? Is that maintainable? Do you even care about maintainability? Frameworks are attractive to abstract away lots of issues, but sometimes they can bloat your project and make it harder to work within.