diff --git a/releases/3.21/NewAndNoteworthy/defaultpaths.png b/releases/3.21/NewAndNoteworthy/defaultpaths.png
new file mode 100644
index 0000000..d0a194d
--- /dev/null
+++ b/releases/3.21/NewAndNoteworthy/defaultpaths.png
Binary files differ
diff --git a/releases/3.21/NewAndNoteworthy/index.html b/releases/3.21/NewAndNoteworthy/index.html
new file mode 100755
index 0000000..21fb591
--- /dev/null
+++ b/releases/3.21/NewAndNoteworthy/index.html
@@ -0,0 +1,8 @@
+<html>
+<head>
+<meta http-equiv="refresh" content="0; url=index.php" />
+</head>
+<body>
+<a href="index.php">This document has moved</a>
+</body>
+</html>
diff --git a/releases/3.21/NewAndNoteworthy/index.php b/releases/3.21/NewAndNoteworthy/index.php
new file mode 100755
index 0000000..8a48a07
--- /dev/null
+++ b/releases/3.21/NewAndNoteworthy/index.php
@@ -0,0 +1,28 @@
+<?php  																														require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/nav.class.php"); 	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/menu.class.php"); 	$App 	= new App();	$Nav	= new Nav();	$Menu 	= new Menu();		include($App->getProjectCommon());    # All on the same line to unclutter the user's desktop'
+$pageKeywords	= "";
+$pageAuthor		="Ugur Yildirim @ Eteration A.S.";
+
+$root = $_SERVER['DOCUMENT_ROOT'];
+require_once ($root . '/webtools/common.php');
+
+# Generate the web page
+// Load the XML source
+$xml = DOMDocument::load('index.xml');
+
+//Set the page title
+$xpath = new DOMXPath($xml);
+$titleNode = $xpath->query("/release/attribute::name")->item(0);
+$pageTitle = ($titleNode != null) ? "Web Tools Platform " . $titleNode->nodeValue . " News" : "eclipse.org webtools page";
+
+// Load the XSL source
+$xsl = DOMDocument::load($root . '/webtools/development/news/phoenix_noteworthy.xsl');
+
+// Configure the transformer
+$proc = new XSLTProcessor;
+$proc->importStyleSheet($xsl); // attach the xsl rules
+
+$html = $proc->transformToXML($xml);
+$html .= $wtpTopButtons;
+
+$App->generatePage($theme, $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
+?>
diff --git a/releases/3.21/NewAndNoteworthy/index.xml b/releases/3.21/NewAndNoteworthy/index.xml
new file mode 100755
index 0000000..1a710ac
--- /dev/null
+++ b/releases/3.21/NewAndNoteworthy/index.xml
@@ -0,0 +1,75 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<?xml-stylesheet type="text/xsl" href="../../../development/news/phoenix_noteworthy.xsl"?>
+<!-- Run as XSL Transformation to preview -->
+<release
+	name="3.21"
+	root="../../.."
+>
+	<header>
+		 WTP 3.21 is primarily a bug fix and polishing release, particularly around late changes made in 2020-06.
+		 It is available as part of the
+		 <a href="https://wiki.eclipse.org/Simultaneous_Release">Eclipse IDE</a>
+		 <a href="https://wiki.eclipse.org/Category:SimRel-2021-03">2021-03</a>
+		 (March 17th, 2021).
+		 <a href="http://download.eclipse.org/webtools/downloads/">Download</a>
+				it now!
+	</header>
+	<component name="Source Editing">
+		<item title="Jakarta EE Schemas">
+			<description>
+				The Jakarta EE 9 Schemas are now included in the XML Catalog.
+				<em>Note: While many of the schemas are cached out-of-the-box, the main
+				function of the XML Catalog is to help find them. The Cache is
+				a separate function.</em>
+				<br />
+				<br />
+				<img src="jakartaschemas.png" width="589" alt="Schemas shown on the XML Catalog preference page"/>
+			</description>
+		</item>
+		<item title="Simplified XML Wizard">
+			<description>
+				The New XML File wizard has been simplified and streamlined. It no longer makes
+				you think about whether you want to use a DTD or Schema separately, and selection
+				of either from the workspace and XML Catalog now offers a search field.
+				<br />
+				<br />
+				<img src="xmlwizard1.png" width="451" alt="The wizard page for choosing a DTD/Schema or Template"/>
+				<img src="xmlwizard2.png" width="451" alt="Searching the workspace"/>
+				<img src="xmlwizard3.png" width="451" alt="Searching the catalog"/>
+			</description>
+		</item>
+		<item title="JSON Typing preference page">
+			<description>
+				For fans of editing JSON in Eclipse who don't feel like they need
+				<em>too</em>
+				much help, there's now a <b>Typing</b> preference page to help
+				disable those assists.
+				<br />
+				<br />
+				<img src="json_typing.png" width="465" alt="The new JSON Typing preference page"/>
+			</description>
+		</item>
+	</component>
+	<component name="Java EE">
+		<item title="Modernized default paths">
+			<description>
+				When creating Dynamic and Static web projects, the suggested content
+				paths and Java Source Folder path have been changed. As always, users
+				can enter any valid value of their liking. 
+				<br />
+				<br />
+				<img src="defaultpaths.png" width="674" alt="The new default paths in the wizards"/>
+			</description>
+		</item>
+	</component>
+	<footer>
+		Summaries for earlier releases:
+		<ul>
+			<li>
+				<a
+					href="../../../development/news/"
+				>Full summaries for earlier milestones and releases.</a>
+			</li>
+		</ul>
+	</footer>
+</release>
diff --git a/releases/3.21/NewAndNoteworthy/jakartaschemas.png b/releases/3.21/NewAndNoteworthy/jakartaschemas.png
new file mode 100644
index 0000000..70e50a7
--- /dev/null
+++ b/releases/3.21/NewAndNoteworthy/jakartaschemas.png
Binary files differ
diff --git a/releases/3.21/NewAndNoteworthy/json_typing.png b/releases/3.21/NewAndNoteworthy/json_typing.png
new file mode 100644
index 0000000..4c351b4
--- /dev/null
+++ b/releases/3.21/NewAndNoteworthy/json_typing.png
Binary files differ
diff --git a/releases/3.21/NewAndNoteworthy/xmlwizard1.png b/releases/3.21/NewAndNoteworthy/xmlwizard1.png
new file mode 100644
index 0000000..aad4487
--- /dev/null
+++ b/releases/3.21/NewAndNoteworthy/xmlwizard1.png
Binary files differ
diff --git a/releases/3.21/NewAndNoteworthy/xmlwizard2.png b/releases/3.21/NewAndNoteworthy/xmlwizard2.png
new file mode 100644
index 0000000..7d8be94
--- /dev/null
+++ b/releases/3.21/NewAndNoteworthy/xmlwizard2.png
Binary files differ
diff --git a/releases/3.21/NewAndNoteworthy/xmlwizard3.png b/releases/3.21/NewAndNoteworthy/xmlwizard3.png
new file mode 100644
index 0000000..f1b1d07
--- /dev/null
+++ b/releases/3.21/NewAndNoteworthy/xmlwizard3.png
Binary files differ
diff --git a/releases/3.21/index.html b/releases/3.21/index.html
new file mode 100755
index 0000000..9a67e7f
--- /dev/null
+++ b/releases/3.21/index.html
@@ -0,0 +1,8 @@
+<html>
+<head>
+<meta http-equiv="refresh" content="0; url=index.php" />
+</head>
+<body>
+<a href="index.php">This document has moved</a>
+</body>
+</html>
diff --git a/releases/3.21/index.php b/releases/3.21/index.php
new file mode 100755
index 0000000..44a28f4
--- /dev/null
+++ b/releases/3.21/index.php
@@ -0,0 +1,28 @@
+<?php  																														require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/nav.class.php"); 	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/menu.class.php"); 	$App 	= new App();	$Nav	= new Nav();	$Menu 	= new Menu();		include($App->getProjectCommon());    # All on the same line to unclutter the user's desktop'
+$pageKeywords	= "";
+$pageAuthor		="Nick Boldt @ Red Hat";
+
+$root = $_SERVER['DOCUMENT_ROOT'];
+require_once ($root . '/webtools/common.php');
+
+# Generate the web page
+// Load the XML source
+$xml = DOMDocument::load('index.xml');
+
+//Set the page title
+$xpath = new DOMXPath($xml);
+$titleNode = $xpath->query("/html/head/title")->item(0);
+$pageTitle = ($titleNode != null) ? $titleNode->nodeValue : "eclipse.org webtools page";
+
+// Load the XSL source
+$xsl = DOMDocument::load($root . '/webtools/wtpnova.xsl');
+
+// Configure the transformer
+$proc = new XSLTProcessor;
+$proc->importStyleSheet($xsl); // attach the xsl rules
+
+$html = $proc->transformToXML($xml);
+$html .= $wtpTopButtons;
+
+$App->generatePage($theme, $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
+?>
diff --git a/releases/3.21/index.xml b/releases/3.21/index.xml
new file mode 100755
index 0000000..829d90e
--- /dev/null
+++ b/releases/3.21/index.xml
@@ -0,0 +1,99 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<?xml-stylesheet type="text/xsl" href="../../wtpphoenix.xsl"?>
+<html>
+	<head>
+    	<meta name="root" content="../../../" />
+		<title>eclipse web tools platform release 3.21</title>
+	</head>
+	<body>
+		<h1>WTP 3.21</h1>
+		<h2>Status as of 2021-03-17</h2>
+		<p>
+			WTP 3.21 was officially released on March 17, 2021, as part of the
+			Eclipse IDE 2021-03.
+			Users of Eclipse should use the 2021-03 Update Site,
+			<a href="https://download.eclipse.org/releases/2021-03/">https://download.eclipse.org/releases/2021-03/</a>
+			,
+			to install WTP 3.21, or
+			<a href="https://download.eclipse.org/releases/latest/">https://download.eclipse.org/releases/latest/</a>
+			to always have the latest. The next release, WTP 3.22, will be part of
+			the simultaneous release in June.
+		</p>
+		<ul>
+					<li>Download WTP as part of a complete Eclipse <a href="https://www.eclipse.org/downloads/packages/release/2021-03/r">package</a>. WTP is featured in the Eclipse IDE for <a href="https://www.eclipse.org/downloads/packages/release/2021-03/r/eclipse-ide-enterprise-java-developers">Enterprise Java</a>.</li>
+					<li>Read the <a href="https://wiki.eclipse.org/Category:New_Help_for_Old_Friends">adopter migration documentation</a></li>
+					<li>Find WTP in the <a href="https://marketplace.eclipse.org/user/nitind/listings">Eclipse Marketplace</a></li>
+<!--
+					<li><a href="http://download.eclipse.org/webtools/downloads/">Download</a> the final WTP 3.21 built P2 Update Site now</li>
+          <li>Browse the <a href="http://help.eclipse.org/2019-09/topic/org.eclipse.wst.doc.user/topics/overview.html?cp=96" target="_top">Web Tools Platform User Guide</a></li>
+-->
+					<li>Read the <a href="https://wiki.eclipse.org/WTP_FAQ">FAQ</a></li>
+					<li>Read the <a href="https://wiki.eclipse.org/WTP_Tomcat_FAQ">WTP and Apache Tomcat FAQ</a></li>
+            <!--  <h3><a href="contributorrecognition.html">Recognition of Contributors</a></h3> -->
+            <!--
+             <h2>Press Coverage for WTP 3.21</h2>
+             <h3><a href=""  target="_top">title</a>, <i>source</i></h3>
+             -->
+		</ul>
+	<!--
+		<h2>
+			<a name="new-noteworthy" />
+			New and Noteworthy
+		</h2>
+		<table border="0" cellpadding="10" cellspacing="10" style="border-spacing:10px; border-collapse: separate">
+			<tbody>
+				<tr>
+					<td align="right" valign="top" width="15%">
+						<b>Miscellaneous</b>
+					</td>
+					<td align="left" valign="top" width="85%">
+					The Snippets View and JSP Java Search functionalities have been restored. The latter also has
+					improved performance.
+					</td>
+				</tr>
+			</tbody>
+		</table>
+	-->
+		<h2><a name="what-is-fixed" />New &amp; Noteworthy</h2>
+		Check out what's <a href="NewAndNoteworthy/">New and Noteworthy</a> in this release
+		<h2><a name="what-is-fixed" />What is Fixed</h2>
+		<p>Fixed <a href="https://bugs.eclipse.org/bugs/buglist.cgi?classification=WebTools&amp;query_format=advanced&amp;target_milestone=3.21&amp;target_milestone=3.21%20M1&amp;target_milestone=3.21%20M2&amp;target_milestone=3.21%20M3&amp;target_milestone=3.21%20RC1&amp;target_milestone=3.21%20RC2&amp;target_milestone=3.21.0">list</a>/<a
+		href="https://bugs.eclipse.org/bugs/report.cgi?x_axis_field=bug_severity&amp;y_axis_field=product&amp;no_redirect=1&amp;query_format=report-table&amp;classification=WebTools&amp;target_milestone=3.21&amp;target_milestone=3.21+M1&amp;target_milestone=3.21+M2&amp;target_milestone=3.21+M3&amp;target_milestone=3.21+RC1&amp;target_milestone=3.21+RC2&amp;target_milestone=3.21.0&amp;format=table&amp;action=wrap">table</a>.</p>
+		<p>Adopters should consult the <a href="https://wiki.eclipse.org/Category:New_Help_for_Old_Friends">migration</a> information for potentially breaking changes.</p>
+
+		<h2>
+			<a name="reported-problems" />
+			Reported and Known Problems
+		</h2>
+		<p>
+			All reported problems are recorded in the Eclipse Bugzilla
+			system under:
+			<ul>
+				<li>
+					Classification =
+					<code>WebTools</code>
+				</li>
+				<li>
+					Status =
+					<code>NEW</code>
+					or
+					<code>ASSIGNED</code>
+					or
+					<code>REOPENED</code>
+				</li>
+			</ul>
+		</p>
+		<a href="https://bugs.eclipse.org/bugs/buglist.cgi?bug_status=NEW&amp;bug_status=ASSIGNED&amp;bug_status=REOPENED&amp;bug_status=UNCONFIRMED&amp;classification=WebTools&amp;order=bugs.bug_id%20desc">All reported problems</a>
+		<p>Check for suggested workarounds in the bug report comments. Remember: <b>bugs that aren't reported have little chance of being fixed.</b><!--Here are more specific items:--></p>
+
+		<!--
+		<table cellpadding="3%" >
+
+		<tr>
+			<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=number">number</a></td>
+			<td> title </td>
+		</tr>
+		</table>
+		-->
+	</body>
+</html>
