diff --git a/2019-03/noteworthy/content/en_index.php b/2019-03/noteworthy/content/en_index.php
index d6a93c4..e580410 100644
--- a/2019-03/noteworthy/content/en_index.php
+++ b/2019-03/noteworthy/content/en_index.php
@@ -15,7 +15,8 @@
 <div class="container">
   <h1>New &amp; Noteworthy</h1>
   <p>
-    2019-03 release is Eclipse Foundation's third quarterly simultaneous release, available March 20, 2019.
+    2019-03 release is Eclipse Foundation's third quarterly simultaneous release with
+    <a href="https://projects.eclipse.org/releases/2019-03">seventy-five participating projects</a>, available March 20, 2019.
   </p>
   <p>
     Here are the new and noteworthy items of various projects in the 2019-03 release train:
@@ -23,8 +24,11 @@
   
   <!-- List of links to the new and noteworthy pages of projects -->
   <ul>
-  	<li><a href="https://www.eclipse.org/eclipse/news/4.11/">New features in Eclipse Platform, Java Development Tools (JDT), Plug-in Development Environment (PDE) and Equinox</a></li>
   	<li><a href="https://wiki.eclipse.org/OCL/New_and_Noteworthy/2019-03">New features in Eclipse OCL</a></li>
+    <li><a href="https://wiki.eclipse.org/EGit/New_and_Noteworthy/5.3">New features in Eclipse EGit</a></li>
+  	<li><a href="https://wiki.eclipse.org/JGit/New_and_Noteworthy/5.3">New features in Eclipse JGit</a></li>
+  	<li><a href="https://www.eclipse.org/eclipse/news/4.11/">New features in Eclipse Platform, Java Development Tools (JDT), Plug-in Development Environment (PDE) and Equinox</a></li>
+  	<li><a href="https://marketplace.eclipse.org/content/eclipse-wild-web-developer-web-development-eclipse-ide">New features in Eclipse Wild Web Developer</a></li>	
   	<li><a href="http://www.eclipse.org/Xtext/releasenotes.html#/releasenotes/2019/03/05/version-2-17-0">New features in Eclipse Xtext</a></li>	
   </ul>
 </div>
\ No newline at end of file
