
<div class='article-page-content__container'>
<div class='article-page-content__container__left'><h3>Ceramic Heat Dissipation Substrates - an alternative to water-based cooling systems </h3><h4>29 April 2024</h4><div class='category-icon'>Research</div><div class='article-page-content__container__left__summary'><p><em>"</em>When the well is dry, we know the worth of water.<em>"</em></p><p>Benjamin Franklin</p></div><h5>By Niels Clemen Jensen</h5><div class='article-page-content__container__left__links'><a download='ceramic-heat-dissipation-substrates' href='/Content/Downloads/ARP/ARP240429.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/6619201cf9d98394bf9d10f1_iStock-1475998284_705x414.jpg#237;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#359;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#359;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#359;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#359;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>Why this paper?</h4><p>In our spring webinar earlier this month, I made the case that some of the new technologies on the block &ndash; e.g. AI and cryptocurrencies &ndash; use excessive amounts of electricity and water, and that such an extreme amount is clearly unsustainable. The underlying reason for the use of all that water is the extraordinary amount of heat being generated by all those servers supporting the new technologies, which has created a need for more cooling.</p>

<p>This paper is my response to the ARP+ subscriber who, at the webinar, asked if there are any realistic alternatives to water when it comes to cooling systems. I am admittedly still midstream in my research on the topic, i.e. expect more from me over the next several months. That said, today, I will look at what appears to be a very promising alternative to water-based cooling systems &ndash; a technology called ceramic heat dissipation substrates which is largely controlled by Japanese companies.</p>
</div><div class='article-page-content__container__right__item' data-alt-text='<p><strong>Exhibit 1: Water consumption by Microsoft, Google and Meta (Billion litres per year)</strong><br />
<em>Source: </em><a href="https://think.ing.com/articles/data-centres-growth-in-water-consumption-needs-more-attention/#:~:text=This%20is%20largely%20driven%20by,water%20consumption%20of%20100%2C000%20homes"><em>ING</em></a></p>
' data-image='/Content/Images/662fcd2f36cc30d46dd0c2db_Picture2.png#360;slide-image;;' data-alt-text2= '<p><strong>Exhibit 2: Data centre cooling market</strong><br />
<em>Source: </em><a href="https://www.marketsandmarkets.com/Market-Reports/data-center-cooling-solutions-market-1038.html?gad_source=1&amp;gclid=EAIaIQobChMIk9iIi6HVhQMVGYtoCR1NCgzwEAAYAiAAEgLO7_D_BwE"><em>marketsandmarkets.com</em></a></p>
' data-image2= '/Content/Images/662fcdb07b3a8521e46c2748_Picture3.png#360;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#360;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#360;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>Why we need to introduce different cooling systems</h4><p>Water is not only a critical resource for human survival; it is also an increasingly scarce resource. Wherever you turn, access to freshwater is waning. This has been a problem for years but, suddenly, with the introduction of AI, cryptocurrencies, EVs and other new technologies, most of which generate excessive amounts of heat, the issue has, in no time, moved from the back burner to the front burner.</p>

<p>As I pointed out in our recent webinar, data centres worldwide use one billion litres of water <em>every day</em>, and new data centres continue to open every day. Even a medium-sized data centre uses as much water as 100,000 homes.</p>

<p>Those companies that use generative AI most frequently are also the heaviest users of water and, here, Google is a clear #1 (Exhibit 1). AI is run on servers in data centres, and many of those data centres are located in areas where water sources are scarce. In 2022, 23% of Microsoft&rsquo;s and 18% of Google&rsquo;s freshwater withdrawals were from areas suffering from water stress (source: ING).</p>

<p>--image--</p>

<p>It is also worth noting that if Google were to integrate generative AI into every search on its website, both electricity and water consumption would multiply, and the company would use about the same amount as is used in the entire country of Ireland. Therefore, something <em>must </em>be done. The current trend is very clearly unsustainable. &nbsp; &nbsp;</p>

<p>The global data centre cooling market is growing rapidly. According to <a href="https://www.marketsandmarkets.com/Market-Reports/data-center-cooling-solutions-market-1038.html?gad_source=1&amp;gclid=EAIaIQobChMIk9iIi6HVhQMVGYtoCR1NCgzwEAAYAiAAEgLO7_D_BwE">marketsandmarkets.com</a>, it is expected to grow from $12.7 Bn in 2023 to $29.6 Bn in 2030, and nowhere is it expected to grow faster than in Asia (Exhibit 2). The problem is relatively simple to understand. If water is used in all those cooling systems, it is only a question of time before we don&rsquo;t have enough water for the most basic needs for humanity. One could in fact argue that is already the case in parts of the world.</p>

<p>--image2--</p>

<p>In that context, I should point out that not only is freshwater becoming increasingly scarce, but the authorities have, in many countries, delivered an embarrassingly poor end-product in terms of the infrastructure required to handle the growing demand for water. And nowhere is the infrastructure more outdated than in the country with most datacentres &ndash; USA.</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#361;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#361;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#361;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#361;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>The solution?</h4><p>A very promising (but not the only) alternative to water-based cooling systems appears to be so-called ceramic heat dissipation substrates &ndash; designed to dissipate the heat generated by the power module in question. Now, ceramic substrates can be used for various purposes &ndash; in the auto industry (to be used in EVs), in the telecommunications and technology industries or for general industrial purposes. Of those four end-markets, the least attractive is probably general industry (lowest expected growth rate), whereas telecom and IT should grow the fastest.</p>

<p>As mentioned already, the need for cooling systems is expected to grow the fastest in Asia, and the market for ceramic substrates for use as heat dissipators in optical transceivers should grow particularly fast &ndash; over 50% annually according to Goldman Sachs (GS).</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#362;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#362;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#362;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#362;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>Final comments</h4><p>The most compelling argument in favour of companies that produce ceramic substrates for use as heat dissipators in optical transceivers is the fact that it requires many years of experience as to how to work with ceramics to successfully go for this market opportunity. It is nearly impossible for any non-ceramic supplier to enter the market at this stage.</p>

<p>Who the eventual winner(s) will be is probably still too early to project; however, investors&rsquo; job is made easier by the fact that the industry consists of only a handful of companies most of which are Japanese.</p>
</div><div><h4>By Niels Clemen Jensen</h4><p><strong>29 April 2024</strong></p></div></div></div>