Picture this; you are to serve food to a group of people but you have several options to consider. You could either serve them with your own cutlery or you could use some from a friend. Owning cutlery means having a kitchen large enough to support the logistics involved; cleaning, storage and what have you. Using a friend’s means that your kitchen logistics are definitely cheaper compared to the former.
Now, that is not the entire context of the scenario. You have to consider the people partaking. Ideally; you want the two to land on their hands at the same time. Otherwise you will be serving disaster. Now that is basically it for the analogy. Local content (LC) is content stored within your server. Content Delivered By a Network (CDN) live in another server but is referenced into your project; as if it lives in the server. As if the plates were yours.
Usually CDN’s host content that is either too large for your server to handle or the same content is re-usable across projects. An example of these would be; libraries, fonts, styles and boiler plate data. The mentioned can be sometimes rather large and tedious for the processing process. For example, the functions to highlight a button in a fancy way includes; the JavaScript(Js) Script to control the behavior, a style sheet (CSS) and a font library (.ttf binaries).
The button only needs content (the text to appear on it) and the action URL (what the button does). These two can take less than fifteen seconds for an average developer to set them out. The CDN stuff on the other hand might take the same developer several hours. If the same developer were to combine the two? Miracles of delivery would manifest; because only the unique stuff is being written.
Technically, this favors the developer in that; delivery time is drastically reduced. However the balance to that is that; the experience for the user (our allegorical partaker) might be of lower quality. There are chances that the CDN content (cutlery) might be late or worse; hinder the content (food) delivery. This is where developers strike and decide to take control.
To avoid such we have the Local Content option. Basically this involves identifying all the files that the CDN option gives and downloading them to the server. Sometimes building them from ground up. Why go through all the hustle? If you demand extreme control over the assets including the code running them, isolating your server from security threats that might come with imported content and the fact that your server is large enough to store all these.
Another reason why you would want to host your assets would be the fact that you can actually simulate CDN delivery to supercharge content deliver. Irony; for most of the time, this method beats CDN options in almost every metric. Why? They are lighter! Here is another reason; we can actually implement local caching on the client.
What is local caching? A cache is a set of content that you will most likely re use across sessions (repeated application access) or across the application pages. This means you can download this once and only re download it if you have modified it. It is like re using plates across meals because the meal is similar as opposed to bring in a fresh set to serve similar purpose. All you have to do is implement something which compares versions. Then your applications become much faster as result.
Now these two situations have their applications unique to context. That being said; I recently came across a situation where a CDN definitely served me better than LC. My point is; the chef decides the partakers experience. Content does share context with food as is developers to chefs. Taste is diminished if the food arrived late and cold. However, if there is no food at all, then whatever and however the chef serves is the tastiest thing until something better shows up.