diff --git a/elections/2021/Board Elections/2021/mader.jpg b/elections/2021/Board Elections/2021/mader.jpg
new file mode 100644
index 0000000..9395304
--- /dev/null
+++ b/elections/2021/Board Elections/2021/mader.jpg
Binary files differ
diff --git a/elections/2021/Board Elections/2021/mader.xml b/elections/2021/Board Elections/2021/mader.xml
new file mode 100755
index 0000000..ca9744e
--- /dev/null
+++ b/elections/2021/Board Elections/2021/mader.xml
@@ -0,0 +1,133 @@
+<!-- id is the same as the file name without the extension
+     type is one of "committer" or "add-in-provider" -->
+<boardmember id="mader" type="committer">
+
+	<name>Thomas Mäder</name>
+
+	<title>Dipl. Informatik Ing. ETH</title>
+
+	<!-- Name of the file containing the image of the candidate; location relative to this file.  -->
+	<image>mader.jpg</image>
+
+	<!-- eMail address will be modified before it is included on a webpage so that robots will not harvest it. -->
+	<email>thomas@devotek-it.ch</email>
+
+	<phone>+41 78 888 30 29</phone>
+
+	<!-- How do we contact you? e.g. postal address -->
+	<contact>
+		Grundgasse 2
+    9500 Wil
+		Switzerland
+	</contact>
+
+	<!-- What do you do with eclipse? -->
+	<eclipse_affiliation>I'm a committer emeritus of Eclipse IDE and an active committer on the Eclipse Theia and Che projects.</eclipse_affiliation>
+
+	<!-- Feel free to include html tags and what-not between the CDATA tags. -->
+	<vision>
+		<![CDATA[
+		<p>
+		Dani Megert, who passed away recently, had been my colleague at Object Technology Intl. 20 years ago when we set out to revolutionize the IDE market.
+		The election to replace him as a committer representative on the board of the Eclipse foundation got me thinking that I might well have what it takes
+		to serve in that function.
+		</p>
+		<p>
+		Having been around since the beginning, I understand the ins and outs of Open Source licensing and governance. I know many of the people
+		involved with the foundation, including former board members who I'm sure would be willing to help me navigate the politics of the
+		Eclipse board. But I haven't been involved in Eclipse Foundation administration directly. This means I owe no-one any favours and I have no axes to grind.
+		I work for Red Hat/IBM and I would probably best represent the committers that work for a large corporation, but as they like to say in Twitter bios:
+		"My opinions are my own, not my employers". Ask anyone who knows me.
+		</p>
+		<p>
+		The Eclipse Foundation has traditionally been a place for businesses to cooperate more than individual contributors. That is OK. But there are areas
+		where the priorities of the individual contributors are not necessarily the same as those of organisations.
+		</p>
+		<p>
+		We want our individual contributions to be recognized. When I'm in a job interview I want to be able to point to my contributions to an Eclipse project and say:
+		"Look! I did that". When I contribute great value to a project, I expect my role and influence in that project to grow accordingly.
+		</p>
+		<p>
+		We want to write software, not CQs. As a contributor I would want the Eclipse Foundation to make it as simple as possible to run a project, while maintaining
+		the secret "business-friendly" sauce. Recent improvements in tooling allowing projects to self-certify their license compliance are a good step in the direction
+		I am talking about here.
+		</p>
+		<p>
+		As software is eating the world, we are the snout of that particular crocodile. Our work might end up in a pacemaker, it might guide a missile into its target,
+		or it might determine the outcome of an election. Corporations cannot be morally responsible. We as individuals shoulder the moral credit and the blame.
+    Because the structures and rules we give our software development organisation will shape what they will create, we as the creators or that software
+    are entitled to having a voice in making those rules and structures. I am aware this is a difficult topic and don't expect any ready-made recipes
+    from me, but I believe it's something we as an industry need to address.
+		</p>
+
+
+
+		<p>
+		Who I am:
+		</p>
+		<p>
+		<p>
+		I've known the EF since the start, know many of the senior players. I have people I can rely on to help me navigate the board politics.
+		I am not beholden with anyone. I don't have an axe to grind or an agenda beyond pursuing the interests of the committers. Like in a twitter bio,
+		my opinions are my own, not my employers.
+		<p>
+		<p>
+		I am actually an active committer on multiple Eclipse projects, not a manager or "head of" or sth. I write code every day.
+		<p>
+		<p>
+		Why I run:
+		</p>
+		<p>
+		When Dani Megert died, I started thinking about the Committer Representative and decided I have unique assets to bring to that table.
+		</p>
+		=> listening first!
+
+		My Story
+		My Topics
+
+
+		Organisations are more evil than the people they are made up of
+		Software is eating the world: we as individuals want to make the world a good place.
+		International, unfettered cooperation.
+
+		We want to be recognized for our contributions, beyond employment at a particular megacorp
+
+		We are interested in contributing easily.
+		=> easy, automated processes
+		=> maximum freedom while keeping the Eclipse secret sauce
+
+		The EF has always been biased towards businesses cooperating, not individuals. It's easy for a business to consume EPL stuff because of the tight
+		IP policy
+
+		Why you should vote for me
+
+		
+
+		]]>
+	</vision>
+
+	<!-- Tell us a little bit about yourself. -->
+	
+	<bio>
+	<![CDATA[
+	<p>
+		I am one of the IBM engineers that created the Eclipse IDE before the Eclipse foundation even existed. At IBM's Object Technology Intl.
+		subsidiary, I also contributed to what is the Eclipse Open J9 Java VM today. After having spent some years working in more business-oriented settings
+		and an ill-fated online file storage startup, I am now a principal software engineer at Red Hat and an active committer to the Eclipse Theia
+		and Eclipse Che online IDE projects.
+	</p>
+	<p>
+		Away from work, I enjoy playing golf, ice hockey and tennis. In summer, you'll find me hiking in the mountains. I tinker with software synthesizers
+		in my home studio and I cook a pretty good aloo gobi.
+		I live in Switzerland.
+	</p>
+	<p>
+		Follow me on Twitter (@tsmaeder).
+	</p>
+	]]>
+	</bio>
+
+	<!-- Who do you work for? -->
+	<affiliation>Red Hat</affiliation>
+
+</boardmember>
diff --git a/elections/2021/Board Elections/2021/sutter.jpg b/elections/2021/Board Elections/2021/sutter.jpg
new file mode 100644
index 0000000..31e04f7
--- /dev/null
+++ b/elections/2021/Board Elections/2021/sutter.jpg
Binary files differ
diff --git a/elections/2021/Board Elections/2021/sutter.xml b/elections/2021/Board Elections/2021/sutter.xml
new file mode 100644
index 0000000..de75c93
--- /dev/null
+++ b/elections/2021/Board Elections/2021/sutter.xml
@@ -0,0 +1,81 @@
+<!-- id is the same as the file name without the extension
+     type is one of "committer" or "add-in-provider" -->
+<boardmember id="sutter" type="committer">
+
+	<name>Kevin Sutter</name>
+
+	<title>STSM, Jakarta EE and MicroProfile Architect</title>
+
+	<!-- Name of the file containing the image of the candidate; location relative to this file.  -->
+	<image>sutter.jpg</image>
+
+	<!-- eMail address will be modified before it is included on a webpage so that robots will not harvest it. -->
+	<email>sutter@us.ibm.com, kwsutter@gmail.com</email>
+
+	<phone>507-253-3620 (work)</phone>
+
+	<!-- How do we contact you? e.g. postal address -->
+    <!-- work -->
+	<contact> <![CDATA[
+    IBM Rochester
+    Hwy 52 North and 37th Street 
+    Rochester, MN   55901
+]]>
+    </contact>
+    
+	<!-- What do you do with eclipse? -->
+	<eclipse_affiliation> <![CDATA[
+    <p>    
+    Release Lead for Jakarta EE 9 and 9.1<br>
+    Co-lead of <a href="https://projects.eclipse.org/projects/ee4j.jakartaee-platform/who" target="_blank">Jakarta EE Platform project</a><br>
+    Member of <a href="https://projects.eclipse.org/projects/ee4j/pmc" target="_blank">EE4J (Jakarta EE) PMC</a><br>
+    Member of <a href="https://jakarta.ee/committees/specification/" target="_blank">Jakarta EE Specification Committee/a><br>
+    Participant of <a href="https://jakarta.ee/committees/steering" target="_blank">Jakarta EE Steering Committee</a><br>
+    Eclipse EE4J Committer and Project Lead on <a href="https://accounts.eclipse.org/users/ksutter#tab-projects" target="_blank">several projects</a><br>
+    Member of <a href="https://docs.google.com/spreadsheets/d/11Bq3hmTmXFlMQIwNWHz5Qul_33CpLhWfX1q5uWeb4YE/edit#gid=0" target="_blank">MicroProfile Working Group</a><br>
+    Co-lead of <a href="https://projects.eclipse.org/projects/technology.microprofile/who" target="_blank">MicroProfile project</a><br>
+	</p>
+]]>
+
+    </eclipse_affiliation>
+
+	<!-- Feel free to include html tags and what-not between the CDATA tags. -->
+	<vision>
+		<![CDATA[
+	 <p>	
+    I have been the IBM alternate for the Eclipse Board of Directors for the past several months.
+    While participating in these meetings, I have noticed a lack of technical diversity on the Board.
+    Although the Board is very well represented by several areas across the Eclipse Foundation, the Enterprise Java space is lacking sufficient representation --
+    especially with Enterprise Java now having the largest set of committers.
+    With my broad background and experience on the Jakarta EE and MicroProfile Working Groups and Projects at Eclipse, I believe that I can fill that void and well represent Enterprise Java on the Board.
+	</p>
+]]>
+	</vision>
+
+	<!-- Tell us a little bit about yourself. -->
+
+	<bio>
+<![CDATA[
+ <p>
+    Participating on the JCA (J2EE Connector Architecture) expert group back in 2001 timeframe was my first experience with Enterprise Java.
+    My first experience with open-source development was with OpenJPA at the Apache Foundation in 2006.
+    From these early experiences grew my association and appreciation of true open-source development.
+</p>
+ <p>    
+    Over the years, I continued to explore new areas of Enterprise Java, eventually becoming IBM's representative on the Java EE Platform specification.
+    As Java EE started to quiet down, the need for continued innovation in the Enterprise Java space was very evident.
+    And, from that void grew MicroProfile.
+    After much investigation and consideration, the Eclipse Foundation was chosen as the landing spot for this new MicroProfile project.
+    And, as Oracle was looking to contribute Java EE to an open-source environment, the Eclipse Foundation became a logical choice.
+    I was involved with the initial creation of both of these efforts at Eclipse.
+</p>
+ <p>    
+    As the affiliation section outlines, I am still very involved with both of the Jakarta EE and MicroProfile Working Groups and I look forward to helping them both succeed.
+</p>
+]]>
+	</bio>
+
+	<!-- Who do you work for? -->
+	<affiliation>IBM</affiliation>
+
+</boardmember>
