
<div class='article-page-content__container'>
<div class='article-page-content__container__left'><h3>The End of an Era?</h3><h4>08 April 2025</h4><div class='category-icon'>Research</div><div class='article-page-content__container__left__summary'><p><em>"</em>An era can be said to end when its basic illusions are exhausted.<em>"</em></p><p>Arthur Miller</p></div><h5>By Niels Clemen Jensen</h5><div class='article-page-content__container__left__links'><a download='the-end-of-an-era' href='/Content/Downloads/67f50fa88f78d5a7b8153446_250408TheEndofanEra.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/67f50a2c7560e84b6fe527f1_iStock-645230644_705x414.jpg#257;article-main-image;705;414' /></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#258;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#258;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#258;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#258;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>Preface</h4><p>You may wonder why this paper has been structured as a research paper and not as an Absolute Return Letter. After all, isn&rsquo;t it topics like this we cover in our monthly Absolute Return Letters? Under normal circumstances, yes, but present circumstances are not normal. A person with a poor understanding of the finer details of economics happens to be in charge of the most powerful economy on planet Earth; however, he also happens to be of the opinion that he knows more than most about almost anything, so he is reluctant to take advice. If you think I am too harsh, I suggest you listen to <a href="https://www.youtube.com/watch?v=sR3f95BGIiA">this</a>.</p>

<p>Equity markets all over the world have hit a wall in recent days, and nowhere has it felt more painful than in Nasdaq-listed stocks. After peaking on the 19th of February at 22,222.61, the Nasdaq 100 index has dropped 21.6% and now stands at 17,430.68 as these lines are written. When an equity market is down at least 10% but no more than 20%, it is classified as a correction. If the -20% line is crossed, it is no longer a correction but a bear market, i.e., we are now officially in a bear market, at least as far as Nasdaq stocks are concerned.</p>

<p>It is not all bad news, though. The journey since March 2009, which marked the end of the dark days aka the Global Financial Crisis, has been extraordinary. The Nasdaq 100 is up about 1,000% since then. 2022 was tricky but, overall, the 16 years from early 2009 to early 2025 have been second to none. However, a big question is lining up. Should investors expect 2025 to be a repeat of 2022 and use the current malaise as a buying opportunity, or have we finally arrived at the end of the road? That is the question I will address in this paper.</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#259;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#259;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#259;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#259;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>The caveat</h4><p>Admittedly, I am biased. I think Trump is a clown but a very powerful one. Being Danish, thus caught up in the Greenland saga, it is hard not to take a negative view on him. Having said that, this paper is not a rant about Trump. I shall do my very, very best to be as objective as possible, but it is only fair that I make my position clear.</p>
</div><div class='article-page-content__container__right__item' data-alt-text='<p><strong>Exhibit 1: Ten largest constituents in Nasdaq 100</strong></p>

<p><em>Source: </em><a href="https://www.slickcharts.com/nasdaq100"><em>slickcharts.com</em></a></p>
' data-image='/Content/Images/67f50cce3e3f8fff80865034_Picture2.png#260;slide-image;;' data-alt-text2= '<p><strong>Exhibit 2: Performance of Nasdaq 100, last 12 months</strong></p>

<p><em>Source: </em><a href="https://finance.yahoo.com/quote/%5ENDX/"><em>Yahoo Finance</em></a></p>
' data-image2= '/Content/Images/67f50cfcaef23ab906cc05a4_Picture3.png#260;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#260;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#260;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>The problem in a nutshell</h4><p>Why are US equities suddenly underperforming equities elsewhere after (many) years of outperforming the rest of the world? &nbsp;The underlying reasons are several, but it is obvious that investors, at least temporarily, have fallen out of love with Big Tech, hence why Nasdaq 100 is suffering more than S&amp;P 500. As you can see in Exhibit 1 below, Big Tech is well represented in the top-10 of the Nasdaq 100, where the ten largest companies account for nearly 50% of the index. I should point out that Big Tech is also well represented in S&amp;P 500 but not quite to the same degree.</p>

<p>--image--</p>

<p>If you then flick to Exhibit 2, you can see that the downfall in Nasdaq 100 since the February peak has been quite spectacular, even if there was an attempt to recover in the third week of March.</p>

<p>--image2--</p>

<p>The sell-off has had the effect of bringing the P/E multiple on Nasdaq 100 much closer to its long-term average, even if we are not quite there yet (Exhibit 3). The chart actually sums up one of the biggest misconceptions re: how &lsquo;overpriced&rsquo; US stocks are. Big Tech? &nbsp;Yes, they are expensive, although rapid earnings growth amongst Big Tech companies, to some degree, justifies those high earnings multiples. However, most US stocks away from megacap stocks are not particularly expensive.</p>
</div><div class='article-page-content__container__right__item' data-alt-text='<p><strong>Exhibit 3: Nasdaq 100 NTM P/E multiple range, last 10 years</strong></p>

<p><em>Source: Bloomberg</em></p>
' data-image='/Content/Images/67f50d391c0bd84e0942e3fc_Picture4.png#261;slide-image;;' data-alt-text2= '<p><strong>Exhibit 4: The Magnificent 7 &ndash; NTM P/E multiples and PEG ratios</strong></p>

<p><em>Note: As of COB, 7th of April 2025<br />
Source: FactSet</em></p>
' data-image2= '/Content/Images/67f50d8497136867f62751a4_Screenshot2025-04-08125011.png#261;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#261;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#261;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>Why the PEG ratio matters</h4><p>I use a simple measure to establish whether a high P/E multiple can be justified or not. It is called the PEG <em>ratio </em>and is calculated as the P/E ratio divided by the growth rate of the company&rsquo;s core earnings for a specified time period. I typically use the next 1-2 years when calculating the PEG ratio. In my book, the PEG ratio offers more value than the P/E ratio in terms of how attractively priced a stock is.</p>

<p>--image--</p>

<p>It goes without saying that the lower the PEG ratio is, the more attractively priced the stock in question is. I find a PEG ratio below 1.0 <em>very </em>attractive and a PEG ratio between 1.0 and 1.5 adequate for investment purposes; however, the yellow flag comes up, if the PEG ratio approaches 2.0, and the flag turns red, if the PEG ratio is higher than 2.5.</p>

<p>Now, let&rsquo;s take a look at how the Magnificent 7 (the biggest of Big Tech) are valued (Exhibit 4). You will note that, in this paper, I mention individual company names, something I normally don&rsquo;t do. It is difficult to make the argument I am about to make, though, without using names. That said, I will stop short of making any recommendations, which will breach our compliance policy. Having said that, as you can see below, both P/E multiples and PEG ratios are all over the place when it comes to the Magnificent 7. I am sure you can draw your own conclusions.</p>

<p>--image2--</p>

<p>&nbsp;</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#262;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#262;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#262;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#262;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>Why Big Tech companies are so highly valued</h4><p>Cutting straight to the core of this issue, Big Tech stocks are expensive, although not as expensive as they were not that long ago, because of two letters: AI. Investors all over the world appear convinced &ndash; or they appeared convinced until a few weeks ago &ndash; that AI will bring unfathomable wealth to those who are prepared to embrace the technology.</p>

<p>To begin with, the so-called hyperscalers were in the winning boat. Hyperscalers are what it says on the tin. They provide the infrastructure required for AI to be rolled out, and they are capable of structuring it in a way that makes it scalable in line with demand growth. Many of the companies in Exhibit 4 are hyperscalers.</p>

<p>Hyperscalers were not the only early winners, though. There is a whole forest of suppliers to the hyperscalers, and they have also benefitted from the rollout of the AI infrastructure. In the early days of the AI craze, the hyperscalers benefitted from a limited knowledge of the industry amongst many investors and thus managed to attract most attention; however, more recently, suppliers have joined the party.</p>

<p>The next step in the AI revolution is the race for <em>adoption</em>. Companies from many different industries are expected to benefit, provided they adopt the technology. As it stands, the adoption rate has been disappointingly low, and that may be part of the reason why tech stocks are performing so poorly. The low adoption rate may also partially explain the big multiple gap between Big Tech and the rest of the market.</p>

<p>The AI craze reminds me of the dotcom fad in the late 1990s. At the height of that craze, investors would invest in <em>anything </em>that appeared to have at least a toe in the dotcom pool. Few critical questions were asked, and almost nobody paid any attention to the fact that when a new technology is introduced, there will both be winners and losers. Fast forward to today&rsquo;s AI craze and tell me if you think it is any different this time.</p>
</div><div class='article-page-content__container__right__item' data-alt-text='<p><strong>Exhibit 5: Ownership breakdown of US equities</strong><br />
<em>Source: Goldman Sachs Global Investment Research</em></p>
' data-image='/Content/Images/67f50e0b97136867f627db56_Picture5.png#263;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#263;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#263;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#263;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>What has changed to cause Big Tech to fall?</h4><p>I started this research paper by stating that Big Tech have been under tremendous pressure in recent weeks. Let me finish it by stating why I think that is. I am sure, if I researched it a bit more, I could come up with plenty more reasons why that is but, to me, four reasons stand out as to why Big Tech have suddenly sold off:</p>

<p><strong>A. Disappointingly low adoption of AI in other industries.</strong></p>

<p>Outside of the technology industry, the desire to adopt AI has been frustratingly low so far (frustrating, at least for the hyperscalers). There is convincing evidence that AI can be used to fulfil many functions in a large number of industries, but the appetite to roll it out has been limited so far.</p>

<p>If that doesn&rsquo;t change, the hyperscalers will have to scale back on their investments. That said, the emergence of DeepSeek is likely to accelerate the adoption rate, as DeepSeek appears to be offering largely the same solutions as US AI suppliers for a fraction of the price.</p>

<p>I also think that the challenging demographic outlook will encourage more companies to adopt AI. Labour shortages will become a growing problem, and AI offers an elegant solution to that.</p>

<p><strong>B. Policy uncertainty.</strong></p>

<p>Policy uncertainty is a rather unquantifiable factor, but if companies and households are uncertain as to what the government is up to, they invest less and they consume less. Therefore, stock prices are also negatively affected by rising policy uncertainty.</p>

<p>The US policy uncertainty index has skyrocketed under Trump, and that has had a negative impact on US equities. However, it is a somewhat fickle indicator, as perceptions &ndash; policy certainty vs. uncertainty &ndash; can change virtually overnight.</p>

<p><strong>C. The link between tariffs and economic growth.</strong></p>

<p>This factor is closely linked to the previous one. Trump&rsquo;s desire to penalise the rest of the world will have a significant impact on economic growth. Since the early days of the industrial revolution, international trade has been the most important source of economic growth. Trying to limit that is a massive economic own goal.</p>

<p>It is no coincidence that most Wall Street firms have raised their recession probability estimate following Trump&rsquo;s announcement last week. The most aggressive estimate I have seen so far comes from J.P. Morgan who raised it from 40% to 60% only a couple of days ago, but other estimates are not far behind. The recent collapse of the yield on 10-year US Treasuries is another sign of radically changing recession expectations.</p>

<p><strong>D. Less appetite for US investments amongst non-US investors.</strong></p>

<p>18% of all US equities are held by non-US investors (Exhibit 5). And, given non-US investors&rsquo; appetite for blue chips when investing abroad, I wouldn&rsquo;t be surprised if more than 18% of Big Tech is held by non-US investors, although I have no documentation to support that claim.</p>

<p>Now, investors all over the world are tired of Trump and want to penalise him. The big Canadian pension funds are upset. So are the Danish pension funds (mostly but not exclusively because of Greenland), and they are not alone here in Europe. Canadian investors account for nearly one-quarter of the 18% and European investors for no less than half.</p>

<p>In other words, a very substantial percentage of all non-US investors have expressed their dismay with Trump. In Denmark, four large pension funds have announced that they are selling <em>everything </em>in the US.</p>

<p>&nbsp;</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#264;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#264;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#264;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#264;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>Where are we likely to go from here?</h4><p>The most important question at this stage is whether all the uncertainty created by Trump will cause a recession or not. Although it is not a certainty (yet), I am with J.P. Morgan when putting the risk at 60%, i.e. more likely than not. What comes next therefore assumes that a recession will pop up over the next 12 months.</p>

<p>Two important questions to begin with:</p>

<p><strong>(i) will the recession be limited to the US, or will it be more widespread?</strong></p>

<p>The close link between policy uncertainty and economic growth is not specific to the US. Economic growth will therefore be affected worldwide, although one could argue that the US economy is more exposed due to Trump&rsquo;s eagerness to antagonise the rest of the world.</p>

<p><strong>(ii) how deep is this recession likely to be (if one)?</strong></p>

<p>Effectively, there are two recession types &ndash; event-driven recessions (e.g. COVID-19) and those caused by a tight central bank. This one (if a recession) is the former type. Whereas those caused by the Fed are usually also fixed by the Fed (by lowering the policy rate), event-driven recessions require a catalyst to fix the problem, such as the invention of an effective vaccine as in the case of COVID-19.</p>

<p>Could the US government come up with a catalyst? Not if you ask them now, but a lot can change over the next 12 months, particularly if you take their desire to &nbsp;win in the midterm elections in November 2026 into account.</p>

<p>I suspect that this recession is (sort of) engineered. The US economy already looked tired, and a relatively mild recession now followed up by a number of rate cuts will allow Trump to say, ahead of the midterm elections, that he has lowered the cost of living for all Americans as promised. I don&rsquo;t see any reasons why this recession shouldn&rsquo;t be relatively shallow.</p>

<p>On that basis, I think equities worldwide will continue to decline but that the fall in the US will be bigger than elsewhere. The US has suffered 12 recessions since World War II. Equities have, on average, declined 24% in those 12 recessions; however, the decline has been much bigger in the last three recessions.</p>

<p>Why? I suspect it has to do with valuations. US equities have been much more expensive since the dotcom bubble in the late 1990s, and expensive stocks fall more than cheap stocks in an economic downturn. For that reason, I expect the decline, peak to trough, to be bigger than 24% and, because of that, I am a seller more than a buyer at current prices.</p>

<p>Having said that, although AI adoption may happen more slowly than the bulls want,<em> the AI era is not over!</em> &nbsp;I have never come across a profit-enhancing new technology that is allowed to simmer on the backburner year after year, and I don&rsquo;t think it is going to happen to this one either. Big Tech will therefore become a buy again. It is all about timing.</p>
</div><div><h4>By Niels Clemen Jensen</h4><p><strong>08 April 2025</strong></p></div></div></div>