
<div class='article-page-content__container'>
<div class='article-page-content__container__left'><h3>Looking behind the Facade of LEO</h3><h4>06 March 2025</h4><div class='category-icon'>Research</div><div class='article-page-content__container__left__summary'><p><em>"</em>Leo is a very good friend of mine, but LEO is something altogether different. You can invest in LEO but not in Leo. Within the next few years, LEO offers plenty of investment opportunities.<em>"</em></p><p>Niels Jensen</p></div><h5>By Niels Clemen Jensen</h5><div class='article-page-content__container__left__links'><a download='looking-behind-the-facade-of-leo' href='/Content/Downloads/ARP/ARP250306.pdf'><i class='fa-solid fa-arrow-down-to-line'></i> Article PDF Download</a>
            <button onclick='shareArticle()' value='share'><i class='fa-solid fa-share-alt'></i> Share Article</button><a href='/megatrends'><i class='fa-solid fa-eye'></i> View Megatrends</a></div></div>
<div class='article-page-content__container__right'><div class='article-page-content__container__right__image'><img src='/Content/Images/67c9d94421906ff846ace754_iStock-1253695441_705x414.jpg#255;article-main-image;705;414' /></div><div class='article-page-content__container__right__item' data-alt-text='<p><strong>Exhibit 1: LEO satellite TAM</strong><br />
<em>Note: TAM is a term used to measure the Total Addressable Market, revenue-wise.<br />
Source: Goldman Sachs Global Investment Research</em></p>
' data-image='/Content/Images/67c9e1b98631340cfd6b881f_Picture1.png#271;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#271;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#271;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#271;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>Preface</h4><p>There are roughly 7,000 Low Earth Orbit (LEO) satellites in space today. Current plans are to launch an additional 70,0000 between now and 2035 (Exhibit 1). Such rapid growth (10x over ten years) will have significant implications, hence this paper.</p>

<p>--image--</p>
</div><div class='article-page-content__container__right__item' data-alt-text='' data-image='//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#272;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#272;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#272;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#272;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>Why so many LEOs?</h4><p>I used to own a holiday home in Mallorca &ndash; tucked away in Serra de Tramuntana, the mountain chain that runs along the northwest coast of the island. &nbsp;Our internet connection was terrible, until somebody suggested I switch to a satellite connection. What a difference it made!</p>

<p>That is precisely what LEO brings to the table. In difficult terrain and/or in thinly populated areas where ground-based technologies struggle, LEO satellites prosper; however, their low altitude gives a narrower field of view when compared to GEO or MEO satellites (see later), meaning that 1,000+ LEO satellites are required to create global coverage. Adding to that, to allow all subscribers to use the communications system simultaneously, a high number of LEO satellites shall be required. Only then can the operator guarantee sufficient speed and bandwidth for all users.</p>
</div><div class='article-page-content__container__right__item' data-alt-text='' data-image='//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#273;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#273;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#273;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#273;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>Main beneficiaries</h4><p>Many industries stand to take advantage of the anticipated growth in LEO satellites. Satellite manufacturers will benefit, not only because of all the new LEO satellites but also because the satellites must be replaced regularly, i.e., replacement demand will also accelerate.</p>

<p>Ground stations will also benefit, as their revenues are driven by the number of satellites in orbit. So will operators of user terminals, as their revenues will increase in line with the growth in the number of subscribers. And so will satellite service companies. With more satellites in orbit, more things can go wrong.</p>
</div><div class='article-page-content__container__right__item' data-alt-text='<p><strong>Exhibit 2: OECD countries by population density / GDP per capita</strong><br />
<em>Source: Goldman Sachs Global Investment Research</em></p>
' data-image='/Content/Images/67c9e21a09577c9933bcdd27_Picture2.png#274;slide-image;;' data-alt-text2= '<p><strong>Exhibit 3: LEO launching costs over time</strong><br />
<em>Source: Goldman Sachs Global Investment Research</em></p>
' data-image2= '/Content/Images/67c9e26ab471d4afb4e8fb20_Picture3.png#274;slide-image2;;' data-alt-text3= '<p><strong>Exhibit 4: Starlink LEO satellites, key statistics</strong><br />
<em>Source: Goldman Sachs Global Investment Research</em></p>
' data-image3= '/Content/Images/67c9e29d35a0460927f25404_Picture4.png#274;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#274;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>The disruptive nature of LEO satellites</h4><p>LEO satellites are highly disruptive and will, over time, do immense damage to traditional, ground-based telecommunications companies. Some Wall Street analysts (e.g. Goldman Sachs) argue that satellite capacity constraints (see later) offer substantial reassurances for traditional telecommunications companies, and that may indeed be the case over the near term; however, I don&rsquo;t think LEO satellite operators will be satisfied, when they have conquered most thinly populated parts of the world.</p>

<p>Goldman Sachs has done an interesting study, where they compare GDP per capita to population density (Exhibit 2). As you can see, even in the developed world, hundreds of millions of people live in countries that are relatively thinly populated. In other words, there is plenty to start with before LEO satellite operators need to take market share away from the incumbents in order to grow; however, it will happen eventually, I believe.</p>

<p>--image--</p>

<p>Over the medium to long-term, LEO satellite operators aim to become mainstream providers, offering for example mobile phone services, which are typically not run via satellites today.</p>

<p>--image2--</p>

<p>As with all new technologies, in the early days, the LEO technology is relatively expensive, but costs are bound to come down. They have in fact already declined somewhat and are expected to fall much further in the years to come (Exhibit 3).</p>

<p>The ability to disrupt is obviously a function of price, but it is also very much a function of the technology at hand, particularly the communication capacity. As you can see in Exhibit 4 below, this technology is moving <em>very </em>fast. Starlink launched version V1.5 in June 2021. Less than two years later, in February 2023, version V2 Mini was launched, and it offered four times higher communication capacity. Now, with version V3 on our doorstep, capacity is about to take another major leap forward.</p>

<p>--image3--</p>

<p>Only the most na&iuml;ve would expect it to stop here. The technology will continue to improve, the cost of delivering the services embedded will continue to come down and, therefore, LEO satellites will become increasingly disruptive.</p>
</div><div class='article-page-content__container__right__item' data-alt-text='' data-image='//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#275;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#275;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#275;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#275;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>Key challenges</h4><p>Going from 7,000 to 77,000 LEO satellites over the next ten years may not even be enough to satisfy demand. If we assume that LEO satellites will increasingly replace ground-based telecommunications infrastructure, many more shall be required. Let&rsquo;s play with the numbers for a second. &nbsp;If we assume LEO satellites should cover half the global population, and that all subscribers should be offered 100 Mbps speed, 461,000 LEO satellites shall be required.</p>

<p>Here is the problem: the sky can only accommodate about 100,000 LEO satellites. There simply isn&rsquo;t room for more. Therefore, enlarging the bandwidth per satellite is the only solution, once you have reached the maximum.</p>

<p>The challenges don&rsquo;t stop there. Cost is also a major issue, and so is latency. A 5G base station costs $43,000 per unit. By comparison, Starlink (a prominent satellite operator owned by SpaceX) paid more than $3 million per unit for their last satellites. In terms of latency, the data transmission path is, not surprisingly, much longer when using satellites than it is for ground-based technologies.</p>

<p>Finally, one should also consider the cost of debris management, which is likely to be strictly monitored by regulatory authorities. A LEO satellite lasts about five years, and space debris must be collected and removed to minimise the risk of debris &lsquo;overloading&rsquo; in space, which could damage civil aircraft, spaceships as well as other satellites.</p>

<p>Because of all those issues, there are reasons to believe that not all planned satellite launches may actually happen. Precisely how many that will fail to launch is impossible to say at this stage; however, it seems a safe bet to assume that a certain proportion of all planned LEO launches will in fact never happen.</p>
</div><div class='article-page-content__container__right__item' data-alt-text='<p><strong>Exhibit 5: Field of view, GEO vs. MEO vs. LEO</strong><br />
<em>Source: Goldman Sachs Global Investment Research</em></p>
' data-image='/Content/Images/67c9e2f8cbeb8bdbb12abaec_Picture5.png#276;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#276;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#276;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#276;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>The losers</h4><p>Over the near term, incumbent satellite operators look likely to lose the most. Current satellite systems &ndash; mostly so-called GEO (Geostationary Equatorial Orbit) satellites of which there are 575 in orbit &ndash; are clearly inferior technologically speaking and cost a great deal more to launch when compared to LEO satellites. For full transparency, there are also 142 so-called MEO (Medium Earth Orbit) satellites in orbit, but they are also inferior to LEO satellites. The only parameter that favours GEO and MEO over LEO, other than field of view (Exhibit 5), is expected lifespan &ndash; 14, 10 and 5 years respectively.</p>

<p>--image--</p>

<p>Those facts are likely to lead to significant migration away from GEO and MEO to LEO satellites. Unfortunately, from a European point-of-view, GEO and MEO satellites are dominated by European satellite operators, whereas LEO satellites are not. In other words, European satellite operators look to be the losers in the transition to LEO.</p>

<p>Longer term, I believe traditional telecommunications companies are also at risk. Although the research team at Goldman Sachs believe there is room for cooperation between the two sides, I don&rsquo;t believe the risk/reward favours conventional telecommunications companies <em>at all</em>, and I struggle to see the investment case, when the incumbents are up against such powerful disruptors.</p>
</div><div class='article-page-content__container__right__item' data-alt-text='' data-image='//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#277;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#277;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#277;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#277;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>The winners</h4><p>I often get the impression that &lsquo;old world&rsquo; investors think LEO is all about Starlink, but that company accounts for only a modest proportion of all planned launches between now and 2035.</p>

<p>China accounts for no less than 53,000 of the 70,000 planned LEO satellite launches over the next ten years. Such strong growth should result in strong revenue growth throughout the supply chain.</p>

<p>Given the Chinese tendency to favour Chinese domestic companies when handing out orders, ideally, one would favour Chinese companies when construction a LEO portfolio; however, the Chinese depend on overseas talent when it comes to LEO satellites and, in that respect, Taiwanese and US companies are fighting for pole position. Therefore, I recommend a mix of Chinese, Taiwanese and US companies to dominate a LEO portfolio.</p>
</div><div class='article-page-content__container__right__item' data-alt-text='' data-image='//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#278;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#278;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#278;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#278;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>Final few words</h4><p>The race to conquer the world with LEO satellites is, to some degree, part of the much bigger space race currently unfolding. SpaceX has already entered into an agreement with the US government whereby the Pentagon can access Starlink&rsquo;s fleet of LEO satellites for military (monitoring) purposes, and I am sure something similar is about to happen in China, if it hasn&rsquo;t already happened.</p>

<p>In a forthcoming research paper, I will look at the unfolding space race, and what that means for financial markets. The world &lsquo;enjoyed&rsquo; a major arms race back in the 1970s and 1980s when the Soviet Union was in its prime, and the implications were many.</p>

<p>The space race unfolding now is effectively another arms race; however, up against the Americans are no longer the Russians but the Chinese. Furthermore, where the arms race in the 1980s was about nuclear bombs and other fancy hardware, the arms race now is very much about technological superiority. It is therefore difficult to draw too many parallels between arms races 1.0 and 2.0.</p>

<p>The conflict between China and the USA is further amplified by the recent fallout between President Trump and the political leadership in Europe, the latter of whom have made no secret of the fact that we, here in Europe, can no longer rely on the Americans as trusted friends. If one or two of our readers think I am overreacting now, why do you think European defence stocks are up 50%+ over the first few weeks of 2025?</p>

<p>All that will be discussed in the next research paper, though. Today, it is about LEO and why a LEO portfolio should be tweaked towards Asian stocks.</p>
</div><div><h4>By Niels Clemen Jensen</h4><p><strong>06 March 2025</strong></p></div></div></div>