
<div class='article-page-content__container'>
<div class='article-page-content__container__left'><h3>The Implications of Increased Fiscal Spending in Germany</h3><h4>19 March 2025</h4><div class='category-icon'>Research</div><div class='article-page-content__container__left__summary'><p><em>"</em>It is time for a European awakening on defence and security. Our freedom and our prosperity depend on our security. And we have to bring our actions in line with the changing security environment.<em>"</em></p><p>Ursula von der Leyen, President of the European Commission</p></div><h5>By Niels Clemen Jensen</h5><div class='article-page-content__container__left__links'><a download='the-implications-of-increased-fiscal-spending-in-germany' href='/Content/Downloads/ARP/ARP250319.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/67dac35c27044c021c62adf4_iStock-1367187205_705x414.jpg#256;article-main-image;705;414' /></div><div class='article-page-content__container__right__item' data-alt-text='<p><strong>Exhibit 1: 33 European defence companies in top 100 by revenues</strong><br />
<em>Source: </em><a href="https://www.reddit.com/r/europe/comments/1j1zzv5/33_european_defense_companies_which_are_in_the/?rdt=40148"><em>reddit.com</em></a></p>
' data-image='/Content/Images/67dac3f52fb4f56c4c2ebfc5_Picture1.png#265;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#265;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#265;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#265;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>Preface</h4><p>The precursor to this research paper is the very anti-European rhetoric coming out of the Trump administration over the last month or so. The Americans have argued that Europe must cough up; that they shouldn&rsquo;t expect the American military umbrella always to be there if needed. Even with some rather tinted European glasses on, it is hard to disagree with that; however, it didn&rsquo;t stop with that. Trump turned out to be &lsquo;in bed&rsquo; with Putin and appeared prepared not only to throw Ukraine under the bus but to do the same to the rest of Europe.</p>

<p>It didn&rsquo;t take long for the penny to drop amongst government leaders in Europe. Emergency meeting after emergency meeting revealed that the purse was suddenly wide open for trillions of euros to be spent on defence, and European defence stocks responded as you would expect.</p>

<p>33 of the top 100 defence companies measured by revenue are European (Exhibit 1), so the instinctive reaction was to load up on those stocks; however, as it turned out, we were too late. Most of them were up well over 50% YTD, a few of them already up over 100% YTD.</p>

<p>--image--</p>

<p>Although it is indeed possible that European defence stocks have further to run, buying into an industry after it has already virtually doubled in price is a concept I really struggle with, hence the following question:</p>

<p><em>Will any other German (or other European) industries benefit from the significant increase in fiscal spending that the new German government seems committed to?</em></p>

<p>I will address that question below. If you expect this to be about which European defence companies to invest in, you will be thoroughly disappointed.</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#266;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#266;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#266;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#266;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>The German dilemma</h4><p>A couple of weeks ago, the likely new German government, a coalition between centre-right CDU and centre-left SPD, supported by the Greens, announced massive spending plans &ndash; partially on defence and partially on infrastructure. The spending plans are in fact so significant that they are not permissible within the context of the current German constitution. In other words, for those plans to be executed, the constitution must be re-written.</p>

<p>Here is the problem: Changing the German constitution shall require a two-thirds majority in both chambers of the German parliament &ndash; the Bundestag (the Lower House) and the Bundesrat (the Upper House) &ndash; and the new three-party coalition doesn&rsquo;t hold a big-enough majority.</p>

<p>However, there is a solution to the problem. The outgoing Bundestag will continue to rule until 23 March and here, the three parties jointly hold the majority required, i.e., the constitutional changes must be implemented before 23 March. Bundestag voted on the proposed changes yesterday (18 March) with 513 of 733 (70%) voting in favour. Bundesrat will have the final say in a vote scheduled for this coming Friday (21 March).</p>

<p>It is not a solution that is universally appreciated, though. Some argue that it is essentially an abuse of the constitution to use the outgoing majority to force through a change that the new, incoming government doesn&rsquo;t have the majority to implement. I am no constitutional expert and shall refrain from offering too many views on that. Suffice to say that we live in extraordinary times, and extraordinary times typically require extraordinary actions.</p>

<p>It is even more complicated than that, though. In CDU, there are several fiscal hardliners, and they must be convinced. Likewise, the deal with the Greens is not yet a done deal. Having said that, the Germans need to do <em>something </em>to get the German economy going again, and this is a relatively straightforward way to address the problem; i.e., my guess is that a deal will be done &ndash; both with the hardliners and the Greens.</p>

<p>As the proposal stands, &euro;500 billion will be spent on a mix of infrastructure and various green projects over a 10-year period. That equates to about 1% of GDP annually. Adding to that, a non-specified amount will be spent on defence; this is expected to add up to at least 1% of GDP annually for several years. As far as the latter is concerned, any defence spending exceeding 1% of GDP will be exempt from the constitutional debt brake, and that will free up capital for other measures.</p>
</div><div class='article-page-content__container__right__item' data-alt-text='<p><strong>Exhibit 2: European sector betas-to-GDP</strong><br />
<em>Source: Goldman Sachs Global Investment Research</em></p>
' data-image='/Content/Images/67dac460526a1bd8ed5e8a3b_Picture2.png#267;slide-image;;' data-alt-text2= '<p><strong>Exhibit 3: DAX vs. S&amp;P 500, NTM P/E discount vs. Economic Policy Uncertainty Index</strong><br />
<em>Source: Goldman Sachs Global Investment Research</em></p>
' data-image2= '/Content/Images/67dac4862165ca377172f5c9_Picture3.png#267;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#267;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#267;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>The beta angle</h4><p>The new German government is clearly prepared to spend its way out of the current economic malaise. That will stimulate GDP growth, not only in Germany but all over the EU. Corporate earnings will therefore also be positively affected.</p>

<p>However, there is another dimension to this story, and that has to do with valuations. If the narrative on European GDP growth improves, and it will if German GDP growth picks up, valuations will also improve in Europe. Historically, German industrial companies have, on average, had quite a high beta-to-GDP, but that could be about to change. See also Exhibit 2 below for various European sector betas-to-GDP.</p>

<p>--image--</p>

<p>The defence and the infrastructure industries are both characterised by having low betas-to-GDP. With a massive spending package on defence and infrastructure about to hit the German economy, the overall German industrial sector&rsquo;s beta-to-GDP will most likely drop meaningfully, which should again lead to higher equity valuations in Germany.</p>

<p>Germany is currently trading at about a 30% P/E discount to the US (Exhibit 3). As you can see, over the years, the valuation disparity can, to a significant degree, be explained by differences in economic policy uncertainty. According to Goldman Sachs, if the European Economic Policy Uncertainty Index were to decrease to a level similar to the corresponding US index, European equity valuations would improve by about 20%. And the rollout of this spending package will go a long way to make that happen.</p>

<p>--image2--</p>
</div><div class='article-page-content__container__right__item' data-alt-text='<p><strong>Exhibit 4a: Relative performance of various German equity indices, last six months</strong><br />
<em>Source: Goldman Sachs Global Investment Research</em></p>
' data-image='/Content/Images/67dac4c29def58af8c850ea9_Picture4.png#268;slide-image;;' data-alt-text2= '<p><strong>Exhibit 4b: Relative performance of German 10-year bonds, last six months</strong><br />
<em>Source: Goldman Sachs Global Investment Research</em></p>
' data-image2= '/Content/Images/67dac4d725a6c61967eb8c1c_Picture5.png#268;slide-image2;;' data-alt-text3= '<p><strong>Exhibit 5: 1-month beta of 10-year rates to global equities</strong><br />
<em>Source: Goldman Sachs Global Investment Research</em></p>
' data-image3= '/Content/Images/67dac4fa0e411680e5e37731_Picture6.png#268;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#268;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>The changing link between bonds and equities</h4><p>The impact has been immediate and rather dramatic. As you can see in Exhibit 4a below, German equities have significantly outperformed other European equities in recent weeks. Defence stocks have, as mentioned earlier, done particularly well and, as you can see below, so have stocks that are exposed to increased fiscal spending on infrastructure.</p>

<p>As far as bonds are concerned, not surprisingly, the yield on German 10-year bonds has risen (Exhibit 4b), with German yields now near the top of the range, post GFC.</p>

<p>--image--</p>

<p>--image2--</p>

<p>The shift in growth expectations (more growth upside risk in Europe vs. more growth downside risk in the US) has led to a sharply positive US 10-year yield beta-to-global equities, whereas the German 10-year yield beta-to-global equities remains negative (Exhibit 5).</p>

<p>--image3--</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#269;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#269;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#269;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#269;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>What can we assume, going forward?</h4><p>Whilst the incoming German government&rsquo;s attitude towards defence spending is radically different from the outgoing&rsquo;s with vast sums about to be spent on improving the German military&rsquo;s capabilities, it is important to remind yourself that the new fiscal package is not only about defence. Vast amounts of capital will be spent on other projects between now and 2035.</p>

<p>That said, if defence stocks hadn&rsquo;t already rallied so much, I would be inclined to include defence in a European portfolio structured for a world under Putin and Trump, but they have. At the very least, the easy money has already been made, hence why I am on the lookout for other opportunities.</p>

<p>At this point, it is important to reiterate the restrictions we are under as a fund manager. In order not to fall foul of various compliance issues, no company names will be mentioned in the following. I will instead mention various industries to focus on. You can then put two plus two together yourself.</p>

<p>An obvious winner is the engineering and construction industry, which is particularly big in France and Germany. There are even companies in this industry that are exposed to defence projects as well as non-defence projects, i.e., they could benefit from both sides.</p>

<p>A somewhat related opportunity is to be found in those European building materials companies that specialise in building materials that are used in infrastructure projects. And even better if those companies are also exposed to improving energy efficiency in public buildings. It is estimated that up towards one-third of the &euro;500 billion will be spent on that.</p>

<p>Improving the power grid in Germany is another part of the plan, and several companies, mostly German, stand to benefit from that. The problem for the industry is that it is heavily regulated with strict caps on profitability. However, the German regulator has indicated that to encourage more investments, those rules will most likely be relaxed. That should meaningfully improve profitability in the industry.</p>

<p>The shipping industry is the last industry I will mention in this context. Assuming the fiscal expansion in Germany leads to stronger GDP growth all over Europe (and it most likely will), shipping stands to benefit immensely. According to the research team at Goldman Sachs, a 1% increase in shipping volumes typically boosts EPS in the leading shipping firms by 3%.</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#270;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#270;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#270;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#270;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>Final few words</h4><p>I think I will stop here. I hope to have made the point that the German stimulus package is about a great deal more than increased defence spending, and I would strongly recommend for new money to be put to work in other industries than defence.</p>
</div><div><h4>By Niels Clemen Jensen</h4><p><strong>19 March 2025</strong></p></div></div></div>