diff --git a/css/all.css b/css/all.css
index c761a4f..2967308 100755
--- a/css/all.css
+++ b/css/all.css
@@ -7634,6 +7634,141 @@
   font-weight: normal;
   font-style: normal;
 }
+.round-icon-block-tab {
+  border-radius: 10px;
+  background: #eeeeee;
+  padding: 5px;
+  display: block;
+  float: left;
+  margin-right: 8px;
+}
+.round-icon-block-tab img {
+  margin: 0px auto;
+  max-width: 20px;
+  width: 20px;
+  display: block;
+}
+
+.continent {
+  display: block;
+  float: left;
+}
+
+.meet-groups {
+  padding: 30px;
+}
+.meet-groups ul {
+  margin-left: 0px;
+  padding-left: 0px;
+  margin-top: 5px;
+}
+.meet-groups ul li {
+  list-style: none;
+  margin-bottom: 10px;
+}
+.meet-groups ul li a {
+  font-size: 16px;
+  color: #555555;
+}
+.meet-groups ul li a:hover {
+  color: red;
+}
+
+#meetup-groups li a {
+  clear: both;
+  overflow: hidden;
+}
+#meetup-groups .active a {
+  clear: both;
+  overflow: hidden;
+}
+#meetup-groups .active .continent {
+  font-weight: bold;
+  padding-top: 1px;
+}
+
+.sub-head-events {
+  font-size: 24px;
+  margin-top: 20px;
+  margin-bottom: 30px;
+}
+
+.margin-headline {
+  margin-top: 60px !important;
+}
+
+.new-event {
+  margin-top: 20px;
+  margin-bottom: 60px;
+  padding-bottom: 20px;
+  border-bottom: 2px #e1e1e1 dotted;
+}
+.new-event .news-date {
+  font-size: 15px;
+  color: #888;
+}
+.new-event .news-date:before {
+  content: "•";
+  font-size: 14px;
+  color: #ed1c24;
+  display: inline-block;
+  margin-right: 5px;
+}
+.new-event p {
+  margin-top: 15px;
+}
+
+.round-icon-block {
+  border-radius: 10px;
+  background: #eeeeee;
+  padding: 15px;
+  display: block;
+}
+.round-icon-block img {
+  margin: 0px auto;
+  max-width: 100px;
+  width: 100px;
+  display: block;
+}
+.round-icon-block p {
+  text-align: center;
+  margin-top: 10px;
+}
+
+@media (max-width: 767px) {
+  .col-md-4 {
+    margin-top: 10px;
+    margin-bottom: 40px;
+  }
+
+  .margin-headline {
+    margin-top: 15px;
+  }
+
+  .meet-groups {
+    padding-top: 0px;
+    padding-bottom: 0px;
+  }
+
+  .continent {
+    font-size: 16px !important;
+  }
+}
+@media (max-width: 992px) {
+  .col-md-4 {
+    margin-top: 10px;
+    margin-bottom: 40px;
+  }
+
+  .margin-headline {
+    margin-top: 15px;
+  }
+
+  .meet-groups {
+    padding-top: 0px;
+    padding-bottom: 0px;
+  }
+}
 .syntaxhighlighter {
   padding: 10px 5px;
   border-radius: 6px;
@@ -8341,11 +8476,6 @@
   color: #888;
 }
 
-.news-date {
-  font-size: 15px;
-  color: #888;
-}
-
 section.news-section a > i {
   opacity: 0;
   color: #888;
diff --git a/download.html b/download.html
index 5c8c2f0..420065d 100644
--- a/download.html
+++ b/download.html
@@ -346,13 +346,9 @@
                                         </li>
 
                                         <li class="divider"></li>
-                                        <li role="presentation" class="submenu-header">Events & Groups</li>
-                                        <li><a href="/events.html">Upcoming Events</a></li>
-                                        <li><a href="https://www.meetup.com/Bay-Area-In-Memory-Computing/" target="_blank" rel="noopener">Ignite Bay Area Meetup <i class="fa fa-external-link" style="padding-left:5px;"></i></a></li>
-                                        <li><a href="https://www.meetup.com/NYC-In-Memory-Computing-Meetup/" target="_blank" rel="noopener">Ignite New York Meetup <i class="fa fa-external-link" style="padding-left:5px;"></i></a></li>
-                                        <li><a href="http://www.meetup.com/Apache-Ignite-London" target="_blank" rel="noopener">Ignite London Meetup <i class="fa fa-external-link" style="padding-left:5px;"></i></a></li>
-                                        <li><a href="https://www.meetup.com/Moscow-Apache-Ignite-Meetup/" target="_blank" rel="noopener">Ignite Moscow Meetup <i class="fa fa-external-link" style="padding-left:5px;"></i></a></li>
-                                        <li><a href="https://vk.com/apacheignite" target="_blank" rel="noopener">Ignite VK Group (Russian) <i class="fa fa-external-link" style="padding-left:5px;"></i></a></li>
+                                        <li role="presentation" class="submenu-header">Events &amp; Groups</li>
+                                        <li><a href="/events.html">Apache Ignite Events</a></li>
+                                        <li><a href="/meetup-groups.html">Community Groups</i></a></li>
                                     </ul>
                                 </li>
                                 <li class="dropdown" style="cursor: pointer;">
diff --git a/events.html b/events.html
index fda7d09..7465091 100644
--- a/events.html
+++ b/events.html
@@ -47,10 +47,17 @@
 
     <main id="main" role="main" class="container">
         <section id="news" class="page-section">
-            <h1 class="first">Meetups & Events</h1>
-            <div class="col-sm-12 col-md-12 col-xs-12" style="padding-left: 0; padding-right: 20px;">
-
-				<section id="how-to-boost-and-scale-postgres-from-sharding-to-in-memory-data-grids" class="page-section news-section">
+            <h1 class="first">Upcoming Apache Ignite Events</h1>	
+			
+<div class="row new-event margin-headline">
+	<div class="col-xl-2 col-md-2 hidden-sm hidden-xs">
+		<div class="round-icon-block">
+			<img src="images/conferences.svg" alt="Conference">
+			<p>Conference</p>
+		</div>
+	</div>
+	<div class="col-xl-10 col-md-10 col-sm-12">
+			<section id="how-to-boost-and-scale-postgres-from-sharding-to-in-memory-data-grids">
                     <div><h3 style="display:inline-block;">How to boost and scale Postgres - from sharding to in-memory data grids
                         <a href="/events.html#how-to-boost-and-scale-postgres-from-sharding-to-in-memory-data-grids"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -78,9 +85,18 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>				
-				
-				<section id="in-memory-computing-essentials-for-software-engineers" class="page-section news-section">
+                </section>		
+	</div>
+</div>
+<div class="row new-event margin-headline">
+	<div class="col-xl-2 col-md-2 hidden-sm hidden-xs">
+		<div class="round-icon-block">
+			<img src="images/conferences.svg" alt="Conferences">
+			<p>Conference</p>
+		</div>
+	</div>
+	<div class="col-xl-10 col-md-10 col-sm-12">
+			<section id="in-memory-computing-essentials-for-software-engineers">
                     <div><h3 style="display:inline-block;">In-Memory Computing Essentials for Software Engineers
                         <a href="/events.html#in-memory-computing-essentials-for-software-engineers"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -108,12 +124,18 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>					
-				
-				
-				
-				
-				<section id="in-memory-computing-essentials-for-java-developers" class="page-section news-section">
+                </section>		
+	</div>
+</div>			
+<div class="row new-event margin-headline">
+	<div class="col-xl-2 col-md-2 hidden-sm hidden-xs">
+		<div class="round-icon-block">
+			<img src="images/meetup.svg" alt="Meetup Logo">
+			<p>Meetups</p>
+		</div>
+	</div>
+	<div class="col-xl-10 col-md-10 col-sm-12">
+			<section id="in-memory-computing-essentials-for-java-developers">
                     <div><h3 style="display:inline-block;">In-Memory Computing Essentials for Java Developers
                         <a href="/events.html#in-memory-computing-essentials-for-java-developers"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -141,11 +163,40 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>				
-				
-				
-				
-				<section id="data-streaming-using-apache-flink-and-apache-ignite" class="page-section news-section">
+                </section>		
+	</div>
+</div>			
+
+<div class="row new-event margin-headline">
+	<div class="col-md-12 text-center">
+		<p>Browse the <a href="meetup-groups.html">Apache Ignite groups</a> and find one near your area.</p>
+	</div>
+</div>
+
+<h2 class="sub-head-events">Past Events</h2>	
+  <!-- Nav tabs -->
+ <ul id="past-events" class="nav nav-tabs">
+     <li  class="active"><a href="#2019" aria-controls="profile" data-toggle="tab">2019</a></li>
+     <li><a href="#2018" aria-controls="profile" data-toggle="tab">2018</a></li>
+	 <li><a href="#2017" aria-controls="profile" data-toggle="tab">2017</a></li>
+	 <li><a href="#2016" aria-controls="profile" data-toggle="tab">2016</a></li>
+	 <li><a href="#2015" aria-controls="profile" data-toggle="tab">2015</a></li>
+	 <li><a href="#2014" aria-controls="profile" data-toggle="tab">2014</a></li>
+ </ul>
+	
+ <!-- Tab panes -->
+ <div class="tab-content">
+
+	<div class="tab-pane active" id="2019">
+<div class="row new-event margin-headline">
+	<div class="col-xl-2 col-md-2 hidden-sm hidden-xs">
+		<div class="round-icon-block">
+			<img src="images/meetup.svg" alt="Meetup Logo">
+			<p>Meetups</p>
+		</div>
+	</div>
+	<div class="col-xl-10 col-md-10 col-sm-12">
+			<section id="data-streaming-using-apache-flink-and-apache-ignite">
                     <div><h3 style="display:inline-block;">Data Streaming Using Apache Flink and Apache Ignite
                         <a href="/events.html#data-streaming-using-apache-flink-and-apache-ignite"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -173,25 +224,32 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>				
-				
-
-				<section id="in-memory-computing-essentials-for-software-engineers-dec-2" class="page-section news-section">
+                </section>		
+	</div>
+</div>		
+		<div class="row new-event margin-headline">
+	<div class="col-xl-2 col-md-2 hidden-sm hidden-xs">
+		<div class="round-icon-block">
+			<img src="images/meetup.svg" alt="Meetup Logo">
+			<p>Meetups</p>
+		</div>
+	</div>
+	<div class="col-xl-10 col-md-10 col-sm-12">
+		<section id="in-memory-computing-essentials-for-software-engineers-dec-2">
                     <div><h3 style="display:inline-block;">In-Memory Computing Essentials for Software Engineers
                         <a href="/events.html#in-memory-computing-essentials-for-software-engineers-oct"><i class="fa fa-anchor"></i></a>
                     </h3></div>
-                    <span class="news-date">The Silicon Valley Java User Group, Speaker: Denis Magda</span><br/><br/>
+                    <span class="news-date">The Silicon Valley Java User Group, Speaker: Denis Magda</span><br/><br/> 
                     <span class="news-date">DECEMBER 18, 2019</span>
 
                     <p>Attendees will be introduced to the fundamental capabilities of in-memory computing platforms that are proven to boost application performance and solve scalability problems by storing and processing massive data sets in RAM and on disk.</p>
 
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/en-US/sv-jug/events/265881743/" target="_blank" rel="noopener">Read more</a>
                         </p>
                     </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.meetup.com/en-US/sv-jug/events/265881743/"
@@ -203,10 +261,18 @@
                         </div>
                         <!-- AddToAny END -->
                     </div>
-                    <p style="margin:0;">&nbsp;</p>
-                </section>				
-
-				<section id="in-memory-computing-essentials-for-software-engineers-dec-1" class="page-section news-section">
+           </section>	
+	</div>
+</div>
+		<div class="row new-event">
+	<div class="col-xl-2 col-md-2 hidden-sm hidden-xs">
+		<div class="round-icon-block">
+			<img src="images/meetup.svg" alt="Meetup Logo">
+			<p>Meetups</p>
+		</div>
+	</div>
+	<div class="col-xl-10 col-md-10 col-sm-12">
+		<section id="in-memory-computing-essentials-for-software-engineers-dec-1">
                     <div><h3 style="display:inline-block;">How and why Apache Ignite<sup>®</sup> is changing from an In-Memory Data Grid into an In-Memory Database
                         <a href="/events.html#in-memory-computing-essentials-for-software-engineers-oct"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -217,13 +283,12 @@
 					
 					<a href="https://www.google.com/maps/place/51°30'07.1%22N+0°07'07.9%22W/@51.501965,-0.118852,17z/data=!3m1!4b1!4m5!3m4!1s0x0:0x0!8m2!3d51.501965!4d-0.118852" target="_blank" rel="noopener">Where to Find Us</a>
 
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.eventbrite.com/e/open-source-database-best-practices-registration-82082285325" target="_blank" rel="noopener">Read more</a>
                         </p>
                     </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.eventbrite.com/e/open-source-database-best-practices-registration-82082285325"
@@ -236,9 +301,18 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>				
-
-				<section id="how-to-migrate-your-data-schema-to-apache-ignite-deec-4-19" class="page-section news-section">
+                </section>
+	</div>
+</div>					
+		<div class="row new-event">
+	<div class="col-xl-2 col-md-2 hidden-sm hidden-xs">
+		<div class="round-icon-block">
+			<img src="images/webinars.svg" alt="Webinar">
+			<p>Webinar</p>
+		</div>
+	</div>
+	<div class="col-xl-10 col-md-10 col-sm-12">
+		<section id="how-to-migrate-your-data-schema-to-apache-ignite-deec-4-19">
                     <div><h3 style="display:inline-block;">How to Migrate Your Data Schema to Apache Ignite 
                         <a href="/events.html#how-to-migrate-your-data-schema-to-apache-ignite-deec-4-19"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -247,13 +321,12 @@
 
                     <p>In this webinar, we will discuss the pros and cons of SQL and JCache APIs approaches to work with your data in Apache Ignite. Talk includes Ignite SQL capabilities, consistency guarantees, complications of distributed SQL and how affinity co-location can minimize them.</p>
 
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.gridgain.com/resources/webinars/how-migrate-your-data-schema-apache-ignite" target="_blank" rel="noopener">Read more</a>
                         </p>
                     </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.gridgain.com/resources/webinars/how-migrate-your-data-schema-apache-ignite"
@@ -266,9 +339,18 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>					
-				
-				<section id="apache-ignite-moscow-meetup-dec-3-19" class="page-section news-section">
+                </section>
+	</div>
+</div>			
+<div class="row new-event">
+	<div class="col-xl-2 col-md-2 hidden-sm hidden-xs">
+		<div class="round-icon-block">
+			<img src="images/meetup.svg" alt="Meetup">
+			<p>Meetup</p>
+		</div>
+	</div>
+	<div class="col-xl-10 col-md-10 col-sm-12">
+		<section id="apache-ignite-moscow-meetup-dec-3-19">
                     <div><h3 style="display:inline-block;">Apache Ignite Moscow Meetup 
                         <a href="/events.html#apache-ignite-moscow-meetup-dec-3-19"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -277,12 +359,12 @@
 
                     <p>Andrei Gora, Apache Ignite PMC, will talk about typical problems that arise when moving to a distributed model of data storage and processing, namely, the organization of consistent data placement in a distributed system. Denis Garus (Sbertech) will present Ignite Sandbox and tell about data protection in a distributed Java environment. After the talks, we plan to discuss what does community expect from Ignite 3.</p>
 
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://gridgain.timepad.ru/event/1124829/" target="_blank" rel="noopener">Read more</a>
                         </p>
                     </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
+                    <div>
 
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
@@ -296,9 +378,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>					
-
-				<section id="ignite-pearls-insight-and-creativity-in-distributed-programming" class="page-section news-section">
+                </section>
+	</div>
+</div>
+		<div class="row new-event">
+	<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+			<img src="images/meetup.svg" alt="Meetup Logo">
+			<p>Meetups</p>
+		</div>
+	</div>
+	<div class="col-md-10">
+		<section id="ignite-pearls-insight-and-creativity-in-distributed-programming">
                     <div><h3 style="display:inline-block;">Ignite Pearls - Insight and Creativity in Distributed Programming
                         <a href="/events.html#ignite-pearls-insight-and-creativity-in-distributed-programming" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -307,12 +397,12 @@
 
                     <p>This presentation is a live Scala coding talk full of small case studies, real examples, and interesting exercises for learning about how to do a modern distributed programming with Apache Ignite.</p>
 
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/en-US/ny-scala/events/266240908/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
                     </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
+                    <div>
 
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
@@ -326,9 +416,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>					
-				
-				<section id="apache-ignite-pumpkin-meetup" class="page-section news-section">
+                </section>	
+	</div>
+</div>
+		<div class="row new-event">
+	<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+			<img src="images/meetup.svg" alt="Meetup Logo">
+			<p>Meetups</p>
+		</div>
+	</div>
+	<div class="col-md-10">
+		<section id="apache-ignite-pumpkin-meetup">
                     <div><h3 style="display:inline-block;">Apache Ignite Pumpkin Meetup
                         <a href="/events.html#apache-ignite-pumpkin-meetup" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -337,12 +435,12 @@
 
                     <p>We are going to have a cozy Halloween talk about “how to use” (first speaker) and “how does it work” (second speaker). As usual, there will be tea and coffee, a snack and a raffle of useful books. Evgeny Zhuravlev will present talk “Architecture and optimization of working with memory for processing big data”. Apache Ignite Committer Maxim Muzafarov will tell about his experience of working with Rebalance feature. </p>
 
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href=" https://gridgain.timepad.ru/event/1091051/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
                     </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
+                    <div>
 
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
@@ -356,9 +454,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-				
-				<section id="in-memory-computing-essentials-for-software-engineers-oct" class="page-section news-section">
+                </section>	
+	</div>
+</div>
+		<div class="row new-event">
+	<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+			<img src="images/meetup.svg" alt="Meetup Logo">
+			<p>Meetups</p>
+		</div>
+	</div>
+	<div class="col-md-10">
+		<section id="in-memory-computing-essentials-for-software-engineers-oct">
                     <div><h3 style="display:inline-block;">In-Memory Computing Essentials for Software Engineers
                         <a href="/events.html#in-memory-computing-essentials-for-software-engineers-oct" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -367,12 +473,12 @@
 
                     <p>Free books+swag, caviar, liquors, cheeses & other eclectic delicacies! Attendees will be introduced to the fundamental capabilities of in-memory computing platforms that are proven to boost application performance and solve scalability problems by storing and processing massive data sets in RAM and on disk.</p>
 
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/es-ES/mysqlnyc/events/265780229/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
                     </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
+                    <div>
 
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
@@ -386,9 +492,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>				
-				
-				<section id="ensembles-of-ml-algorithms-and-distributed-online-machine-learning-with-apache-ignite" class="page-section news-section">
+                </section>	
+	</div>
+</div>
+		<div class="row new-event">
+	<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+			<img src="images/meetup.svg" alt="Meetup Logo">
+			<p>Meetups</p>
+		</div>
+	</div>
+	<div class="col-md-10">
+		<section id="ensembles-of-ml-algorithms-and-distributed-online-machine-learning-with-apache-ignite">
                     <div><h3 style="display:inline-block;">Ensembles of ML algorithms and Distributed Online Machine Learning with Apache Ignite
                         <a href="/events.html#ensembles-of-ml-algorithms-and-distributed-online-machine-learning-with-apache-ignite" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -397,13 +511,11 @@
 
                     <p>Alexey Zinovyev, Apache<sup>®</sup> Ignite® Committer, will tell about Apache Ignite ML module and how can it  speedup your ML training. Also He will speak about using Ignite as a backend for distributed TensorFlow calculations.</p>
 
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://aceu19.apachecon.com/session/ensembles-ml-algorithms-and-distributed-online-machine-learning-apache-ignite-0" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://aceu19.apachecon.com/session/ensembles-ml-algorithms-and-distributed-online-machine-learning-apache-ignite-0"
@@ -416,9 +528,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-				
-				<section id="whats-new-in-gridgain-web-console" class="page-section news-section">
+                </section>	
+	</div>
+</div>
+		<div class="row new-event">
+	<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+			<img src="images/webinars.svg" alt="Webinars">
+			<p>Webinars</p>
+		</div>
+	</div>
+	<div class="col-md-10">
+		<section id="whats-new-in-gridgain-web-console">
                     <div><h3 style="display:inline-block;">Updated Apache Ignite Apache® Ignite® Web Console live demo
                         <a href="/events.html#whats-new-in-gridgain-web-console" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -427,13 +547,11 @@
 
                     <p>GridGain Web Console is now 100% free for Apache® Ignite™ and GridGain®  users. During the session we will cover the basics of installation and discuss new features and capabilities added to the most recent release as well as architectural changes.</p>
 
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.gridgain.com/resources/webinars/whats-new-in-gridgain-web-console" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.gridgain.com/resources/webinars/whats-new-in-gridgain-web-console"
@@ -446,9 +564,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-				
-                <section id="why-did-we-developed-another-one-kafka-connector" class="page-section news-section">
+                </section>	
+	</div>
+</div>
+		<div class="row new-event">
+	<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+			<img src="images/meetup.svg" alt="Meetup">
+			<p>Meetup</p>
+		</div>
+	</div>
+	<div class="col-md-10">
+		<section id="why-did-we-developed-another-one-kafka-connector">
                     <div><h3 style="display:inline-block;">Why did we developed another one Kafka connector
                         <a href="/events.html#why-did-we-developed-another-one-kafka-connector" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -457,12 +583,12 @@
 
                     <p>In his talk Alexey will tell, when the connectors are more convenient than developing from scratch, briefly will go through the existing connectors. After that Alexey will tell how he wrote his version based on Apache Ignite and certified by Confluent.</p>
 
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://leroy-merlin.timepad.ru/event/1069622/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
                     </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
+                    <div>
 
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
@@ -476,9 +602,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-
-				<section id="data-distribution-in-apache-ignite" class="page-section news-section">
+                </section>	
+	</div>
+</div>
+		<div class="row new-event">
+	<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+			<img src="images/meetup.svg" alt="Meetup">
+			<p>Meetup</p>
+		</div>
+	</div>
+	<div class="col-md-10">
+		<section id="data-distribution-in-apache-ignite">
                     <div><h3 style="display:inline-block;">Data Distribution in Apache Ignite
                         <a href="/events.html#data-distribution-in-apache-ignite" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -487,12 +621,12 @@
 
                     <p>Andrei Gora, committer and PMC of the Apache Ignite project, will talk about typical problems that arise when moving to a distributed model of data storage and processing, namely, the organization of a consistent data placement in a distributed system. Special attention will be paid to the rendezvous hashing algorithm, the features of its use in Apache Ignite (Rendezvous affinity function) and possible alternatives.</p>
 
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/ru-RU/Scalability-Camp/events/264936752/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
                     </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
+                    <div>
 
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
@@ -506,9 +640,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-
- 				<section id="moving-apache-ignite-into-production-best-practices-for-disaster-recovery-and-high-availability" class="page-section news-section">
+                </section>	
+	</div>
+</div>
+		<div class="row new-event">
+	<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+			<img src="images/meetup.svg" alt="Meetup">
+			<p>Meetup</p>
+		</div>
+	</div>
+	<div class="col-md-10">
+		<section id="moving-apache-ignite-into-production-best-practices-for-disaster-recovery-and-high-availability">
                     <div><h3 style="display:inline-block;">Moving Apache® Ignite® into Production: Best Practices For Disaster Recovery and High Availability
                         <a href="/events.html#moving-apache-ignite-into-production-best-practices-for-deploying-apache-ignite-in-the-cloud" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -517,12 +659,12 @@
 
                     <p>Learn some of the best practices and the different options for maximizing availability and preventing data loss. This session explains in detail the various challenges including cluster and data center failures, and the best practices for implementing disaster recovery (DR) for distributed in-memory computing based on real-world deployments.</p>
 
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.gridgain.com/resources/webinars/moving-apache-ignite-production-best-practices-disaster-recovery-and-high" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
                     </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
+                    <div>
 
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
@@ -536,9 +678,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section> 
-				
-				<section id="continuous-machine-and-deep-learning-at-scale-with-apache-ignite" class="page-section news-section">
+                </section>	
+	</div>
+</div>
+		<div class="row new-event">
+	<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+			<img src="images/conferences.svg" alt="Conference">
+			<p>Conference</p>
+		</div>
+	</div>
+	<div class="col-md-10">
+		<section id="continuous-machine-and-deep-learning-at-scale-with-apache-ignite">
                     <div><h3 style="display:inline-block;">Continuous Machine and Deep Learning at Scale with Apache Ignite
                         <a href="/events.html#continuous-machine-and-deep-learning-at-scale-with-apache-ignite" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -547,13 +697,11 @@
 
                     <p>During this session Denis, Apache Ignite PMC chair,  will tell, how Apache Ignite and GridGain help to address these limitations with model training and execution, and help achieve near-real-time, continuous learning. It will be explained how ML/DL work with Apache Ignite, and how to get started.</p>
 
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://apachecon.com/acna19/s/#/scheduledEvent/1125 " target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://apachecon.com/acna19/s/#/scheduledEvent/1125 "
@@ -566,9 +714,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-				
- 				<section id="moving-apache-ignite-into-production-best-practices-for-deploying-apache-ignite-in-the-cloud" class="page-section news-section">
+                </section>	
+	</div>
+</div>
+		<div class="row new-event">
+	<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+			<img src="images/webinars.svg" alt="Webinars">
+			<p>Webinars</p>
+		</div>
+	</div>
+	<div class="col-md-10">
+		<section id="moving-apache-ignite-into-production-best-practices-for-deploying-apache-ignite-in-the-cloud">
                     <div><h3 style="display:inline-block;">Moving Apache® Ignite® into Production: Best Practices for Deploying Apache Ignite in the Cloud
                         <a href="/events.html#moving-apache-ignite-into-production-best-practices-for-deploying-apache-ignite-in-the-cloud" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -577,13 +733,12 @@
 
                     <p>This webinar discusses deploying Apache Ignite into production in public and private clouds. Companies have faced many challenges when deploying in-memory computing platforms such as Apache Ignite in the cloud, but they have also discovered many best practices that have made success possible.</p>
 
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.gridgain.com/resources/webinars/moving-apacher-ignitetm-production-best-practices-deploying-apache-ignite-in" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
                     </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.gridgain.com/resources/webinars/moving-apacher-ignitetm-production-best-practices-deploying-apache-ignite-in"
@@ -596,9 +751,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section> 				
-				
- 				<section id="cloud-deployment-best-practices" class="page-section news-section">
+                </section>	
+	</div>
+</div>
+		<div class="row new-event">
+	<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+			<img src="images/meetup.svg" alt="Meetup">
+			<p>Meetup</p>
+		</div>
+	</div>
+	<div class="col-md-10">
+		<section id="cloud-deployment-best-practices">
                     <div><h3 style="display:inline-block;">Cloud deployment best practices
                         <a href="/events.html#cloud-deployment-best-practices" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -607,12 +770,12 @@
 
                     <p>Cloud deployments offer the potential for almost infinite resources and flexible scalability. But there are so many options! It can be overwhelming to know which services are best for your use case. Building distributed systems only adds to the complexity. Come learn some best practices on how to best structure and deploy IMDB/IMDG applications in a cloud environment.</p>
 
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.gridgain.com/resources/meetups/nyc-in-memory-computing-meetup-10" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
                     </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
+                    <div>
 
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
@@ -626,9 +789,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section> 
-				
- 				<section id="the-insiders-checklist-for-hardening-an-in-memory-computing-cluster" class="page-section news-section">
+                </section>	
+	</div>
+</div>
+		<div class="row new-event">
+	<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+			<img src="images/meetup.svg" alt="Meetup">
+			<p>Meetup</p>
+		</div>
+	</div>
+	<div class="col-md-10">
+		<section id="the-insiders-checklist-for-hardening-an-in-memory-computing-cluster">
                     <div><h3 style="display:inline-block;">The Insiders Checklist for Hardening an In-Memory Computing Cluster
                         <a href="/events.html#the-insiders-checklist-for-hardening-an-in-memory-computing-cluster" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -637,13 +808,12 @@
 
                     <p> In this talk Denis Magda, GridGain's VP of product management and Apache® Ignite™ PMC Chair, will walk through the various components of Apache Ignite and GridGain -- including memory storage, networking layer, compute grid -- to help explain many of best practices and the reasoning behind them.</p>
 
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.gridgain.com/resources/meetups/bay-area-in-memory-computing-meetup-10" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
                     </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.gridgain.com/resources/meetups/bay-area-in-memory-computing-meetup-10"
@@ -656,9 +826,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>               
-				
-				<section id="htap-via-integration-of-ignite-spark" class="page-section news-section">
+                </section>	
+	</div>
+</div>
+		<div class="row new-event">
+	<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+			<img src="images/meetup.svg" alt="Meetup">
+			<p>Meetup</p>
+		</div>
+	</div>
+	<div class="col-md-10">
+		<section id="htap-via-integration-of-ignite-spark">
                     <div><h3 style="display:inline-block;">HTAP via integration of Apache Ignite and Apache Spark
                         <a href="/events.html#htap-via-integration-of-ignite-spark" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -669,12 +847,12 @@
                         and using Apache Ignite as a storage engine for Apache Spark in particular to
                         handle HTAP workloads.</p>
 
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://cyberagent.connpass.com/event/134260/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
                     </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
+                    <div>
 
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
@@ -688,9 +866,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-
-                <section id="moving-apache-ignite-production-initial-checklist" class="page-section news-section">
+                </section>	
+	</div>
+</div>
+		<div class="row new-event">
+	<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+			<img src="images/webinars.svg" alt="Webinars">
+			<p>Webinar</p>
+		</div>
+	</div>
+	<div class="col-md-10">
+		<section id="moving-apache-ignite-production-initial-checklist">
                     <div><h3 style="display:inline-block;">Moving Apache Ignite into Production: An Initial Checklist
                         <a href="/events.html#moving-apache-ignite-production-initial-checklist" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -701,12 +887,12 @@
 
                     <p>This webinar is the first in a series that will guide you through the best development, monitoring, and troubleshooting practices for deploying Apache Ignite across different topologies and use cases.</p>
 
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.gridgain.com/resources/webinars/moving-apache-ignite-production-initial-checklist" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
                     </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
+                    <div>
 
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
@@ -720,11 +906,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-
-
-
-                <section id="sparkaisummit-north-america-2019" class="page-section news-section">
+                </section>	
+	</div>
+</div>
+		<div class="row new-event">
+	<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+			<img src="images/conferences.svg" alt="Conferences">
+			<p>Conference</p>
+		</div>
+	</div>
+	<div class="col-md-10">
+		<section id="sparkaisummit-north-america-2019">
                     <div><h3 style="display:inline-block;">Distributed ML/DL with Ignite ML Module Using Apache Spark as Database
                         <a href="/events.html#sparkaisummit-north-america-2019" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -743,13 +935,12 @@
                         not only for KMeans and LinReg.
                     </p>
 
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://databricks.com/sparkaisummit/north-america/sessions-single-2019?id=143" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
                     </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://databricks.com/sparkaisummit/north-america/sessions-single-2019?id=143"
@@ -762,8 +953,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="apacher-ignitetm-nodejs-developers" class="page-section news-section">
+                </section>	
+	</div>
+</div>
+		<div class="row new-event">
+	<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+			<img src="images/webinars.svg" alt="Webinars">
+			<p>Webinar</p>
+		</div>
+	</div>
+	<div class="col-md-10">
+		<section id="apacher-ignitetm-nodejs-developers">
                     <div><h3 style="display:inline-block;">Apache Ignite for Node.js Developers
                         <a href="/events.html#apacher-ignitetm-nodejs-developers" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -783,13 +983,12 @@
                         <li>Performing SQL, SQL Fields and Scan Queries</li>
                     </ul>
 
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.gridgain.com/resources/webinars/apacher-ignitetm-nodejs-developers" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
                     </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.gridgain.com/resources/webinars/apacher-ignitetm-nodejs-developers"
@@ -802,8 +1001,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="open-data-science-meetup-saint-petersburg-russia" class="page-section news-section">
+                </section>	
+	</div>
+</div>
+		<div class="row new-event">
+	<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+			<img src="images/meetup.svg" alt="Meetup">
+			<p>Meetup</p>
+		</div>
+	</div>
+	<div class="col-md-10">
+		<section id="open-data-science-meetup-saint-petersburg-russia">
                     <div><h3 style="display:inline-block;">Using TensorFlow with Apache Ignite
                         <a href="/events.html#open-data-science-meetup-saint-petersburg-russia" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -818,12 +1026,12 @@
                         <li>Inference TensorFlow models on Apache Ignite cluster</li>
                     </ul>
 
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.gridgain.com/resources/meetups/open-data-science-meetup-saint-petersburg-russia" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
                     </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
+                    <div>
 
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
@@ -837,10 +1045,19 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="whats-new-in-apache-ignite-27" class="page-section news-section">
+                </section>	
+	</div>
+</div>
+		<div class="row new-event">
+	<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+			<img src="images/webinars.svg" alt="Webinars">
+			<p>Webinar</p>
+		</div>
+	</div>
+	<div class="col-md-10">
+		<section id="whats-new-in-apache-ignite-27">
                     <div><h3 style="display:inline-block;">What’s New in Apache Ignite 2.7
-                        <a href="/events.html#whats-new-in-apache-ignite-27" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
+                        <a href="/events.html#whats-new-in-apache-ignite-27" aria-label="Webinar"><i class="fa fa-anchor"></i></a>
                     </h3></div>
                     <span class="news-date">Webinar, Speaker - Denis Magda</span><br/><br/>
                     <span class="news-date">Feb 13, 2019</span>
@@ -849,12 +1066,12 @@
                         You will learn how the new capabilities of Apache Ignite work. You will also understand more about some
                         of the other changes made to Apache Ignite, and the reasoning behind them. Come with your questions, and learn from the questions of your peers.
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
-                            <a href="https://www.gridgain.com/resources/webinars/whats-new-in-apache-ignite-27" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
+                            <a href="https://www.gridgain.com/resources/webinars/whats-new-in-apache-ignite-27" target="_blank" rel="noopener" aria-label="Webinar">Read more</a>
                         </p>
                     </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
+                    <div>
 
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
@@ -868,8 +1085,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="EffectiveMySQL-257849652" class="page-section news-section">
+                </section>	
+	</div>
+</div>
+		<div class="row new-event">
+	<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+			<img src="images/meetup.svg" alt="Meetup">
+			<p>Meetup</p>
+		</div>
+	</div>
+	<div class="col-md-10">
+		<section id="EffectiveMySQL-257849652">
                     <div><h3 style="display:inline-block;">Turbocharge your MySQL queries in-memory with In-Memory Computing
                         <a href="/events.html#EffectiveMySQL-257849652" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -882,13 +1108,12 @@
                         PostgreSQL, supports MySQL indexes, supports compound indexes, and various forms of
                         MySQL queries including distributed MySQL joins.
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/EffectiveMySQL/events/257849652/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
                     </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.meetup.com/EffectiveMySQL/events/257849652/"
@@ -901,8 +1126,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="gridgain-cloud-deploy-apache-ignite-in-minutes" class="page-section news-section">
+                </section>	
+	</div>
+</div>
+		<div class="row new-event">
+	<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+			<img src="images/webinars.svg" alt="Webinars">
+			<p>Webinar</p>
+		</div>
+	</div>
+	<div class="col-md-10">
+		<section id="gridgain-cloud-deploy-apache-ignite-in-minutes" >
                     <div><h3 style="display:inline-block;">GridGain Cloud: Deploy Apache Ignite in Minutes
                         <a href="/events.html#gridgain-cloud-deploy-apache-ignite-in-minutes" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -914,13 +1148,11 @@
                         Learn how to deploy Ignite as a service with just a few clicks, and how to use Ignite as a
                         distributed cache or in-memory database (IMDB) as a service.
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.gridgain.com/resources/webinars/gridgain-cloud-deploy-apache-ignite-in-minutes" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.gridgain.com/resources/webinars/gridgain-cloud-deploy-apache-ignite-in-minutes"
@@ -933,8 +1165,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="in-memory-computing-best-practices-developing-new-apps-channels-and-apis" class="page-section news-section">
+                </section>	
+	</div>
+</div>	
+		<div class="row new-event">
+	<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+			<img src="images/webinars.svg" alt="Webinars">
+			<p>Webinar</p>
+		</div>
+	</div>
+	<div class="col-md-10">
+		<section id="in-memory-computing-best-practices-developing-new-apps-channels-and-apis">
                     <div><h3 style="display:inline-block;">In-Memory Computing Best Practices: Developing New Apps, Channels and APIs
                         <a href="/events.html#in-memory-computing-best-practices-developing-new-apps-channels-and-apis" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -947,13 +1188,12 @@
                         This session, the third in the In-Memory Computing Best Practices Series, dives into how in-memory
                         computing acts as a foundation for digital business.
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.gridgain.com/resources/webinars/in-memory-computing-best-practices-developing-new-apps-channels-and-apis" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
                     </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.gridgain.com/resources/webinars/in-memory-computing-best-practices-developing-new-apps-channels-and-apis"
@@ -966,8 +1206,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="Stanford-Data-Science-Machine-Learning-Meetup-256812708" class="page-section news-section">
+                </section>	
+	</div>
+</div>
+		<div class="row new-event">
+	<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+			<img src="images/meetup.svg" alt="Meetup">
+			<p>Meetup</p>
+		</div>
+	</div>
+	<div class="col-md-10">
+		<section id="Stanford-Data-Science-Machine-Learning-Meetup-256812708">
                     <div><h3 style="display:inline-block;">Workshop: Machine Learning 101 with In-Memory Computing
                         <a href="/events.html#Stanford-Data-Science-Machine-Learning-Meetup-256812708" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -986,12 +1235,12 @@
                         <li>Solve optimizations problems by simulating the process of biological evolution.</li>
                         <li>Apply machine learning algorithms supported by Apache Ignite.</li>
                     </ul>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/Stanford-Data-Science-Machine-Learning-Meetup/events/256812708" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
                     </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
+                    <div>
 
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
@@ -1005,8 +1254,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="open-source-data-science-256974934" class="page-section news-section">
+                </section>	
+	</div>
+</div>
+		<div class="row new-event">
+	<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+			<img src="images/meetup.svg" alt="Meetup">
+			<p>Meetup</p>
+		</div>
+	</div>
+	<div class="col-md-10">
+		<section id="open-source-data-science-256974934">
                     <div><h3 style="display:inline-block;">Workshop: In-Memory Computing Essentials for Data Scientists
                         <a href="/events.html#open-source-data-science-256974934" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -1025,12 +1283,12 @@
                         <li>Solve optimizations problems by simulating the process of biological evolution.</li>
                         <li>Apply machine learning algorithms supported by Apache Ignite.</li>
                     </ul>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/open-source-data-science/events/256974934/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
                     </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
+                    <div>
 
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
@@ -1044,8 +1302,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="NYC-In-Memory-Computing-Meetup-257355223" class="page-section news-section">
+                </section>	
+	</div>
+</div>
+		<div class="row new-event">
+	<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+			<img src="images/meetup.svg" alt="Meetup">
+			<p>Meetup</p>
+		</div>
+	</div>
+	<div class="col-md-10">
+		<section id="NYC-In-Memory-Computing-Meetup-257355223">
                     <div><h3 style="display:inline-block;">Relational DBMSs: Faster Transactions and Analytics with In-Memory Computing
                         <a href="/events.html#NYC-In-Memory-Computing-Meetup-257355223" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -1062,12 +1329,12 @@
                         <li>How to use Apache Ignite as an In-Memory Data Grid that stores data in memory and boosts applications performance by offloading reads from a Relational DBMS.</li>
                         <li>The strategic benefits of using Apache Ignite instead of Memcache, Redis, GigaSpaces, or Oracle Coherence.</li>
                     </ul>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/NYC-In-Memory-Computing-Meetup/events/257355223" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
                     </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
+                    <div>
 
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
@@ -1081,8 +1348,19 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="Amsterdam-Kubernetes-Meetup-256234544" class="page-section news-section">
+                </section>	
+	</div>
+</div>	
+	</div>
+	<div class="tab-pane" id="2018">
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup Logo">
+					<p>Meetups</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="Amsterdam-Kubernetes-Meetup-256234544">
                     <div><h3 style="display:inline-block;">Distributed Database DevOps Dilemmas? Kubernetes to the rescue!
                         <a href="/events.html#Amsterdam-Kubernetes-Meetup-256234544" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -1100,13 +1378,11 @@
                         <li>Database Availability - what’s the role of Kubernetes and the database</li>
                         <li>Utilizing both RAM and disk - set up Apache Ignite in a way to get in-memory performance with the durability of disk</li>
                     </ul>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/Amsterdam-Kubernetes-Meetup/events/256234544" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.meetup.com/Amsterdam-Kubernetes-Meetup/events/256234544"
@@ -1119,8 +1395,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="Hamburg-Kubernetes-Meetup-256200849" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup Logo">
+					<p>Meetups</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="Hamburg-Kubernetes-Meetup-256200849">
                     <div><h3 style="display:inline-block;">Distributed Database DevOps Dilemmas? Kubernetes to the rescue!
                         <a href="/events.html#Hamburg-Kubernetes-Meetup-256200849" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -1138,12 +1423,12 @@
                         <li>Database Availability - what’s the role of Kubernetes and the database</li>
                         <li>Utilizing both RAM and disk - set up Apache Ignite in a way to get in-memory performance with the durability of disk</li>
                     </ul>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/Hamburg-Kubernetes-Meetup/events/256200849/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
                     </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
+                    <div>
 
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
@@ -1157,8 +1442,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="Munchen-Kubernetes-Meetup-256177844" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup Logo">
+					<p>Meetups</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="Munchen-Kubernetes-Meetup-256177844">
                     <div><h3 style="display:inline-block;">Distributed Database DevOps Dilemmas? Kubernetes to the rescue!
                         <a href="/events.html#Munchen-Kubernetes-Meetup-256177844" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -1176,12 +1470,12 @@
                         <li>Database Availability - what’s the role of Kubernetes and the database</li>
                         <li>Utilizing both RAM and disk - set up Apache Ignite in a way to get in-memory performance with the durability of disk</li>
                     </ul>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/Munchen-Kubernetes-Meetup/events/256177844/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
                     </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
+                    <div>
 
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
@@ -1195,8 +1489,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="NYC-In-Memory-Computing-Meetup-256580648" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup Logo">
+					<p>Meetups</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="NYC-In-Memory-Computing-Meetup-256580648">
                     <div><h3 style="display:inline-block;">Memory-Centric Architecture - A New Approach to Distributed Systems
                         <a href="/events.html#NYC-In-Memory-Computing-Meetup-256580648" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -1213,12 +1516,12 @@
                         two worlds - disk-first and memory-first approaches.
 
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/NYC-In-Memory-Computing-Meetup/events/256580648/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
                     </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
+                    <div>
 
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
@@ -1232,8 +1535,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="Kafka-ATL-256500714" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup Logo">
+					<p>Meetups</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="Kafka-ATL-256500714">
                     <div><h3 style="display:inline-block;">Stream Processing Best Practices - In the Cloud and with Apache Ignite
                         <a href="/events.html#Kafka-ATL-256500714" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -1250,12 +1562,12 @@
                         <li>Recommended approaches for deployment, monitoring and management</li>
                         <li>Tips and tricks for performance and scalability tuning</li>
                     </ul>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/Kafka-ATL/events/256500714/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
                     </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
+                    <div>
 
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
@@ -1269,8 +1581,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="Apache-Kafka-DC-256476441" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup Logo">
+					<p>Meetups</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="Apache-Kafka-DC-256476441">
                     <div><h3 style="display:inline-block;">Best Practices for Stream Processing with Kafka and Apache Ignite
                         <a href="/events.html#Apache-Kafka-DC-256476441" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -1287,12 +1608,12 @@
                         <li>Recommended approaches for deployment, monitoring and management</li>
                         <li>Tips and tricks for performance and scalability tuning</li>
                     </ul>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/Apache-Kafka-DC/events/256476441" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
                     </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
+                    <div>
 
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
@@ -1306,8 +1627,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="moscow-apache-ignite-meetup-818220" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup Logo">
+					<p>Meetups</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="moscow-apache-ignite-meetup-818220">
                     <div><h3 style="display:inline-block;">Apache Ignite performance measurement. How we do benchmarks
                         <a href="/events.html#moscow-apache-ignite-meetup-818220" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -1319,12 +1649,12 @@
                         created using the example of Transparent Data Encryption in Apache Ignite.
 
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.gridgain.com/resources/meetups/moscow-apache-ignite-meetup" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
                     </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
+                    <div>
 
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
@@ -1338,8 +1668,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="KafkaBayArea--255670377" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup Logo">
+					<p>Meetups</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="KafkaBayArea--255670377">
                     <div><h3 style="display:inline-block;">Best Practices for Stream Processing with Kafka and Apache Ignite
                         <a href="/events.html#KafkaBayArea--255670377" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -1355,12 +1694,12 @@
                         <li>Recommended approaches for deployment, monitoring and management</li>
                         <li>Tips and tricks for performance and scalability tuning</li>
                     </ul>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/KafkaBayArea/events/255670377/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
                     </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
+                    <div>
 
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
@@ -1374,8 +1713,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="Bay-Area-In-Memory-Computing-255491989" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup Logo">
+					<p>Meetups</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="Bay-Area-In-Memory-Computing-255491989">
                     <div><h3 style="display:inline-block;">In-Memory Computing Essentials for Data Scientist
                         <a href="/events.html#Bay-Area-In-Memory-Computing-255491989" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -1385,12 +1733,12 @@
                         Lucas will talk about the fundamental capabilities of in-memory computing platforms that specifically boost high-load applications and services.
                         These cost-effective capabilities bring existing IT architecture to the next level by storing and processing massive quantities of data both in RAM and, optionally, on disk.
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/Bay-Area-In-Memory-Computing/events/255491989/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
                     </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
+                    <div>
 
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
@@ -1404,8 +1752,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="DevOps-Exchange-SanFrancisco-254969027" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup Logo">
+					<p>Meetups</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="DevOps-Exchange-SanFrancisco-254969027">
                     <div><h3 style="display:inline-block;">Distributed Database DevOps Dilemmas? Kubernetes to the rescue!
                         <a href="/events.html#DevOps-Exchange-SanFrancisco-254969027" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -1417,12 +1774,12 @@
                         leaning on relational databases as a data layer. However, it is more difficult to do the same when a distributed SQL database or
                         other kinds of distributed storage is used instead. In this presentation, attendees will learn how Kubernetes can orchestrate a distributed database.
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/DevOps-Exchange-SanFrancisco/events/254969027" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
                     </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
+                    <div>
 
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
@@ -1436,8 +1793,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="NYC-In-Memory-Computing-Meetup-254701726" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup Logo">
+					<p>Meetups</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="NYC-In-Memory-Computing-Meetup-254701726">
                     <div><h3 style="display:inline-block;">Powering up banks and financial institutions with distributed systems
                         <a href="/events.html#NYC-In-Memory-Computing-Meetup-254701726" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -1448,12 +1814,12 @@
                         platforms that are important for financial applications -- including ACID compliance, SQL compatibility,
                         persistence, replication, security, fault tolerance, fraud detection and more.
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/NYC-In-Memory-Computing-Meetup/events/254701726/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
                     </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
+                    <div>
 
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
@@ -1467,8 +1833,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="futureofdata-newyork-253873404" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup Logo">
+					<p>Meetups</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="futureofdata-newyork-253873404">
                     <div><h3 style="display:inline-block;">Best practices for stream ingestion, processing and analytics using in-memory computing
                         <a href="/events.html#futureofdata-newyork-253873404" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -1485,12 +1860,12 @@
                         <li>Implement and tune Apache Ignite or GridGain and Spark together</li>
                         <li>Design to ensure performance for real-time reports</li>
                     </ul>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/futureofdata-newyork/events/253873404" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
                     </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
+                    <div>
 
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
@@ -1504,8 +1879,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="Metis-New-York-Data-Science-254379968" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup Logo">
+					<p>Meetups</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="Metis-New-York-Data-Science-254379968">
                     <div><h3 style="display:inline-block;">Apache Ignite: The In-Memory Hammer In Your Data Science Toolkit
                         <a href="/events.html#Metis-New-York-Data-Science-254379968" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -1515,12 +1899,12 @@
                         In this presentation we will look at some of the main components of Apache Ignite, such as the Compute Grid,
                         Data Grid and the Machine Learning Grid. Through examples, attendees will learn how Apache Ignite can be used for data analysis.
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/Metis-New-York-Data-Science/events/254379968" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
                     </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
+                    <div>
 
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
@@ -1534,8 +1918,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="it-dev-connections-dallas" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup Logo">
+					<p>Meetups</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="it-dev-connections-dallas">
                     <div><h3 style="display:inline-block;">Scale Out and Conquer: Architectural Decisions Behind Distributed In-Memory Systems
                         <a href="/events.html#it-dev-connections-dallas" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -1547,12 +1940,12 @@
                         data-sharding algorithms, effective data models for distributed environments, synchronization and
                         coordination in distributed systems, and local scalability issues of speeding up local processing on cluster nodes.
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://tmt.knect365.com/it-dev-connections/speakers/denis-magda-1#far-east-room_scale-out-and-conquer-architectural-decisions-behind-distributed-in-memory-systems" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
                     </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
+                    <div >
 
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
@@ -1566,8 +1959,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="Bay-Area-In-Memory-Computing-254629901" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup Logo">
+					<p>Meetups</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="Bay-Area-In-Memory-Computing-254629901">
                     <div><h3 style="display:inline-block;">Best Practices for Stream Ingestion, Processing and Analytics Using In-Memory Computing
                         <a href="/events.html#Bay-Area-In-Memory-Computing-254629901" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -1583,12 +1985,12 @@
                         <li>Implement and tune Apache Ignite or GridGain and Spark together</li>
                         <li>Design to ensure performance for real-time reports</li>
                     </ul>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/Bay-Area-In-Memory-Computing/events/254629901/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
                     </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
+                    <div>
 
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
@@ -1602,8 +2004,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="db-tech-showcase-tokyo" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/conferences.svg" alt="Conferences">
+					<p>Conference</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="db-tech-showcase-tokyo">
                     <div><h3 style="display:inline-block;">Apache Ignite: From In-Memory Data Grid to Memory-Centric Distributed Database
                         <a href="/events.html#db-tech-showcase-tokyo" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -1612,12 +2023,12 @@
                     <p>
                         In this session Roman will explain how Apache Ignite evolved from in-memory data grid to memory-centric database, and you will learn about its peculiarities and strengths for fast data storing and processing.
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.db-tech-showcase.com/dbts/tokyo" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
                     </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
+                    <div>
 
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
@@ -1631,8 +2042,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="Big-Data-Paris-251647148" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="Big-Data-Paris-251647148">
                     <div><h3 style="display:inline-block;">How to become a Big Data Rockstar in 15 minutes!
                         <a href="/events.html#Big-Data-Paris-251647148" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -1651,12 +2071,12 @@
                     </ul>
                     <p>Attendees will also learn how to download and install Ignite and start to be productive in under 5 minutes.</p>
 
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/Big-Data-Paris/events/251647148" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
                     </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
+                    <div>
 
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
@@ -1670,8 +2090,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="Metis-New-York-Data-Science-253834339" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="Metis-New-York-Data-Science-253834339">
                     <div><h3 style="display:inline-block;">In-Memory Computing Essentials for Data Scientists
                         <a href="/events.html#Metis-New-York-Data-Science-253834339" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -1691,13 +2120,12 @@
                         <li>Apply machine learning algorithms supported by Apache Ignite.</li>
                     </ul>
                     <p>This two-hour workshop is a must-attend event for all data scientists!</p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/Metis-New-York-Data-Science/events/253834339/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
                     </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.meetup.com/Metis-New-York-Data-Science/events/253834339/"
@@ -1710,8 +2138,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="postgres-nyc-252852884" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="postgres-nyc-252852884">
                     <div><h3 style="display:inline-block;">PostgreSQL with Apache Ignite: Faster Transactions and Analytics
                         <a href="/events.html#postgres-nyc-252852884" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -1727,12 +2164,12 @@
                         <li>How to use Apache Ignite as an In-Memory Data Grid that stores data in memory and boosts applications performance by offloading reads from PostgreSQL.</li>
                         <li>The strategic benefits of using Apache Ignite instead of Memcache, Redis, GigaSpaces, or Oracle Coherence.</li>
                     </ul>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/postgres-nyc/events/252852884/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
                     </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
+                    <div>
 
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
@@ -1746,8 +2183,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="NYC-In-Memory-Computing-Meetup-253100350" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="NYC-In-Memory-Computing-Meetup-253100350">
                     <div><h3 style="display:inline-block;">Machine and Deep Learning with an Apache Ignite
                         <a href="/events.html#NYC-In-Memory-Computing-Meetup-253100350" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -1765,12 +2211,12 @@
                         <li>Examples of how to implement each ML and DL algorithm</li>
                         <li>Tips and tricks for getting the most performance out of ML and DL</li>
                     </ul>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/NYC-In-Memory-Computing-Meetup/events/253100350/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
                     </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
+                    <div>
 
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
@@ -1784,9 +2230,18 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="big-bang-Data-science-Solutions-253752437" class="page-section news-section">
-                    <div><h3 style="display:inline-block;">Improving Apache Spark™ In-Memory Computing with Apache Ignite®
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="big-bang-Data-science-Solutions-253752437">
+                    <div><h3 style="display:inline-block;">Improving Apache Spark™ In-Memory Computing with Apache Ignite<sup>®</sup>
                         <a href="/events.html#big-bang-Data-science-Solutions-253752437" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
                     <span class="news-date">Big Bang Data Science - Georgia, Speaker - Akmal Chaudhri</span><br/><br/>
@@ -1802,12 +2257,12 @@
                         <li>How to leverage Ignite to easily share state across Spark jobs using mutable RDDs and DataFrames</li>
                         <li>How to leverage Ignite distributed SQL and advanced indexing in memory to improve SQL performance</li>
                     </ul>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/big-bang-Data-science-Solutions/events/253752437/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
                     </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
+                    <div>
 
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
@@ -1821,8 +2276,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="Greater-Atlanta-Internet-of-Things-253619287" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="Greater-Atlanta-Internet-of-Things-253619287">
                     <div><h3 style="display:inline-block;">Speeding-up the IoT: Best practices for stream ingestion, processing and analytics using in-memory computing
                         <a href="/events.html#Greater-Atlanta-Internet-of-Things-253619287" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -1838,12 +2302,12 @@
                         <li>Implement and tune Apache Ignite and Spark together</li>
                         <li>Design to ensure performance for real-time reports</li>
                     </ul>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/Greater-Atlanta-Internet-of-Things/events/253619287/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
                     </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
+                    <div>
 
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
@@ -1857,8 +2321,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="Bay-Area-In-Memory-Computing-252983625" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="Bay-Area-In-Memory-Computing-252983625">
                     <div><h3 style="display:inline-block;">Best Practices for Deploying Distributed Databases and In-Memory Computing Platforms with Kubernetes
                         <a href="/events.html#Bay-Area-In-Memory-Computing-252983625" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -1872,13 +2345,11 @@
                         <li>Set up and manage persistence for the in-memory technologies above or configure a disk-based distributed database</li>
                         <li>Set up auto-discovery and automated horizontal scalability, and use other tricks for high availability</li>
                     </ul>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/Bay-Area-In-Memory-Computing/events/252983625" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.meetup.com/Bay-Area-In-Memory-Computing/events/252983625"
@@ -1891,8 +2362,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="Metis-San-Francisco-Data-Science-253823997" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="Metis-San-Francisco-Data-Science-253823997">
                     <div><h3 style="display:inline-block;">In-Memory Computing Essentials for Data Scientists
                         <a href="/events.html#Metis-San-Francisco-Data-Science-253823997" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -1905,12 +2385,12 @@
                         These capabilities and benefits will be demonstrated with the usage of Apache Ignite which is the
                         in-memory computing platform that is durable, strongly consistent, and highly available with powerful SQL, key-value and processing APIs.
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/Metis-San-Francisco-Data-Science/events/253823997" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
                     </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
+                    <div>
 
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
@@ -1924,8 +2404,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="datasummer-ukraine" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/conferences.svg" alt="Conference">
+					<p>Conference</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="datasummer-ukraine" >
                     <div><h3 style="display:inline-block;">Apache Ignite + Apache Spark RDDs and DataFrames integration (ENG)
                         <a href="/events.html#datasummer-ukraine" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -1941,13 +2430,11 @@
                         <li>How to leverage Ignite to easily share state across Spark jobs using mutable RDDs and DataFrames</li>
                         <li>How to leverage Ignite distributed SQL and advanced indexing in memory to improve SQL performance</li>
                     </ul>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://provectus.com/datasummer/#agenda" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://provectus.com/datasummer/#agenda"
@@ -1960,8 +2447,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="big-data-san-francisco-v-50-tickets-46971191097" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/conferences.svg" alt="Conference">
+					<p>Conference</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="big-data-san-francisco-v-50-tickets-46971191097">
                     <div><h3 style="display:inline-block;">Adding Speed and Scale to Existing Applications with No Rip and Replace Using Apache Ignite
                         <a href="/events.html#big-data-san-francisco-v-50-tickets-46971191097" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -1978,12 +2474,12 @@
                         <li>Leverage from Apache Ignite distributed SQL and ACID transaction for IMDG scenarios</li>
                         <li>Move further and start to build HTAP applications, real-time analytics, and machine learning, on the same IMDG</li>
                     </ul>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.eventbrite.co.uk/e/big-data-san-francisco-v-50-tickets-46971191097" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
                     </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
+                    <div class="col-sm-12 col-md-3 col-xs-12">
 
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
@@ -1997,8 +2493,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="London-In-Memory-Computing-Meetup-252516279" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="London-In-Memory-Computing-Meetup-252516279" >
                     <div><h3 style="display:inline-block;">Machine and Deep Learning with in-memory computing
                         <a href="/events.html#London-In-Memory-Computing-Meetup-252516279" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -2013,13 +2518,11 @@
                         <li>Examples of how to implement each ML and DL algorithm</li>
                         <li>Tips and tricks for getting the most performance out of ML and DL</li>
                     </ul>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/London-In-Memory-Computing-Meetup/events/252516279" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.meetup.com/London-In-Memory-Computing-Meetup/events/252516279"
@@ -2032,8 +2535,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="webinars-best-practices-deploying-distributed-databases-and-in-memory-computing-platforms" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/webinars.svg" alt="Webinars">
+					<p>Webinar</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="webinars-best-practices-deploying-distributed-databases-and-in-memory-computing-platforms" >
                     <div><h3 style="display:inline-block;">Best Practices for Deploying Distributed Databases and In-Memory Computing Platforms with Kubernetes
                         <a href="/events.html#webinars-best-practices-deploying-distributed-databases-and-in-memory-computing-platforms" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -2047,13 +2559,11 @@
                     <p>
                         In this webinar, learn how Kubernetes can orchestrate a distributed database or in-memory computing solutions using Apache Ignite as an example.
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.gridgain.com/resources/webinars/best-practices-deploying-distributed-databases-and-in-memory-computing-platforms" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.gridgain.com/resources/webinars/best-practices-deploying-distributed-databases-and-in-memory-computing-platforms"
@@ -2066,8 +2576,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="webinars-in-memory-computing-essentials-architects-and-developers-part-1-0" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/webinars.svg" alt="Webinars">
+					<p>Webinar</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="webinars-in-memory-computing-essentials-architects-and-developers-part-1-0" >
                     <div><h3 style="display:inline-block;">In-Memory Computing Essentials for Architects and Developers: Part 1
                         <a href="/events.html#webinars-in-memory-computing-essentials-architects-and-developers-part-1-0" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -2083,13 +2602,11 @@
                         <li>Data processing with key-value APIs</li>
                         <li>Data processing with SQL</li>
                     </ul>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.gridgain.com/resources/webinars/in-memory-computing-essentials-architects-and-developers-part-1-0" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.gridgain.com/resources/webinars/in-memory-computing-essentials-architects-and-developers-part-1-0"
@@ -2102,8 +2619,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="docker-new-york" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/conferences.svg" alt="Conference">
+					<p>Conference</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="docker-new-york" >
                     <div><h3 style="display:inline-block;">Distributed Database DevOps Dilemmas? Kubernetes to the rescue!
                         <a href="/events.html#docker-new-york" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -2121,13 +2647,11 @@
                         <li>Database Availability - what’s the role of Kubernetes and the database</li>
                         <li>Utilizing both RAM and disk - set up Apache Ignite in a way to get in-memory performance with the durability of disk</li>
                     </ul>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://events.docker.com/events/details/docker-new-york-presents-dockernyc-with-gridgain" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://events.docker.com/events/details/docker-new-york-presents-dockernyc-with-gridgain"
@@ -2140,8 +2664,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="NYC-In-Memory-Computing-Meetup-251244661" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="NYC-In-Memory-Computing-Meetup-251244661" >
                     <div><h3 style="display:inline-block;">Scale Out and Conquer: Architectural Decisions Behind Distributed In-Memory Systems
                         <a href="/events.html#NYC-In-Memory-Computing-Meetup-251244661" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -2156,13 +2689,11 @@
                         <li>Synchronization and coordination in distributed systems</li>
                         <li>Local scalability issues of speeding up local processing on cluster nodes</li>
                     </ul>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/NYC-In-Memory-Computing-Meetup/events/251244661/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.meetup.com/NYC-In-Memory-Computing-Meetup/events/251244661/"
@@ -2175,8 +2706,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="mysqlnyc-251606063" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="mysqlnyc-251606063" >
                     <div><h3 style="display:inline-block;">Apache Cassandra vs Apache Ignite for HTAP
                         <a href="/events.html#mysqlnyc-251606063" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -2193,13 +2733,11 @@
                         <li>The requirements for real-time, high volume HTAP applications</li>
                         <li>Architectural best practices, including how in-memory computing fits in and has eliminated tradeoffs between consistency, speed and scale</li>
                     </ul>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/mysqlnyc/events/251606063/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.meetup.com/mysqlnyc/events/251606063/"
@@ -2212,8 +2750,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="webinar-building-new-hybrid-transactionaloperational-processing-htap-applications" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/webinars.svg" alt="Webinars">
+					<p>Webinar</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="webinar-building-new-hybrid-transactionaloperational-processing-htap-applications" >
                     <div><h3 style="display:inline-block;">Building New Hybrid Transactional/Operational Processing (HTAP) Applications With Apache® Ignite®
                         <a href="/events.html#webinar-building-new-hybrid-transactionaloperational-processing-htap-applications" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -2230,13 +2777,11 @@
                         <li>Increase transaction throughput using a combination of distributed SQL, ACID transaction support and native persistence</li>
                         <li>Synchronize data and transactions with existing systems</li>
                     </ul>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.gridgain.com/resources/webinars/part-2-building-new-hybrid-transactionaloperational-processing-htap-applications" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.gridgain.com/resources/webinars/part-2-building-new-hybrid-transactionaloperational-processing-htap-applications"
@@ -2249,8 +2794,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="containerdays-distributed-database-devops-dilemmas" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/conferences.svg" alt="Conferences">
+					<p>Conference</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="containerdays-distributed-database-devops-dilemmas" >
                     <div><h3 style="display:inline-block;">Distributed Database DevOps Dilemmas? Kubernetes to the rescue!
                         <a href="/events.html#containerdays-distributed-database-devops-dilemmas" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -2271,13 +2825,11 @@
                         <li>Utilizing both RAM and disk - set up Apache Ignite in a way to get in-memory performance with the durability of disk</li>
                     </ul>
 
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://containerdays.io/program/distributed-database-devops-dilemmas-kubernetes-to-the-rescue,2830.html" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://containerdays.io/program/distributed-database-devops-dilemmas-kubernetes-to-the-rescue,2830.html"
@@ -2290,8 +2842,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="euroadshow18-iot-schedule" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/conferences.svg" alt="Conferences">
+					<p>Conference</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="euroadshow18-iot-schedule" >
                     <div><h3 style="display:inline-block;">Apache Spark and Apache Ignite: Where Fast Data Meets the IoT
                         <a href="/events.html#euroadshow18-iot-schedule" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -2303,13 +2864,11 @@
                         In particular, attendees will learn about data streaming to an Apache Ignite cluster from
                         embedded devices and real-time data processing with Apache Spark.
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="http://www.apachecon.com/euroadshow18/iot-schedule.html" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="http://www.apachecon.com/euroadshow18/iot-schedule.html"
@@ -2322,9 +2881,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-
-                <section id="Bay-Area-In-Memory-Computing-251308516" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="Bay-Area-In-Memory-Computing-251308516" >
                     <div><h3 style="display:inline-block;">In-memory computing hot topics & emerging trends: Panel discussion in Menlo Park
                         <a href="/events.html#Bay-Area-In-Memory-Computing-251308516" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -2341,13 +2908,11 @@
                         discussion on in-memory computing hot topics and emerging trends (and more). The panel of experts
                         will also field your questions, suggestions and ideas.
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/Bay-Area-In-Memory-Computing/events/251308516/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.meetup.com/Bay-Area-In-Memory-Computing/events/251308516/"
@@ -2360,8 +2925,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="javamug-lvktppyxjbrb" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="javamug-lvktppyxjbrb" >
                     <div><h3 style="display:inline-block;">Skyrocket Java applications with the open-source Apache Ignite
                         <a href="/events.html#javamug-lvktppyxjbrb" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -2372,13 +2946,11 @@
                         As Java professionals, you will learn how to solve some of the most demanding scalability and
                         performance challenges. She’ll also cover a few typical use cases and work through some code examples.
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/javamug/events/lvktppyxjbrb/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.meetup.com/javamug/events/lvktppyxjbrb/"
@@ -2391,8 +2963,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="adding-speed-and-scale-existing-applications-no-rip-and-replace-using" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/webinars.svg" alt="Webinars">
+					<p>Webinar</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="adding-speed-and-scale-existing-applications-no-rip-and-replace-using" >
                     <div><h3 style="display:inline-block;">Adding Speed and Scale to Existing Applications with No Rip and Replace Using Apache® Ignite®
                         <a href="/events.html#adding-speed-and-scale-existing-applications-no-rip-and-replace-using" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -2409,13 +2990,11 @@
                         <li>Leverage from Apache Ignite distributed SQL and ACID transaction for IMDG scenarios</li>
                         <li>Move further and start to build HTAP applications, real-time analytics, and machine learning, on the same IMDG</li>
                     </ul>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.gridgain.com/resources/webinars/part-1-adding-speed-and-scale-existing-applications-no-rip-and-replace-using" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.gridgain.com/resources/webinars/part-1-adding-speed-and-scale-existing-applications-no-rip-and-replace-using"
@@ -2428,8 +3007,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="Bay-Area-In-Memory-Computing-250456740" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="Bay-Area-In-Memory-Computing-250456740" >
                     <div><h3 style="display:inline-block;">Improving Apache Spark™ In-Memory Computing with Apache Ignite®
                         <a href="/events.html#Bay-Area-In-Memory-Computing-250456740" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -2446,13 +3034,11 @@
                         <li>How to leverage Ignite to easily share state across Spark jobs using mutable RDDs and DataFrames</li>
                         <li>How to leverage Ignite distributed SQL and advanced indexing in memory to improve SQL performance</li>
                     </ul>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/Bay-Area-In-Memory-Computing/events/250456740/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.meetup.com/Bay-Area-In-Memory-Computing/events/250456740/"
@@ -2465,8 +3051,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="iot-world-santa-clara" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/conferences.svg" alt="Conferences">
+					<p>Conference</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="iot-world-santa-clara" >
                     <div><h3 style="display:inline-block;">Apache Spark and Apache Ignite: Where Fast Data Meets the IoT
                         <a href="/events.html#iot-world-santa-clara" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -2477,13 +3072,11 @@
                         from the IoT side and will be capable of processing the streams in real-time using Apache Ignite's cluster resources.
                         Attendees will learn about data streaming to an Apache Ignite cluster from embedded devices and real-time data processing with Apache Spark.
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://tmt.knect365.com/iot-world/speakers/denis-magda" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://tmt.knect365.com/iot-world/speakers/denis-magda"
@@ -2496,8 +3089,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="machine-learning-and-deep-learning-apacher-ignitetm" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/webinars.svg" alt="Webinars">
+					<p>Webinars</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="machine-learning-and-deep-learning-apacher-ignitetm" >
                     <div><h3 style="display:inline-block;">Machine Learning and Deep Learning with Apache® Ignite®
                         <a href="/events.html#machine-learning-and-deep-learning-apacher-ignitetm" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -2510,13 +3112,11 @@
                         that are optimized for collocated processing. Learn more about these new capabilities and how
                         to use them in Apache Ignite 2.4.
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.gridgain.com/resources/webinars/machine-learning-and-deep-learning-apacher-ignitetm" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.gridgain.com/resources/webinars/machine-learning-and-deep-learning-apacher-ignitetm"
@@ -2529,8 +3129,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="London-In-Memory-Computing-Meetup-250316825" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetups">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="London-In-Memory-Computing-Meetup-250316825" >
                     <div><h3 style="display:inline-block;">Comparing Apache Ignite and Cassandra for Hybrid Transactional/Analytical Processing (HTAP)
                         <a href="/events.html#London-In-Memory-Computing-Meetup-250316825" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -2543,13 +3152,11 @@
                         accelerate the wrong architecture, or do what other companies have started to do and invest in
                         technologies being used for modern hybrid transactional/analytical processing (HTAP).
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/London-In-Memory-Computing-Meetup/events/250316825/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.meetup.com/London-In-Memory-Computing-Meetup/events/250316825/"
@@ -2562,8 +3169,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="NYC-In-Memory-Computing-Meetup-events-249201183" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetups">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="NYC-In-Memory-Computing-Meetup-events-249201183" >
                     <div><h3 style="display:inline-block;">Comparing Apache Ignite and Cassandra for Hybrid Transactional/Analytical Processing (HTAP)
                         <a href="/events.html#NYC-In-Memory-Computing-Meetup-events-249201183" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -2579,13 +3195,11 @@
                         <li>Architectural best practices, including how in-memory computing fits in and has eliminated tradeoffs between consistency, speed and scale</li>
                         <li>A detailed comparison of Apache Ignite and GridGain® for HTAP applications</li>
                     </ul>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/NYC-In-Memory-Computing-Meetup/events/249201183/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.meetup.com/NYC-In-Memory-Computing-Meetup/events/249201183/"
@@ -2598,8 +3212,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="webinar-improving-apache-spark-in-memory-computing-apache-ignite" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/webinars.svg" alt="Webinars">
+					<p>Webinar</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="webinar-improving-apache-spark-in-memory-computing-apache-ignite" >
                     <div><h3 style="display:inline-block;">Improving Apache Spark™ In-Memory Computing with Apache Ignite®
                         <a href="/events.html#webinar-improving-apache-spark-in-memory-computing-apache-ignite" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -2616,13 +3239,11 @@
                         <li>How to leverage Ignite to easily share state across Spark jobs using mutable RDDs and DataFrames</li>
                         <li>How to leverage Ignite distributed SQL and advanced indexing in memory to improve SQL performance</li>
                     </ul>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.gridgain.com/resources/webinars/improving-apache-spark-in-memory-computing-apache-ignite" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.gridgain.com/resources/webinars/improving-apache-spark-in-memory-computing-apache-ignite"
@@ -2635,8 +3256,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="Bay-Area-In-Memory-Computing-events-248615199" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetups">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="Bay-Area-In-Memory-Computing-events-248615199" >
                     <div><h3 style="display:inline-block;">Comparing Apache Ignite and Cassandra for Hybrid Transactional/Analytical Processing (HTAP)
                         <a href="/events.html#Bay-Area-In-Memory-Computing-events-248615199" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -2652,13 +3282,11 @@
                         <li>Architectural best practices, including how in-memory computing fits in and has eliminated tradeoffs between consistency, speed and scale</li>
                         <li>A detailed comparison of Apache Ignite and GridGain® for HTAP applications</li>
                     </ul>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/Bay-Area-In-Memory-Computing/events/248615199/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.meetup.com/Bay-Area-In-Memory-Computing/events/248615199/"
@@ -2671,8 +3299,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="Apache-Spark-Maryland-events-248437125" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetups">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="Apache-Spark-Maryland-events-248437125" >
                     <div><h3 style="display:inline-block;">Apache Spark and Apache Ignite: Make streaming analytics real with in-memory computing
                         <a href="/events.html#Apache-Spark-Maryland-events-248437125" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -2687,13 +3324,11 @@
                         <li>Process data stored in Ignite with Spark RDDs and DataFrames</li>
                         <li>Speed up SQL queries by leveraging the Ignite SQL engine and indexing</li>
                     </ul>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/Apache-Spark-Maryland/events/248437125/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.meetup.com/Apache-Spark-Maryland/events/248437125/"
@@ -2706,8 +3341,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="NOVA-Data-Science-events-249015197" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetups">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="NOVA-Data-Science-events-249015197" >
                     <div><h3 style="display:inline-block;">Apache Ignite: the in-memory hammer in your data science toolkit.
                         <a href="/events.html#NOVA-Data-Science-events-249015197" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -2718,13 +3362,11 @@
                         the Compute Grid, Data Grid and the Machine Learning Grid. Through examples, attendees will learn how Apache Ignite can be used for data analysis.
 
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/NOVA-Data-Science/events/249015197/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.meetup.com/NOVA-Data-Science/events/249015197/"
@@ -2737,8 +3379,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="DC-Spring-Framework-events-247811860" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetups">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="DC-Spring-Framework-events-247811860" >
                     <div><h3 style="display:inline-block;">Faster data access and processing? Our experiment with Apache Ignite
                         <a href="/events.html#DC-Spring-Framework-events-247811860" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -2747,13 +3398,11 @@
                     <p>
                         Slow database performance is a common complaint for Java developers. Is Apache Ignite the solution? Akmal Chaudhri will cover a few typical use cases and work through some code examples using Apache Ignite.
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/DC-Spring-Framework/events/247811860/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.meetup.com/DC-Spring-Framework/events/247811860/"
@@ -2766,8 +3415,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="big-data-washington-dc-v-20-tickets-42867967244" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetups">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="big-data-washington-dc-v-20-tickets-42867967244" >
                     <div><h3 style="display:inline-block;">The In-Memory Hammer In Your Data Science Toolkit
                         <a href="/events.html#big-data-washington-dc-v-20-tickets-42867967244" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -2778,13 +3436,11 @@
                         such as the Compute Grid, Data Grid and the Machine Learning Grid.
                         Through examples, attendees will learn how Apache Ignite can be used for data analysis.
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.eventbrite.com/e/big-data-washington-dc-v-20-tickets-42867967244" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.eventbrite.com/e/big-data-washington-dc-v-20-tickets-42867967244"
@@ -2797,8 +3453,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="brighttalk-comparing-apacher-ignitetm-and-cassandratm-hybrid-transactional-applications" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/webinars.svg" alt="Webinars">
+					<p>Webinar</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="brighttalk-comparing-apacher-ignitetm-and-cassandratm-hybrid-transactional-applications" >
                     <div><h3 style="display:inline-block;">Comparing Apache® Ignite® and Cassandra™ for Hybrid Transactional Applications (HTAP)
                         <a href="/events.html#brighttalk-comparing-apacher-ignitetm-and-cassandratm-hybrid-transactional-applications" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -2814,13 +3479,11 @@
                         <li>Architectural best practices, including how in-memory computing fits in and has eliminated tradeoffs between consistency, speed and scale</li>
                         <li>A detailed comparison of Apache Ignite and GridGain® for HTAP applications</li>
                     </ul>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.brighttalk.com/webcast/9059/306965?utm_campaign=webcasts-search-results-feed&utm_content=Ignite&utm_source=brighttalk-portal&utm_medium=web" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.brighttalk.com/webcast/9059/306965?utm_campaign=webcasts-search-results-feed&utm_content=Ignite&utm_source=brighttalk-portal&utm_medium=web"
@@ -2833,8 +3496,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="comparing-apacher-ignitetm-and-cassandratm-hybrid-transactional-applications" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/webinars.svg" alt="Webinars">
+					<p>Webinars</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="comparing-apacher-ignitetm-and-cassandratm-hybrid-transactional-applications" >
                     <div><h3 style="display:inline-block;">Comparing Apache® Ignite® and Cassandra™ for Hybrid Transactional Applications (HTAP)
                         <a href="/events.html#comparing-apacher-ignitetm-and-cassandratm-hybrid-transactional-applications" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -2850,13 +3522,11 @@
                         <li>Architectural best practices, including how in-memory computing fits in and has eliminated tradeoffs between consistency, speed and scale</li>
                         <li>A detailed comparison of Apache Ignite and GridGain® for HTAP applications</li>
                     </ul>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.gridgain.com/resources/webinars/comparing-apacher-ignitetm-and-cassandratm-hybrid-transactional-applications" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.gridgain.com/resources/webinars/comparing-apacher-ignitetm-and-cassandratm-hybrid-transactional-applications"
@@ -2869,8 +3539,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="in-memory-computing-essentials-for-data-scientists" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="in-memory-computing-essentials-for-data-scientists" >
                     <div><h3 style="display:inline-block;">In-Memory Computing Essentials for Data Scientists
                         <a href="/events.html#in-memory-computing-essentials-for-data-scientists" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -2881,13 +3560,11 @@
                         boost highly-loaded applications, research projects, risk analysis and fraud detection tasks by
                         storing and processing massive amounts of data in memory and on disk across a cluster of machines.
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://symbion.dk/event/in-memory-computing-essentials-for-data-scientists/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://symbion.dk/event/in-memory-computing-essentials-for-data-scientists/"
@@ -2900,8 +3577,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="apache-ignite-the-in-memory-hammer-in-your-data-science-toolkit" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="apache-ignite-the-in-memory-hammer-in-your-data-science-toolkit" >
                     <div><h3 style="display:inline-block;">Apache Ignite: the in-memory hammer in your data science toolkit
                         <a href="/events.html#apache-ignite-the-in-memory-hammer-in-your-data-science-toolkit" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -2912,13 +3598,11 @@
                         such as the Compute Grid, Data Grid and the Machine Learning Grid.
                         Through examples, attendees will learn how Apache Ignite can be used for data analysis.
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://symbion.dk/event/apache-ignite-the-in-memory-hammer-in-your-data-science-toolkit/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://symbion.dk/event/apache-ignite-the-in-memory-hammer-in-your-data-science-toolkit/"
@@ -2931,8 +3615,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="Atlanta-Apache-Spark-User-Group-events-247807609" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="Atlanta-Apache-Spark-User-Group-events-247807609">
                     <div><h3 style="display:inline-block;">How to Share State Across Multiple Spark Jobs using Apache Ignite
                         <a href="/events.html#Atlanta-Apache-Spark-User-Group-events-247807609" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -2942,13 +3635,11 @@
                         This session will demonstrate how to easily share state in-memory across multiple Spark jobs,
                         either within the same application or between different Spark applications using an implementation of the Spark RDD abstraction provided in Apache Ignite
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/Atlanta-Apache-Spark-User-Group/events/247807609/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.meetup.com/Atlanta-Apache-Spark-User-Group/events/247807609/"
@@ -2961,8 +3652,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="big-bang-Data-science-Solutions-events-247996429" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="big-bang-Data-science-Solutions-events-247996429" >
                     <div><h3 style="display:inline-block;">Apache Ignite: The in-memory hammer in your data science toolkit
                         <a href="/events.html#big-bang-Data-science-Solutions-events-247996429" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -2973,13 +3673,11 @@
                         of Apache Ignite, such as the Compute Grid, Data Grid, and the Machine Learning Grid.
                         Through examples, attendees will learn how Apache Ignite can be used for data analysis.
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/big-bang-Data-science-Solutions/events/247996429/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.meetup.com/big-bang-Data-science-Solutions/events/247996429/"
@@ -2992,8 +3690,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="webinar-choosing-right-in-memory-computing-technology" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/webinars.svg" alt="Webinars">
+					<p>Webinar</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="webinar-choosing-right-in-memory-computing-technology" >
                     <div><h3 style="display:inline-block;">Choosing the Right In-Memory Computing Technology
                         <a href="/events.html#webinar-choosing-right-in-memory-computing-technology" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -3005,13 +3712,11 @@
                         in-memory computing platforms.  But what are the best technologies for each type of project?
                         Learn about your options from one of the leading in-memory computing veterans.
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.gridgain.com/resources/webinars/choosing-right-in-memory-computing-technology" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.gridgain.com/resources/webinars/choosing-right-in-memory-computing-technology"
@@ -3024,8 +3729,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="NYC-In-Memory-Computing-Meetup-events-248077601" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="NYC-In-Memory-Computing-Meetup-events-248077601" >
                     <div><h3 style="display:inline-block;">All the Cool Kids are Doing it: The Whys and Hows of Architecting a Distributed Caching solution for your use case with Apache Ignite
                         <a href="/events.html#NYC-In-Memory-Computing-Meetup-events-248077601" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -3039,13 +3753,11 @@
                         of different technology choices. How to use Kafka, noSQL, RDBMS, Kubernetes and container deployment, Spark,
                         etc will all be discussed in terms of various best practices in architecting the right solution with Apache Ignite.
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/NYC-In-Memory-Computing-Meetup/events/248077601/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.meetup.com/NYC-In-Memory-Computing-Meetup/events/248077601/"
@@ -3058,8 +3770,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="Moscow-Apache-Ignite-Meetup-events-247608182" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="Moscow-Apache-Ignite-Meetup-events-247608182" >
                     <div><h3 style="display:inline-block;">In-Memory Computing Essentials for Architects and Developers - Part 1
                         <a href="/events.html#Moscow-Apache-Ignite-Meetup-events-247608182" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -3077,13 +3798,11 @@
                     <br/>
                     <i>This webinar is in Russian.</i>
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/Moscow-Apache-Ignite-Meetup/events/247608182/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.meetup.com/Moscow-Apache-Ignite-Meetup/events/247608182/"
@@ -3096,8 +3815,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="elciotna18-event-DYLq" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+	 	<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/conferences.svg" alt="Conference">
+					<p>Conference</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="elciotna18-event-DYLq" >
                     <div><h3 style="display:inline-block;">Apache Spark and Apache Ignite: Where Fast Data Meets the IoT
                         <a href="/events.html#elciotna18-event-DYLq" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -3109,13 +3837,11 @@
                         In particular, attendees will learn about data streaming to an Apache Ignite cluster from
                         embedded devices and real-time data processing with Apache Spark.
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://elciotna18.sched.com/event/DYLq" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://elciotna18.sched.com/event/DYLq"
@@ -3128,8 +3854,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="Amsterdam-Java-User-Group-events-246975240" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+	 	<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="Amsterdam-Java-User-Group-events-246975240" >
                     <div><h3 style="display:inline-block;">In-Memory Computing Essentials for Java Developers
                         <a href="/events.html#Amsterdam-Java-User-Group-events-246975240" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -3140,13 +3875,11 @@
                         boost high-load applications and services, and bring existing IT architecture to the next level by
                         storing and processing a massive amount of data both in RAM and, optionally, on disk.
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/Amsterdam-Java-User-Group/events/246975240/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.meetup.com/Amsterdam-Java-User-Group/events/246975240/"
@@ -3159,8 +3892,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="Amsterdam-Java-User-Group-events-244797561" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+	 	<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="Amsterdam-Java-User-Group-events-244797561" >
                     <div><h3 style="display:inline-block;">Catch an intro to the Java-powered Apache Ignite - memory-centric distributed platform
                         <a href="/events.html#Amsterdam-Java-User-Group-events-244797561" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -3172,13 +3914,11 @@
                         Akmal will also cover a few typical use cases and work through some code examples.
                         Hope to see you there so you can leave ready to fire up your database deployments!
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/Amsterdam-Java-User-Group/events/244797561/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.meetup.com/Amsterdam-Java-User-Group/events/244797561/"
@@ -3191,8 +3931,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="Amsterdam-Kubernetes-Meetup-events-247989650" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+	 	<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="Amsterdam-Kubernetes-Meetup-events-247989650" >
                     <div><h3 style="display:inline-block;">Distributed Database DevOps Dilemmas? Kubernetes to the rescue!
                         <a href="/events.html#Amsterdam-Kubernetes-Meetup-events-247989650" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -3206,13 +3955,11 @@
                         in-memory computing platform that is durable, strongly consistent, and highly available with
                         powerful SQL, key-value and processing APIs.
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/Amsterdam-Kubernetes-Meetup/events/247989650/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.meetup.com/Amsterdam-Kubernetes-Meetup/events/247989650/"
@@ -3225,8 +3972,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="BruJUG-events-247929324" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+	 	<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="BruJUG-events-247929324" >
                     <div><h3 style="display:inline-block;">Skyrocket Java applications with the open-source Apache Ignite
                         <a href="/events.html#BruJUG-events-247929324" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -3238,13 +3994,11 @@
                         He’ll also cover a few typical use cases and work through some code examples.
                         Attendees would leave ready to fire up their own database deployments!
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/BruJUG/events/247929324/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.meetup.com/BruJUG/events/247929324/"
@@ -3257,8 +4011,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="webinars-essentials-in-russian-part1" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+	 	<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/webinars.svg" alt="Webinars">
+					<p>Webinars</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="webinars-essentials-in-russian-part1" >
                     <div><h3 style="display:inline-block;">Basics of In-Memory Computing for architects and developers: Part 1
                         <a href="/events.html#webinars-essentials-in-russian-part1" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -3276,13 +4039,11 @@
                         <br/>
                         <i>This webinar is in Russian.</i>
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.gridgain.com/resources/webinars/essentials-in-russian-part1" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.gridgain.com/resources/webinars/essentials-in-russian-part1"
@@ -3295,8 +4056,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="Big-Data-Berlin-events-247348848" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="Big-Data-Berlin-events-247348848" >
                     <div><h3 style="display:inline-block;">The In-Memory Hammer In Your Data Science Toolkit
                         <a href="/events.html#Big-Data-Berlin-events-247348848" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -3307,13 +4077,11 @@
                         such as the Compute Grid, Data Grid and the Machine Learning Grid.
                         Through examples, attendees will learn how Apache Ignite can be used for data analysis.
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/Big-Data-Berlin/events/247348848/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.meetup.com/Big-Data-Berlin/events/247348848/"
@@ -3326,8 +4094,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="Bay-Area-In-Memory-Computing-events-247427747" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="Bay-Area-In-Memory-Computing-events-247427747">
                     <div><h3 style="display:inline-block;">Building consistent and highly available distributed systems with Apache Ignite and GridGain
                         <a href="/events.html#Bay-Area-In-Memory-Computing-events-247427747" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -3342,13 +4119,11 @@
                             <li>Full and incremental snapshots</li>
                         </ul>
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/Bay-Area-In-Memory-Computing/events/247427747/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.meetup.com/Bay-Area-In-Memory-Computing/events/247427747/"
@@ -3361,8 +4136,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="Berlin-Kubernetes-Meetup-events-247357559" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="Berlin-Kubernetes-Meetup-events-247357559" >
                     <div><h3 style="display:inline-block;">Kubernetes: Good, Bad, Ugly of GKE and Distributed Databases in Kubernetes
                         <a href="/events.html#Berlin-Kubernetes-Meetup-events-247357559" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -3377,13 +4161,11 @@
                             <li>Utilizing both RAM and disk - set up Apache Ignite in a way to get in-memory performance with durability of disk</li>
                         </ul>
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/Berlin-Kubernetes-Meetup/events/247357559/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.meetup.com/Berlin-Kubernetes-Meetup/events/247357559/"
@@ -3396,8 +4178,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="ibm-indexconf-sessions" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/conferences.svg" alt="Conference">
+					<p>Conference</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="ibm-indexconf-sessions" >
                     <div><h3 style="display:inline-block;">Apache Spark and Apache Ignite: Where Fast Data Meets the IoT
                         <a href="/events.html#ibm-indexconf-sessions" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -3413,13 +4204,11 @@
                         endless streams from the IoT side and will be capable of processing the streams in
                         real-time using Apache Ignite's cluster resources.
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://developer.ibm.com/indexconf/sessions/#!?id=5554" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://developer.ibm.com/indexconf/sessions/#!?id=5554"
@@ -3432,8 +4221,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="jug-bb-events-247490915" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="jug-bb-events-247490915" >
                     <div><h3 style="display:inline-block;">Skyrocket Java applications with the open-source Apache Ignite
                         <a href="/events.html#jug-bb-events-247490915" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -3446,13 +4244,11 @@
                         and work through some code examples. Attendees would leave ready to fire up their own database deployments!
 
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/jug-bb/events/247490915/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.meetup.com/jug-bb/events/247490915/"
@@ -3465,8 +4261,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="redis-replaced-why-companies-now-choose-apacher-ignitetm" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/webinars.svg" alt="Webinar">
+					<p>Webinar</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="redis-replaced-why-companies-now-choose-apacher-ignitetm" >
                     <div><h3 style="display:inline-block;">GridGain Webinar: Redis Replaced: Why Companies Now Choose Apache® Ignite® to Improve Application Speed and Scale
                         <a href="/events.html#redis-replaced-why-companies-now-choose-apacher-ignitetm" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -3482,13 +4287,11 @@
                             <li>Apache Ignite in-memory storage and collocated computing scales out linearly to avoid scale limitations with traditional caches</li>
                         </ul>
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.gridgain.com/company/news/events/gridgain-webinar-redis-replaced-why-companies-now-choose-apacher-ignitetm" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.gridgain.com/company/news/events/gridgain-webinar-redis-replaced-why-companies-now-choose-apacher-ignitetm"
@@ -3501,8 +4304,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="San-Francisco-Kubernetes-Meetup-events-247330448" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="San-Francisco-Kubernetes-Meetup-events-247330448" >
                     <div><h3 style="display:inline-block;">Deploy like a Boss: Using Kubernetes and Apache Ignite!
                         <a href="/events.html#San-Francisco-Kubernetes-Meetup-events-247330448" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -3515,13 +4327,11 @@
                         Kubernetes helps enable developers to work seamlessly with new versions of their applications, running
                         them where they want with a flexibly scalable experience. Apache Ignite is the perfect complement to this.
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/San-Francisco-Kubernetes-Meetup/events/247330448/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.meetup.com/San-Francisco-Kubernetes-Meetup/events/247330448/"
@@ -3534,9 +4344,18 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="getting-started-apacher-ignitetm-distributed-database" class="page-section news-section">
-                    <div><h3 style="display:inline-block;">Getting Started with Apache® Ignite® as a Distributed Database
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/webinars.svg" alt="Webinars">
+					<p>Webinar</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="getting-started-apacher-ignitetm-distributed-database" >
+                    <div><h3 style="display:inline-block;">Getting Started with Apache® Ignite<sup>®</sup> as a Distributed Database
                         <a href="/events.html#getting-started-apacher-ignitetm-distributed-database" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
                     <span class="news-date">Webinar, Valentin Kulichenko</span><br/><br/>
@@ -3550,13 +4369,11 @@
                             <li>Explain the best practices for configuration and tuning</li>
                         </ul>
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.gridgain.com/resources/webinars/getting-started-apacher-ignitetm-distributed-database" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.gridgain.com/resources/webinars/getting-started-apacher-ignitetm-distributed-database"
@@ -3569,8 +4386,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="Sydney-Cassandra-Users-events-246922765" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="Sydney-Cassandra-Users-events-246922765" >
                     <div><h3 style="display:inline-block;">Ignite your Cassandra Love Story: Caching Cassandra with Apache Ignite
                         <a href="/events.html#Sydney-Cassandra-Users-events-246922765" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -3585,13 +4411,11 @@
                             <li>How companies use this powerful combination to handle extreme OLTP workloads</li>
                         </ul>
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/Sydney-Cassandra-Users/events/246922765/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.meetup.com/Sydney-Cassandra-Users/events/246922765/"
@@ -3604,8 +4428,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="boston-java-events-246725780" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="boston-java-events-246725780" >
                     <div><h3 style="display:inline-block;">Java and In-Memory Computing: Apache Ignite
                         <a href="/events.html#boston-java-events-246725780" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -3618,13 +4451,11 @@
                         and work through some code examples. Attendees would leave ready to fire up their own database deployments!
 
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/boston-java/events/246725780/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.meetup.com/boston-java/events/246725780/"
@@ -3637,8 +4468,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="mysqlbos-events-246021720" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="mysqlbos-events-246021720" >
                     <div><h3 style="display:inline-block;">Turbocharge your MySQL queries in-memory with Apache Ignite
                         <a href="/events.html#mysqlbos-events-246021720" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -3650,13 +4490,11 @@
                         MySQL schema and data from PostgreSQL, supports MySQL indexes, supports compound indexes, and various
                         forms of MySQL queries including distributed MySQL joins.
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/mysqlbos/events/246021720/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.meetup.com/mysqlbos/events/246021720/"
@@ -3669,8 +4507,56 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="London-In-Memory-Computing-Meetup-events-246875000" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="mysqlbos-events-246021720" >
+                    <div><h3 style="display:inline-block;">Turbocharge your MySQL queries in-memory with Apache Ignite
+                        <a href="/events.html#mysqlbos-events-246021720" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
+                    </h3></div>
+                    <span class="news-date">The Boston MySQL Meetup Group, Speaker - Fotios Filacouris</span><br/><br/>
+                    <span class="news-date">Febuary 12, 2018</span>
+                    <p>
+                        Apache Ignite is a unique data management platform that is built on top of a distributed key-value storage
+                        and provides full-fledged MySQL support.Attendees will learn how Apache Ignite handles auto-loading of a
+                        MySQL schema and data from PostgreSQL, supports MySQL indexes, supports compound indexes, and various
+                        forms of MySQL queries including distributed MySQL joins.
+                    </p>
+                    <div class="news-readmore">
+                        <p>
+                            <a href="https://www.meetup.com/mysqlbos/events/246021720/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
+                        </p>
+                    </div>                    <div>
+                        <!-- AddToAny BEGIN -->
+                        <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
+                             data-a2a-url="https://www.meetup.com/mysqlbos/events/246021720/"
+                             data-a2a-title="Turbocharge your MySQL queries in-memory with Apache Ignite">
+                            <a aria-label="Twitter" class="a2a_button_twitter"></a>
+                            <a aria-label="Linkedin" class="a2a_button_linkedin"></a>
+                            <a aria-label="Facebook" class="a2a_button_facebook"></a>
+                            <a aria-label="Add To Any" class="a2a_dd" href="https://www.addtoany.com/share"></a>
+                        </div>
+                        <!-- AddToAny END -->
+                    </div>
+                    <p style="margin:0;">&nbsp;</p>
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="London-In-Memory-Computing-Meetup-events-246875000" >
                     <div><h3 style="display:inline-block;">Building consistent and highly available distributed systems with Apache Ignite and GridGain
                         <a href="/events.html#London-In-Memory-Computing-Meetup-events-246875000" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -3681,13 +4567,11 @@
                         However, there are many applications that require very strong consistency guarantees.
                         Making such applications highly available can be a significant challenge. Akmal will explain how to overcome these challenges.
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/London-In-Memory-Computing-Meetup/events/246875000/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.meetup.com/London-In-Memory-Computing-Meetup/events/246875000/"
@@ -3700,8 +4584,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="apache-ignite-service-grid-foundation-of-your-microservices-based-solution" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/conferences.svg" alt="Conferences">
+					<p>Conferences</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="apache-ignite-service-grid-foundation-of-your-microservices-based-solution" >
                     <div><h3 style="display:inline-block;">Apache Ignite Service Grid: Foundation of Your Microservices-Based Solution
                         <a href="/events.html#apache-ignite-service-grid-foundation-of-your-microservices-based-solution" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -3711,13 +4604,11 @@
                         During this session, Denis will provide a step-by-step guide on how to build a
                         fault-tolerant and scalable microservice-based solution using Apache Ignite's Service Grid and other components to resolve these aforementioned issues.
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://developerweeksfbayarea2018.sched.com/event/D6C7/apache-ignite-service-grid-foundation-of-your-microservices-based-solution" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://developerweeksfbayarea2018.sched.com/event/D6C7/apache-ignite-service-grid-foundation-of-your-microservices-based-solution"
@@ -3730,8 +4621,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="techiteasy-events-245530302" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="techiteasy-events-245530302" >
                     <div><h3 style="display:inline-block;">Meet Apache Ignite In-Memory Computing Platform
                         <a href="/events.html#techiteasy-events-245530302" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -3742,13 +4642,11 @@
                         and processing platform. Roman will explain how one can do distributed computing, and use SQL
                         with horizontal scalability and high availability of NoSQL systems with Apache Ignite.
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/techiteasy/events/245530302/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.meetup.com/techiteasy/events/245530302/"
@@ -3761,8 +4659,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="Los-Angeles-Kubernetes-Meetup-244966244" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="Los-Angeles-Kubernetes-Meetup-244966244" >
                     <div><h3 style="display:inline-block;">Deploy like a Boss: Using Kubernetes and Apache Ignite!
                         <a href="/events.html#Los-Angeles-Kubernetes-Meetup-244966244" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -3775,13 +4682,11 @@
                         By working with containerization Kubernetes helps enable developers to work seamlessly with
                         new versions of their applications, running them where they want with a flexibly scalable experience. Apache Ignite is the perfect complement to this.
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/Los-Angeles-Kubernetes-Meetup/events/244966244/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.meetup.com/Los-Angeles-Kubernetes-Meetup/events/244966244/"
@@ -3794,8 +4699,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="webinar-ignite-fire-in-your-sql-app" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/webinars.svg" alt="Webinar">
+					<p>Webinar</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="webinar-ignite-fire-in-your-sql-app" >
                     <div><h3 style="display:inline-block;">Ignite The Fire In Your SQL App
                         <a href="/events.html#webinar-ignite-fire-in-your-sql-app" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -3807,13 +4721,11 @@
                         and their applications to speed up response times and scale. In other projects they've used it as its own SQL database.
                         This session will dive into some of the best practices for both types of projects using Apache Ignite.
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.gridgain.com/resources/webinars/ignite-fire-in-your-sql-app" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.gridgain.com/resources/webinars/ignite-fire-in-your-sql-app"
@@ -3826,8 +4738,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="BigDataApps-244915185" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="BigDataApps-244915185" >
                     <div><h3 style="display:inline-block;">Apache Spark and Apache Ignite: Where Fast Data Meets the IoT
                         <a href="/events.html#BigDataApps-244915185" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -3838,13 +4759,11 @@
                         receive endless streams from the IoT side and will be capable of processing the streams
                         in real-time using Apache Ignite's cluster resources.
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/BigDataApps/events/244915185/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.meetup.com/BigDataApps/events/244915185/"
@@ -3857,8 +4776,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="NYC-In-Memory-Computing-Meetup-246047934" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="NYC-In-Memory-Computing-Meetup-246047934" >
                     <div><h3 style="display:inline-block;">Building consistent and highly available distributed systems with Apache Ignite and GridGain
                         <a href="/events.html#NYC-In-Memory-Computing-Meetup-246047934" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -3871,13 +4799,11 @@
                         attendees will be given an overview of Apache Ignite and GridGain capabilities
                         that allow the delivery of high availability, while not breaking data consistency.
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/NYC-In-Memory-Computing-Meetup/events/246047934/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.meetup.com/NYC-In-Memory-Computing-Meetup/events/246047934/"
@@ -3890,8 +4816,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="scale-out-and-conquer-architectural-decisions-behind-distributed-in-memory" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/webinars.svg" alt="Webinar">
+					<p>Webinar</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="scale-out-and-conquer-architectural-decisions-behind-distributed-in-memory" >
                     <div><h3 style="display:inline-block;">Scale Out and Conquer: Architectural Decisions Behind Distributed In-Memory Systems
                         <a href="/events.html#scale-out-and-conquer-architectural-decisions-behind-distributed-in-memory" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -3902,13 +4837,11 @@
                         add more machines to achieve near-linear, elastic scalability. But how does it really work? What are its limits?
                         And how can you optimize performance and scalability?
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.gridgain.com/resources/webinars/scale-out-and-conquer-architectural-decisions-behind-distributed-in-memory" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.gridgain.com/resources/webinars/scale-out-and-conquer-architectural-decisions-behind-distributed-in-memory"
@@ -3921,8 +4854,19 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="niketechtalksdec2017" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+	</div>
+	<div class="tab-pane" id="2017">
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/conferences.svg" alt="Conference">
+					<p>Conference</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="niketechtalksdec2017" >
                     <div><h3 style="display:inline-block;">Getting Started With Apache Ignite
                         <a href="/events.html#niketechtalksdec2017" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -3934,13 +4878,11 @@
                         During this session, we will do a deep-dive into the Apache Ignite architecture and discuss
                         how it is being deployed around the globe. You will walk away knowing why and when to use Apache Ignite in your next data intensive application!
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://niketechtalksdec2017.splashthat.com/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://niketechtalksdec2017.splashthat.com/"
@@ -3953,8 +4895,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="Bay-Area-In-Memory-Computing-events-245196260" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="Bay-Area-In-Memory-Computing-events-245196260" >
                     <div><h3 style="display:inline-block;">Want extreme performance at scale? Do distributed the RIGHT way!
                         <a href="/events.html#Bay-Area-In-Memory-Computing-events-245196260" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -3970,13 +4921,11 @@
                         What is affinity colocation and how does it help to improve performance?
                         How does affinity colocation affects execution of distributed computations and distributed SQL queries? And more...
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/Bay-Area-In-Memory-Computing/events/245196260/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.meetup.com/Bay-Area-In-Memory-Computing/events/245196260/"
@@ -3989,8 +4938,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="in-memory-computing-essentials-architects-and-developers-part-2" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/webinar.svg" alt="Webinar">
+					<p>Webinar</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="in-memory-computing-essentials-architects-and-developers-part-2" >
                     <div><h3 style="display:inline-block;">In-Memory Computing Essentials for Architects and Developers: Part 2
                         <a href="/events.html#in-memory-computing-essentials-architects-and-developers-part-2" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -4006,13 +4964,11 @@
                         <li>Collocated processing for SQL (distributed joins and more)</li>
                         <li>Distributed persistence usage</li>
                     </ul>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.gridgain.com/resources/webinars/in-memory-computing-essentials-architects-and-developers-part-2" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.gridgain.com/resources/webinars/in-memory-computing-essentials-architects-and-developers-part-2"
@@ -4025,8 +4981,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="Moscow-Apache-Ignite-Meetup-events-245332076" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="Moscow-Apache-Ignite-Meetup-events-245332076" >
                     <div><h3 style="display:inline-block;">Apache Ignite Use Cases for Banks and Telecoms
                         <a href="/events.html#Moscow-Apache-Ignite-Meetup-events-245332076" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -4035,13 +5000,11 @@
                     <p>
                         Welcome to the inaugural gathering of the Moscow Apache® Ignite® Meetup! Our guest experts -  Mikhail Kuznetzov, Mikhail Khasin, and Victor Khoodyakov will talk about their experiences implementing solutions for a large bank as well as a telecom company, based on Apache Ignite.
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/Moscow-Apache-Ignite-Meetup/events/245332076/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.meetup.com/Moscow-Apache-Ignite-Meetup/events/245332076/"
@@ -4054,8 +5017,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="kccncna17-event-D3vE" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/conferences.svg" alt="Conferences">
+					<p>Conference</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="kccncna17-event-D3vE" >
                     <div><h3 style="display:inline-block;">Distributed Database DevOps Dilemmas? Kubernetes to the Rescue
                         <a href="/events.html#kccncna17-event-D3vE" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -4072,13 +5044,11 @@
                         <li>Database Availability - what’s the role of Kubernetes and the database.</li>
                         <li>Utilizing both RAM and disk - set up Apache Ignite in a way to get in-memory performance with durability of disk.</li>
                     </ul>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://kccncna17.sched.com/event/D3vE" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://kccncna17.sched.com/event/D3vE"
@@ -4091,8 +5061,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="austin-data-meetup-events-245472777" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="austin-data-meetup-events-245472777" >
                     <div><h3 style="display:inline-block;">Apache Ignite: the in-memory hammer in your data science toolkit
                         <a href="/events.html#austin-data-meetup-events-245472777" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -4112,13 +5091,11 @@
                         attendees will learn how Apache Ignite can be used for data analysis.
 
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/austindata/events/245472777/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.meetup.com/austindata/events/245472777/"
@@ -4131,8 +5108,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="meeting-challenges-fast-data-in-healthcare-in-memory-technologies" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/webinars.svg" alt="Webinars">
+					<p>Webinar</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="meeting-challenges-fast-data-in-healthcare-in-memory-technologies" >
                     <div><h3 style="display:inline-block;">Meeting the Challenges of Fast Data in Healthcare with In-Memory Technologies
                         <a href="/events.html#meeting-challenges-fast-data-in-healthcare-in-memory-technologies" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -4142,13 +5128,11 @@
                         In this webinar, Akmal Chaudhri will discuss the requirements for fast data in healthcare and specifically
                         how Apache Ignite, a distributed in-memory computing platform, is used by drug discovery companies to identify potential therapies for complex diseases.
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.gridgain.com/resources/webinars/meeting-challenges-fast-data-in-healthcare-in-memory-technologies" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.gridgain.com/resources/webinars/meeting-challenges-fast-data-in-healthcare-in-memory-technologies"
@@ -4161,8 +5145,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="implementing-durable-memory-centric-architectures-in-large-financial" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/webinars.svg" alt="Webinars">
+					<p>Webinar</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="implementing-durable-memory-centric-architectures-in-large-financial" >
                     <div><h3 style="display:inline-block;">Implementing Durable Memory-Centric Architectures in Large Financial <br/>Institutions
                         <a href="/events.html#implementing-durable-memory-centric-architectures-in-large-financial" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -4177,13 +5170,11 @@
                         architecture and demonstrate the 5 major challenges that Sberbank ran into when integrating distributed,
                         horizontally scalable memory-centric database at their bank.
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.gridgain.com/resources/webinars/implementing-durable-memory-centric-architectures-in-large-financial" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.gridgain.com/resources/webinars/implementing-durable-memory-centric-architectures-in-large-financial"
@@ -4196,8 +5187,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="in-memory-computing-essentials-architects-and-developers-part-1" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/webinars.svg" alt="Webinars">
+					<p>Webinar</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="in-memory-computing-essentials-architects-and-developers-part-1" >
                     <div><h3 style="display:inline-block;">In-Memory Computing Essentials for Architects and Developers: Part 1
                         <a href="/events.html#in-memory-computing-essentials-architects-and-developers-part-1" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -4212,13 +5212,11 @@
                         <li>Data processing with key-value APIs</li>
                         <li>Data processing with SQL</li>
                     </ul>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.gridgain.com/resources/webinars/in-memory-computing-essentials-architects-and-developers-part-1" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.gridgain.com/resources/webinars/in-memory-computing-essentials-architects-and-developers-part-1"
@@ -4231,8 +5229,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="datariders-events-243704486" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="datariders-events-243704486" >
                     <div><h3 style="display:inline-block;">Hands-on Workshop: In-Memory Computing Essentials for Java Developers
                         <a href="/events.html#datariders-events-243704486" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -4245,13 +5252,11 @@
                         The capabilities and benefits of such platforms will be demonstrated with the usage of Apache Ignite,
                         which is the in-memory computing platform that is durable, strongly consistent, and highly available with powerful SQL, key-value and processing APIs.
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/preview/datariders/events/243704486" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.meetup.com/preview/datariders/events/243704486"
@@ -4264,8 +5269,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="devoxx-Apache_Spark_and_Apache_Ignite:_Where_Fast_Data_Meets_the_IoT" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/conferences.svg" alt="Conferences">
+					<p>Conferences</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="devoxx-Apache_Spark_and_Apache_Ignite:_Where_Fast_Data_Meets_the_IoT" >
                     <div><h3 style="display:inline-block;">Apache Spark and Apache Ignite: Where Fast Data Meets the IoT
                         <a href="/events.html#devoxx-Apache_Spark_and_Apache_Ignite:_Where_Fast_Data_Meets_the_IoT" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -4280,13 +5294,11 @@
                         IoT side and will be capable of processing the streams in real-time using Apache Ignite's cluster resources. In particular, attendees will learn
                         about data streaming to an Apache Ignite cluster from embedded devices and real-time data processing with Apache Spark.
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://cfp.devoxx.ma/2017/talk/RYX-3007/Apache_Spark_and_Apache_Ignite:_Where_Fast_Data_Meets_the_IoT" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://cfp.devoxx.ma/2017/talk/RYX-3007/Apache_Spark_and_Apache_Ignite:_Where_Fast_Data_Meets_the_IoT"
@@ -4299,8 +5311,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="devoxx-How_to_build_an_event-driven_dynamically_re-configurable_micro-services_platform" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/conferences.svg" alt="Conferences">
+					<p>Conferences</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="devoxx-How_to_build_an_event-driven_dynamically_re-configurable_micro-services_platform" >
                     <div><h3 style="display:inline-block;">How to build an event-driven, dynamically re-configurable micro-services platform
                         <a href="/events.html#How_to_build_an_event-driven_dynamically_re-configurable_micro-services_platform" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -4312,13 +5333,11 @@
                     <p>
                         In this presentation, Sven will show you how to combine Apache Ignite with Docker to not only build an event-driven microservice platform but also to make this dynamically re-configurable without any downtime at all.
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://cfp.devoxx.be/2017/talk/YPK-6082/How_to_build_an_event-driven_dynamically_re-configurable_micro-services_platform" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://cfp.devoxx.be/2017/talk/YPK-6082/How_to_build_an_event-driven_dynamically_re-configurable_micro-services_platform"
@@ -4331,8 +5350,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="odsc-apache-ignite-memory-hammer-data-science-toolkit-2" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/conferences.svg" alt="Conferences">
+					<p>Conferences</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="odsc-apache-ignite-memory-hammer-data-science-toolkit-2" >
                     <div><h3 style="display:inline-block;">Apache Ignite: The In-Memory Hammer In Your Data Science Toolkit&nbsp;
                         <a href="/events.html#odsc-apache-ignite-memory-hammer-data-science-toolkit-2" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -4349,13 +5377,11 @@
                         Data Grid and the Machine Learning Grid. Through examples, attendees will learn how Apache Ignite can be used for data analysis.
                     </p>
 
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://odsc.com/training/portfolio/apache-ignite-memory-hammer-data-science-toolkit-2" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://odsc.com/training/portfolio/apache-ignite-memory-hammer-data-science-toolkit-2"
@@ -4368,8 +5394,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="sydney-ibm-bluemix-meetup-group" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="sydney-ibm-bluemix-meetup-group" >
                     <div><h3 style="display:inline-block;">Fast Data meets Big Data in the IoT- Using Apache Ignite&nbsp;
                         <a href="/events.html#sydney-ibm-bluemix-meetup-group" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -4383,13 +5418,11 @@
                         how Apache Ignite can meet those requirements. Rachel will also cover other design options like NoSQL and Spark and how to deploy in the IBM cloud.
                     </p>
 
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.gridgain.com/company/news/events/sydney-ibm-bluemix-meetup-group" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.gridgain.com/company/news/events/sydney-ibm-bluemix-meetup-group"
@@ -4402,8 +5435,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="Bay-Area-In-Memory-Computing-243868747" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="Bay-Area-In-Memory-Computing-243868747" >
                     <div><h3 style="display:inline-block;">Achieving High Availability and Consistency With Distributed Systems&nbsp;
                         <a href="/events.html#Bay-Area-In-Memory-Computing-243868747" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -4416,13 +5458,11 @@
                     <p>
                         Tech talk No. 2 - Denis continues the knowledge sharing with a session titled, "Harnessing the 21st Century with a Distributed Memory-Centric SQL."
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/Bay-Area-In-Memory-Computing/events/243868747/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.meetup.com/Bay-Area-In-Memory-Computing/events/243868747/"
@@ -4435,8 +5475,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="Dublin-Spark-Meetup-events-243875410" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="Dublin-Spark-Meetup-events-243875410" >
                     <div><h3 style="display:inline-block;">Apache Spark and Apache Ignite: Where Fast Data Meets the IoT&nbsp;
                         <a href="/events.html#Dublin-Spark-Meetup-events-243875410" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -4447,13 +5496,11 @@
                         IoT side and will be capable of processing the streams in real-time using Apache Ignite's cluster resources. In particular,
                         attendees will learn about data streaming to an Apache Ignite cluster from embedded devices and real-time data processing with Apache Spark.
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/Dublin-Spark-Meetup/events/243875410/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.meetup.com/Dublin-Spark-Meetup/events/243875410/"
@@ -4466,8 +5513,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="spark-summit-eu-2017-how-to-share-state" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/conferences.svg" alt="Conferences">
+					<p>Conference</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="spark-summit-eu-2017-how-to-share-state" >
                     <div><h3 style="display:inline-block;">How to Share State Across Multiple Spark Jobs using Apache® Ignite®&nbsp;
                         <a href="/events.html#spark-summit-eu-2017-how-to-share-state" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -4481,13 +5537,11 @@
                         applications and workers. Examples will show how IgniteRDD, with its advanced in-memory indexing capabilities,
                         allows execution of SQL queries many times faster than native Spark RDDs or Data Frames.
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://spark-summit.org/eu-2017/events/how-to-share-state-across-multiple-apache-spark-jobs-using-apache-ignite/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://spark-summit.org/eu-2017/events/how-to-share-state-across-multiple-apache-spark-jobs-using-apache-ignite/"
@@ -4500,8 +5554,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="imc-summit-2017" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/conferences.svg" alt="Conferences">
+					<p>Conference</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="imc-summit-2017" >
                     <div><h3 style="display:inline-block;">The In-Memory Computing Summit 2017 – North America&nbsp;
                         <a href="/events.html#imc-summit-2017" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -4513,13 +5576,11 @@
                         on the full range of in-memory computing-related technologies and solutions held in North America.
                     </p>
                     <p>Check out the agenda here: <a href="https://www.imcsummit.org/us/agenda/schedule/day-1">https://www.imcsummit.org/us/agenda/schedule/day-1</a></p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.imcsummit.org/us/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.imcsummit.org/us/"
@@ -4532,8 +5593,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="Eurostaff-Big-Data-243650721" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="Eurostaff-Big-Data-243650721" >
                     <div><h3 style="display:inline-block;">Better Machine Learning with Apache® Ignite®&nbsp;
                         <a href="/events.html#Eurostaff-Big-Data-243650721" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -4547,13 +5617,11 @@
                     <p>
                         Through examples, attendees will learn how Apache Ignite can be used for data analysis and be the in-memory hammer in your machine learning toolkit.
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/Eurostaff-Big-Data/events/243650721/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.meetup.com/Eurostaff-Big-Data/events/243650721/"
@@ -4566,8 +5634,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="sv-jug-events-242946746" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="sv-jug-events-242946746" >
                     <div><h3 style="display:inline-block;">Catch an intro to Apache Ignite and skyrocket Java applications&nbsp;
                         <a href="/events.html#sv-jug-events-242946746" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -4579,13 +5656,11 @@
                         He will also cover a few typical use cases and work through some code examples.
                         Hope to see you there so you can leave ready to fire up your database deployments!
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/preview/sv-jug/events/242946746" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.meetup.com/preview/sv-jug/events/242946746"
@@ -4598,8 +5673,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="apacher-sparktm-and-apacher-ignitetm-where-fast-data-meets-iot" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/webinars.svg" alt="Webinars">
+					<p>Webinar</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="apacher-sparktm-and-apacher-ignitetm-where-fast-data-meets-iot" >
                     <div><h3 style="display:inline-block;">Apache® Spark™ and Apache® Ignite®: Where Fast Data Meets the IoT&nbsp;
                         <a href="/events.html#apacher-sparktm-and-apacher-ignitetm-where-fast-data-meets-iot" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -4610,13 +5694,11 @@
                         from the Internet of Things (IoT) and be capable of processing the streams in real-time using Apache Ignite’s cluster resources.
                         You will also learn about data streaming to an Apache Ignite® cluster from embedded devices and real-time data processing with Apache® Spark™.
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.gridgain.com/resources/webinars/apacher-sparktm-and-apacher-ignitetm-where-fast-data-meets-iot" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.gridgain.com/resources/webinars/apacher-sparktm-and-apacher-ignitetm-where-fast-data-meets-iot"
@@ -4629,8 +5711,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="odsc-europe-2017-apache-ignite-memory-hammer-data-science-toolkit" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/conferences.svg" alt="Conferences">
+					<p>Conference</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="odsc-europe-2017-apache-ignite-memory-hammer-data-science-toolkit" >
                     <div><h3 style="display:inline-block;">Apache Ignite®: The In-Memory Hammer in Your Data Science Toolkit&nbsp;
                         <a href="/events.html#odsc-europe-2017-apache-ignite-memory-hammer-data-science-toolkit" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -4641,13 +5732,11 @@
                         such as the Compute Grid, Data Grid and the Machine Learning Grid. Through examples,
                         attendees will learn how Apache Ignite can be used for data analysis.
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://odsc.com/training/portfolio/apache-ignite-memory-hammer-data-science-toolkit" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://odsc.com/training/portfolio/apache-ignite-memory-hammer-data-science-toolkit"
@@ -4660,8 +5749,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="london-bigdataweek-powering-banks-financial-institutions-distributed-systems" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/conferences.svg" alt="Conferences">
+					<p>Conference</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="london-bigdataweek-powering-banks-financial-institutions-distributed-systems" >
                     <div><h3 style="display:inline-block;">Powering up banks and financial institutions with distributed systems&nbsp;
                         <a href="/events.html#london-bigdataweek-powering-banks-financial-institutions-distributed-systems" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -4675,13 +5773,11 @@
                         A customer case study will also be presented. We will analyze one of the largest Apache Ignite deployments in the world at Sberbank,
                         a Russian and Eastern European Bank, by walking through the overall architecture and demonstrating various implementation and deployment challenges.
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="http://london.bigdataweek.com/session/powering-banks-financial-institutions-distributed-systems/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="http://london.bigdataweek.com/session/powering-banks-financial-institutions-distributed-systems/"
@@ -4694,8 +5790,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="dataplatform-jp" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/conferences.svg" alt="Conferences">
+					<p>Conference</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="dataplatform-jp" >
                     <div><h3 style="display:inline-block;">Real-time Data Analysis with Apache Ignite High-Performance In-memory Platform&nbsp;
                         <a href="/events.html#dataplatform-jp" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -4709,13 +5814,11 @@
                     <p>
                         In this session, Roman will introduce Apache Ignite, and explain how it can be used for real-time analysis of large volumes of IoT data.
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="http://dataplatform.jp/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="http://dataplatform.jp/"
@@ -4728,8 +5831,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="webinar-postgres-apacher-ignitetm" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/webinars.svg" alt="Webinar">
+					<p>Webinar</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="webinar-postgres-apacher-ignitetm" >
                     <div><h3 style="display:inline-block;">Postgres with Apache® Ignite®: Faster Transactions and Analytics&nbsp;
                         <a href="/events.html#webinar-postgres-apacher-ignitetm" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -4744,13 +5856,11 @@
                         <li>How to use Apache Ignite as an advanced high-performance cache platform for hot data</li>
                     </ul>
 
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.gridgain.com/resources/webinars/postgres-apacher-ignitetm-faster-transactions-and-analytics" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.gridgain.com/resources/webinars/postgres-apacher-ignitetm-faster-transactions-and-analytics"
@@ -4763,8 +5873,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="Paris-Spark-Meetup-243673170" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="Paris-Spark-Meetup-243673170" >
                     <div><h3 style="display:inline-block;">Apache Spark and Apache Ignite: Where Fast Data Meets the IoT&nbsp;
                         <a href="/events.html#Paris-Spark-Meetup-243673170" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -4775,13 +5894,11 @@
                         IoT side and will be capable of processing the streams in real-time using Apache Ignite's cluster resources. In particular,
                         attendees will learn about data streaming to an Apache Ignite cluster from embedded devices and real-time data processing with Apache Spark.
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/Paris-Spark-Meetup/events/243673170/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.meetup.com/Paris-Spark-Meetup/events/243673170/"
@@ -4794,8 +5911,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="Big-Data-Developers-in-Paris-243327509" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="Big-Data-Developers-in-Paris-243327509" >
                     <div><h3 style="display:inline-block;">Giving a boost to the Hadoop and Spark ecosystems with in-memory technologies&nbsp;
                         <a href="/events.html#Big-Data-Developers-in-Paris-243327509" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -4807,13 +5933,11 @@
                         Hadoop Accelerator, HDFS compliant In-Memory File System, MapReduce Accelerator, Spark Shared RDDs, Spark SQL boost.
 
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/preview/Big-Data-Developers-in-Paris/events/243327509" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.meetup.com/preview/Big-Data-Developers-in-Paris/events/243327509"
@@ -4826,8 +5950,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="New-York-Kubernetes-Meetup-242597746" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="New-York-Kubernetes-Meetup-242597746" >
                     <div><h3 style="display:inline-block;">Stateful Apps in Production and Distributed Database Orchestration&nbsp;
                         <a href="/events.html#New-York-Kubernetes-Meetup-242597746" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -4837,13 +5970,11 @@
                         This talk will focus on a DevOps perspective on the orchestration of distributed databases, Apache Ignite.
                         Denis will speak on node auto-discovery, automated horizontal scalability, availability and utilization of RAM and disk with Apache Ignite.
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/New-York-Kubernetes-Meetup/events/242597746/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.meetup.com/New-York-Kubernetes-Meetup/events/242597746/"
@@ -4856,8 +5987,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="better-machine-learning-apacher-ignitetm" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/webinars.svg" alt="Webinars">
+					<p>Webinar</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="better-machine-learning-apacher-ignitetm" >
                     <div><h3 style="display:inline-block;">Better Machine Learning with Apache® Ignite®&nbsp;
                         <a href="/events.html#better-machine-learning-apacher-ignitetm" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -4868,13 +6008,11 @@
                         to enable your business to start reaping the benefits of machine learning. Through examples, attendees will learn how Apache Ignite
                         can be used for data analysis and be the in-memory hammer in your machine learning toolkit.
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.gridgain.com/resources/webinars/better-machine-learning-apacher-ignitetm" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.gridgain.com/resources/webinars/better-machine-learning-apacher-ignitetm"
@@ -4887,8 +6025,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="NYC-In-Memory-Computing-Meetup-243150945" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="NYC-In-Memory-Computing-Meetup-243150945" >
                     <div><h3 style="display:inline-block;">Powering up banks and financial institutions with distributed systems&nbsp;
                         <a href="/events.html#NYC-In-Memory-Computing-Meetup-243150945" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -4899,13 +6046,11 @@
                         Then he'll introduce the open-source Apache Ignite, an in-memory computing platform that enables high-performance transactions,
                         real-time streaming, and fast analytics in a single, comprehensive data access and processing layer.
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/NYC-In-Memory-Computing-Meetup/events/243150945/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.meetup.com/NYC-In-Memory-Computing-Meetup/events/243150945/"
@@ -4918,8 +6063,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="internet-things-iot-new-york-meetup" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="internet-things-iot-new-york-meetup" >
                     <div><h3 style="display:inline-block;">Apache Spark and Apache Ignite: Where Fast Data Meets the IoT&nbsp;
                         <a href="/events.html#NYC-In-Memory-Computing-Meetup-243150945" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -4930,13 +6084,11 @@
                         In this session, Akmal will show attendees how to build a Fast Data solution that will receive endless streams from the IoT
                         side and will be capable of processing the streams in real-time using Apache Ignite's cluster resources.
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.gridgain.com/company/news/events/internet-things-iot-new-york-meetup" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.gridgain.com/company/news/events/internet-things-iot-new-york-meetup"
@@ -4949,42 +6101,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="SF-Spark-and-Friends-242935496" class="page-section news-section">
-                    <div><h3 style="display:inline-block;">Apache Spark, Apache Flink, and Apache Ignite: Where Fast Data Meets the IoT&nbsp;
-                        <a href="/events.html#SF-Spark-and-Friends-242935496" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
-                    </h3></div>
-                    <span class="news-date">Meetup, San Francisco, CA, Speaker - Denis Magda</span><br/><br/>
-                    <span class="news-date">September 20, 2017</span>
-                    <p>
-                        This session will show attendees how to build a Fast Data solution that will receive endless streams from the IoT side and
-                        will be capable of processing the streams in real-time using Apache Ignite's cluster resources.
-                    </p>
-                    <p>
-                        In particular, attendees will learn about data streaming to an Apache Ignite cluster from embedded
-                        devices and real-time data processing with Apache Flink.
-                    </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
-                        <p>
-                            <a href="https://www.meetup.com/SF-Spark-and-Friends/events/242935496/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
-                        </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
-                        <!-- AddToAny BEGIN -->
-                        <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
-                             data-a2a-url="https://www.meetup.com/SF-Spark-and-Friends/events/242935496/"
-                             data-a2a-title="Apache Spark, Apache Flink, and Apache Ignite: Where Fast Data Meets the IoT">
-                            <a aria-label="Twitter" class="a2a_button_twitter"></a>
-                            <a aria-label="Linkedin" class="a2a_button_linkedin"></a>
-                            <a aria-label="Facebook" class="a2a_button_facebook"></a>
-                            <a aria-label="Add To Any" class="a2a_dd" href="https://www.addtoany.com/share"></a>
-                        </div>
-                        <!-- AddToAny END -->
-                    </div>
-                    <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="Cambridge-NET-User-Group-238837204" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="Cambridge-NET-User-Group-238837204" >
                     <div><h3 style="display:inline-block;">Business Intelligence and Apache Ignite for .NET Users&nbsp;
                         <a href="/events.html#Cambridge-NET-User-Group-238837204" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -4995,13 +6122,11 @@
                         Apache Ignite is the memory-centric platform that combines distributed SQL database and key-value data grid,
                         that is ACID compliant, horizontally scalable and highly available, and empowered with compute and machine learning capabilities.
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/Cambridge-NET-User-Group/events/238837204/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.meetup.com/Cambridge-NET-User-Group/events/238837204/"
@@ -5014,8 +6139,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="SF-Big-Analytics-242368299" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="SF-Big-Analytics-242368299" >
                     <div><h3 style="display:inline-block;">Apache Ignite: The in-memory hammer in your data science toolkit&nbsp;
                         <a href="/events.html#SF-Big-Analytics-242368299" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -5025,13 +6159,11 @@
                         In this talk, Denis will go through some of the main components of Apache Ignite, such as the Compute Grid, Data Grid and the Machine Learning Grid.
                         Through examples, attendees will learn how Apache Ignite can be used for big data analysis.
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/SF-Big-Analytics/events/242368299/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.meetup.com/SF-Big-Analytics/events/242368299/"
@@ -5044,8 +6176,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="webinar-5573556767611108099" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/webinars.svg" alt="Webinars">
+					<p>Webinar</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="webinar-5573556767611108099" >
                     <div><h3 style="display:inline-block;">Implementing In-Memory Computing for Financial Services Use Cases with Apache® Ignite®&nbsp;
                         <a href="/events.html#SF-Big-Analytics-242368299" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -5062,13 +6203,11 @@
                         <li>Fault tolerance</li>
                         <li>Persistence</li>
                     </ul>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://register.gotowebinar.com/register/5573556767611108099" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://register.gotowebinar.com/register/5573556767611108099"
@@ -5081,8 +6220,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="big-data-and-cloud-meetup-santa-clara-242523245" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="big-data-and-cloud-meetup-santa-clara-242523245" >
                     <div><h3 style="display:inline-block;">Apache Spark and Apache Ignite: Where Fast Data Meets the IoT&nbsp;
                         <a href="/events.html#big-data-and-cloud-meetup-santa-clara-242523245" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -5092,13 +6240,11 @@
                         In his talk, Denis will will show attendees how to build a sast Data solution that will receive endless streams from
                         the IoT side and will be capable of processing the streams in real-time using the cluster resources of Apache Ignite.
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/datariders/events/242523245/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.meetup.com/datariders/events/242523245/"
@@ -5111,8 +6257,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="deploy-boss-using-kubernetesr-and-apacher-ignitetm" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/webinars.svg" alt="Webinar">
+					<p>Webinar</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="deploy-boss-using-kubernetesr-and-apacher-ignitetm" >
                     <div><h3 style="display:inline-block;">Deploy like a Boss: Using Kubernetes® and Apache® Ignite®&nbsp;
                         <a href="/events.html#deploy-boss-using-kubernetesr-and-apacher-ignitetm" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -5132,13 +6287,11 @@
                         <li>Adjusting the Ignite Cluster Size when you need to scale</li>
                     </ul>
 
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="http://info.gridgain.com/r40u0R2G0WUmSWT9S00K030" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="http://info.gridgain.com/r40u0R2G0WUmSWT9S00K030"
@@ -5151,8 +6304,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="big-community-webinar-2423316315303466241" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/webinars.svg" alt="Webinar">
+					<p>Webinar</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="big-community-webinar-2423316315303466241" >
                     <div><h3 style="display:inline-block;">Introduction to Apache Ignite, a memory-centric distributed platform&nbsp;
                         <a href="/events.html#big-community-webinar-2423316315303466241" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -5167,13 +6329,11 @@
                         In this webinar, attendees will learn about the many components of Apache  Ignite, including the Data Grid, Compute Grid,
                         distributed SQL database and the Machine Learning Grid. We will also cover a few typical use cases and work through some Java code examples.
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://register.gotowebinar.com/register/2423316315303466241" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://register.gotowebinar.com/register/2423316315303466241"
@@ -5186,8 +6346,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="building-consistent-and-highly-available-distributed-systems" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/webinars.svg" alt="Webinar">
+					<p>Webinar</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="building-consistent-and-highly-available-distributed-systems" >
                     <div><h3 style="display:inline-block;">Building Consistent and Highly Available Distributed Systems with Apache® Ignite®&nbsp;
                         <a href="/events.html#building-consistent-and-highly-available-distributed-systems" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a>
                     </h3></div>
@@ -5204,13 +6373,11 @@
                         <li>Data center replication</li>
                         <li>Full and incremental snapshots</li>
                     </ul>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.gridgain.com/resources/webinars/building-consistent-and-highly-available-distributed-systems-apacher-ignitetm" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.gridgain.com/resources/webinars/building-consistent-and-highly-available-distributed-systems-apacher-ignitetm"
@@ -5223,9 +6390,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-
-                <section id="Bay-Area-In-Memory-Computing-241381155" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="Bay-Area-In-Memory-Computing-241381155" >
                     <div><h3 style="display:inline-block;">Diving into the internals of Apache Ignite's memory architecture&nbsp;<a href="/events.html#Bay-Area-In-Memory-Computing-241381155" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a></h3></div>
                     <span class="news-date">Meetup, Denis Magda</span><br/><br/>
                     <span class="news-date">Jul 27, 2017</span>
@@ -5235,13 +6410,11 @@
                         and blending a distributed SQL database with an in-memory key-value data grid.
                     </p>
 
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/Bay-Area-In-Memory-Computing/events/241381155/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.meetup.com/Bay-Area-In-Memory-Computing/events/241381155/"
@@ -5254,9 +6427,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-
-                <section id="Brighton-Java-241395191" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="Brighton-Java-241395191" >
                     <div><h3 style="display:inline-block;">An Intro to Apache Ignite, the Memory-centric Distributed Platform&nbsp;<a href="/events.html#Brighton-Java-241395191" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a></h3></div>
                     <span class="news-date">Meetup, Akmal Chaudhri</span><br/><br/>
                     <span class="news-date">July 26, 2017</span>
@@ -5266,13 +6447,11 @@
                         He will also cover a few typical use cases and work through some code examples.
                     </p>
 
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/Brighton-Java/events/241395191/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.meetup.com/Brighton-Java/events/241395191/"
@@ -5285,9 +6464,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-
-                <section id="distributed-acid-transactions-apache-ignite" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="distributed-acid-transactions-apache-ignite" >
                     <div><h3 style="display:inline-block;">Distributed ACID Transactions in Apache Ignite&nbsp;<a href="/events.html#" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a></h3></div>
                     <span class="news-date">Webinar, Akmal Chaudhri</span><br/><br/>
                     <span class="news-date">July 19, 2017</span>
@@ -5302,13 +6489,11 @@
                         <li>Deadlock-free transactions</li>
                         <li>Deadlock detection mechanism</li>
                     </ul>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.gridgain.com/resources/webinars/distributed-acid-transactions-apache-ignite" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.gridgain.com/resources/webinars/distributed-acid-transactions-apache-ignite"
@@ -5321,9 +6506,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-
-                <section id="SQL-queries-meetup-amsterdam" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="SQL-queries-meetup-amsterdam" >
                     <div><h3 style="display:inline-block;">Turbocharge your SQL queries in-memory with Apache® Ignite®&nbsp;<a href="/events.html#SQL-queries-meetup-amsterdam" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a></h3></div>
                     <span class="news-date">Meetup, Amsterdam, Netherlands, Speaker - Denis Magda</span><br/><br/>
                     <span class="news-date">June 20, 2017 @6:30pm</span>
@@ -5339,13 +6532,11 @@
                         <li>Boost application performance 1,000x and scale to over 1 billion transactions per second with in-memory storage of hundreds
                             of TB's of data for your SQL-based applications.</li>
                     </ul>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/MySQL-User-Group-NL/events/240545280/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.meetup.com/MySQL-User-Group-NL/events/240545280/"
@@ -5358,8 +6549,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="meetup-an-overview-of-ignite-persistent-store" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="meetup-an-overview-of-ignite-persistent-store" >
                     <div><h3 style="display:inline-block;">Apache Ignite Community Meetup - An Overview of Donated Ignite Persistent Store Feature&nbsp;<a href="/events.html#meetup-an-overview-of-ignite-persistent-store" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a></h3></div>
                     <span class="news-date">Meetup, GoToMeeting, Speaker - Denis Magda</span><br/><br/>
                     <span class="news-date">June 16, 2017 @8:00am</span>
@@ -5378,13 +6578,11 @@
                         Access Code: 818-661-157
                     </p>
 
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="http://apache-ignite-developers.2346864.n4.nabble.com/DISCUSS-Webinar-for-Ignite-Persistent-Store-walk-through-td18677.html#a18767" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="http://apache-ignite-developers.2346864.n4.nabble.com/DISCUSS-Webinar-for-Ignite-Persistent-Store-walk-through-td18677.html#a18767"
@@ -5397,9 +6595,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-
-                <section id="sparksummit2017-apacheignite-apachespark" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/conferences.svg" alt="Conferences">
+					<p>Conferences</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="sparksummit2017-apacheignite-apachespark" >
                     <div><h3 style="display:inline-block;">Apache Ignite and Apache Spark: This is Where Fast Data Meets the IoT&nbsp;<a href="/events.html#sparksummit2017-apacheignite-apachespark" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a></h3></div>
                     <span class="news-date">Spark Summit 2017, San Francisco, CA. Speaker - Denis Magda</span><br/><br/>
                     <span class="news-date">June 07, 2017 @3:20pm</span>
@@ -5412,13 +6618,11 @@
                         <li>Data streaming to an Apache Ignite cluster from embedded devices powered by Apache Mynewt.</li>
                         <li>Real-time data processing with Apache Spark and Apache Ignite.</li>
                     </ul>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://spark-summit.org/2017/events/apache-spark-and-apache-ignite-where-fast-data-meets-the-iot/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://spark-summit.org/2017/events/apache-spark-and-apache-ignite-this-is-where-fast-data-meets-the-iot/"
@@ -5431,8 +6635,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="apacher-ignitetm-whats-new-version-201" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/webinars.svg" alt="Webinars">
+					<p>Webinar</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="apacher-ignitetm-whats-new-version-201" >
                     <div><h3 style="display:inline-block;">Apache® Ignite® 2.0: Prelude to a Distributed SQL Database&nbsp;<a href="/events.html#apacher-ignitetm-whats-new-version-201" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a></h3></div>
                     <span class="news-date">Webinar, Denis Magda</span><br/><br/>
                     <span class="news-date">June 07, 2017 @11:00am PT / 2:00pm ET</span>
@@ -5452,13 +6665,11 @@
                         update distributed data sets using standard SQL syntax. We will also cover B+Tree data structures
                         used to store SQL indexes off-heap.
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.gridgain.com/resources/webinars/apacher-ignitetm-20-prelude-distributed-sql-database" target="_blank" rel="noopener">Register for this webinar</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.gridgain.com/resources/webinars/apacher-ignitetm-20-prelude-distributed-sql-database"
@@ -5471,8 +6682,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="apachecon2017-apacheignite-apachespark" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/conferences.svg" alt="Conferences">
+					<p>Conference</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="apachecon2017-apacheignite-apachespark" >
                     <div><h3 style="display:inline-block;">Apache Ignite and Apache Spark: This is Where Fast Data Meets the IoT&nbsp;<a href="/events.html#apachecon2017-apacheignite-apachespark" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a></h3></div>
                     <span class="news-date">ApacheCon North America, Miami, FL. Speaker - Denis Magda</span><br/><br/>
                     <span class="news-date">May 18, 2017 @2:40pm</span>
@@ -5485,13 +6705,11 @@
                         <li>Data streaming to an Apache Ignite cluster from embedded devices powered by Apache Mynewt.</li>
                         <li>Real-time data processing with Apache Spark and Apache Ignite.</li>
                     </ul>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://apachecon2017.sched.com/event/9zot" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://apachecon2017.sched.com/event/9zot"
@@ -5504,9 +6722,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-
-                <section id="apachebigdata2017-apacheignite-sql-grid" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/conferences.svg" alt="Conferences">
+					<p>Conference</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="apachebigdata2017-apacheignite-sql-grid" >
                     <div><h3 style="display:inline-block;">Apache Ignite SQL Grid: Hot Blend of Traditional SQL and Swift Data Grid&nbsp;<a href="/events.html#apachebigdata2017-apacheignite-sql-grid" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a></h3></div>
                     <span class="news-date">ApacheCon North America, Miami, FL. Speaker - Denis Magda</span><br/><br/>
                     <span class="news-date">May 18, 2017 @10:00am</span>
@@ -5517,13 +6743,11 @@
                         a majority of data grids have to sacrifice traditional SQL support requiring application developers to
                         completely rewrite their SQL-based code to support data grid specific APIs.
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://apachebigdata2017.sched.com/event/A01a?iframe=no" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://apachebigdata2017.sched.com/event/A01a?iframe=no"
@@ -5536,8 +6760,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="Miami-Hadoop-User-Group" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="Miami-Hadoop-User-Group" >
                     <div><h3 style="display:inline-block;">Apache Ignite and Apache Spark: Where Fast Data Meets the IoT&nbsp;<a href="/events.html#Miami-Hadoop-User-Group" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a></h3></div>
                     <span class="news-date">Miami Hadoop User Group, Miami, FL. Speaker - Denis Magda</span><br/><br/>
                     <span class="news-date">May 17, 2017 @6:00pm</span>
@@ -5550,13 +6783,11 @@
                         <li>Data streaming to an Apache Ignite cluster from embedded devices powered by Apache Mynewt.</li>
                         <li>Real-time data processing with Apache Spark and Apache Ignite.</li>
                     </ul>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/Miami-Hadoop-User-Group/events/239713172/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.meetup.com/Miami-Hadoop-User-Group/events/239713172/"
@@ -5569,21 +6800,28 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="benchmarking-apache-ignite-still-keeps-ahead-of-ha-1" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="benchmarking-apache-ignite-still-keeps-ahead-of-ha-1" >
                     <div><h3 style="display:inline-block;">Benchmarking: Apache Ignite Still Keeps Ahead Of Hazelcast&nbsp;<a href="/events.html#benchmarking-apache-ignite-still-keeps-ahead-of-ha-1" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a></h3></div>
                     <span class="news-date">Blog, Denis Magda</span><br/><br/>
                     <span class="news-date">May 12, 2017</span>
                     <p>
                         There's an ad saying that Hazelcast is up to 50% faster than Apache Ignite, but that may not be true anymore. Check out this benchmark to get the true story.
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://dzone.com/articles/benchmarking-apache-ignite-still-keeps-ahead-of-ha-1" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://dzone.com/articles/benchmarking-apache-ignite-still-keeps-ahead-of-ha-1"
@@ -5596,8 +6834,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="Apache-Flink-London-Meetup" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="Apache-Flink-London-Meetup" >
                     <div><h3 style="display:inline-block;">Apache Flink meets Apache Ignite&nbsp;<a href="/events.html#Apache-Flink-London-Meetup" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a></h3></div>
                     <span class="news-date">Apache Flink London Meetup, Speaker - Akmal B. Chaudhri</span><br/><br/>
                     <span class="news-date">May 10, 2017 @6:30pm</span>
@@ -5605,13 +6852,11 @@
                         Akmal B. Chaudhri will be giving a quick introduction of Apache Ignite, its main capabilities and how it can add value to your pipelines.
                         Akmal is a Technical Evangelist, specializing in Big Data, NoSQL and NewSQL database technologies.
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/Apache-Flink-London-Meetup/events/239663941/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.meetup.com/Apache-Flink-London-Meetup/events/239663941/"
@@ -5624,8 +6869,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="apacheignite-oscon-2017" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/conferences.svg" alt="Conference">
+					<p>Conference</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="apacheignite-oscon-2017" >
                     <div><h3 style="display:inline-block;">The next phase of distributed systems with Apache Ignite&nbsp;<a href="/events.html#apacheignite-oscon-2017" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a></h3></div>
                     <span class="news-date">OSCON, Austin, TX. Speaker - Dani Traphagen</span><br/><br/>
                     <span class="news-date">May 10, 2017 @5:05pm</span>
@@ -5635,13 +6889,11 @@
                         Fortune 500 companies that view disk as a bottleneck. Dani explains how to optimize toward the cache, leveraging it for low-latency,
                         highly available microservices architectures with the hot-and-fresh-out-of-the-kitchen open source project Apache Ignite.
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://conferences.oreilly.com/oscon/oscon-tx/public/schedule/detail/60801" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://conferences.oreilly.com/oscon/oscon-tx/public/schedule/detail/60801"
@@ -5654,8 +6906,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="apacher-ignitetm-real-time-processing-iot-generated-streaming-data" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/webinars.svg" alt="Webinars">
+					<p>Webinar</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="apacher-ignitetm-real-time-processing-iot-generated-streaming-data" >
                     <div><h3 style="display:inline-block;">Apache® Ignite®: Real-Time Processing of IoT-Generated Streaming Data&nbsp;<a href="/events.html#apacher-ignitetm-real-time-processing-iot-generated-streaming-data" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a></h3></div>
                     <span class="news-date">Webinar, Denis Magda</span><br/><br/>
                     <span class="news-date">May 10, 2017 @11:00am</span>
@@ -5668,13 +6929,11 @@
                         <li>How to conduct real-time data processing on this stream using Apache Ignite</li>
                     </ul>
 
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.gridgain.com/resources/webinars/apacher-ignitetm-real-time-processing-iot-generated-streaming-data" target="_blank" rel="noopener">Register for this webinar</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.gridgain.com/resources/webinars/apacher-ignitetm-real-time-processing-iot-generated-streaming-data"
@@ -5687,8 +6946,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="apache-ignite-20-released" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/webinars.svg" alt="Webinars">
+					<p>Webinar</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="apache-ignite-20-released" >
                     <div><h3 style="display:inline-block;">Apache Ignite 2.0 Released&nbsp;<a href="/events.html#apache-ignite-20-released" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a></h3></div>
                     <span class="news-date">May 05, 2017</span>
                     <p>
@@ -5705,13 +6973,11 @@
                     <p>
                         See <a href="https://ignite.apache.org/releases/2.0.0/release_notes.html">release notes</a> for a full list of the changes.
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://blogs.apache.org/ignite/entry/apache-ignite-2-0-redesigned" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://blogs.apache.org/ignite/entry/apache-ignite-2-0-redesigned"
@@ -5724,8 +6990,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="presenting-apache-ignite-at-percona-live-2017" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/conferences.svg" alt="Conferences">
+					<p>Conferences</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="presenting-apache-ignite-at-percona-live-2017" >
                     <div><h3 style="display:inline-block;">Accelerate MySQL® for Demanding OLAP and OLTP Use Cases with Apache® Ignite™&nbsp;<a href="/events.html#presenting-apache-ignite-at-percona-live-2017" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a></h3></div>
                     <span class="news-date">Percona Live 2017, Santa Clara, CA, USA. Speaker - Nikita Ivanov</span><br/><br/>
                     <span class="news-date">April 25, 2017 @1:20pm PT</span>
@@ -5736,13 +7011,11 @@
                         At the end of the session, you will understand how incorporating Apache Ignite into your architecture can empower dramatically faster analytics and
                         transactions when augmenting your current MySQL infrastructure.
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.percona.com/live/17/sessions/accelerate-mysql®-demanding-olap-and-oltp-use-cases-apache®-ignite™-0" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.percona.com/live/17/sessions/accelerate-mysql®-demanding-olap-and-oltp-use-cases-apache®-ignite™-0"
@@ -5755,8 +7028,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="apacher-ignitetm-memory-backbone-microservices-based-architectures" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/webinars.svg" alt="Webinar">
+					<p>Webinar</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="apacher-ignitetm-memory-backbone-microservices-based-architectures" >
                     <div><h3 style="display:inline-block;">Apache® Ignite™: An In-Memory Backbone for Microservices-Based Architectures&nbsp;<a href="/events.html#apacher-ignitetm-memory-backbone-microservices-based-architectures" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a></h3></div>
                     <span class="news-date">Webinar, Denis Magda</span><br/><br/>
                     <span class="news-date">April 19, 2017 @11:00am PT / 2:00pm ET</span>
@@ -5769,13 +7051,11 @@
                         This webinar discusses how in-memory computing using Apache® Ignite® can overcome the performance limitations
                         common to microservices architectures built using traditional database architectures.
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.gridgain.com/resources/webinars/apacher-ignitetm-memory-backbone-microservices-based-architectures" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.gridgain.com/resources/webinars/apacher-ignitetm-memory-backbone-microservices-based-architectures"
@@ -5788,9 +7068,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-
-                <section id="presenting-apache-ignite-performance-jpoint-2017" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/conferences.svg" alt="Conference">
+					<p>Conference</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="presenting-apache-ignite-performance-jpoint-2017" >
                     <div><h3 style="display:inline-block;">Scalability in Distributed In-Memory Systems&nbsp;<a href="/events.html#presenting-apache-ignite-performance-jpoint-2017" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a></h3></div>
                     <span class="news-date">JPoint 2017, Moscow, Russia. Speaker - Vladimir Ozerov</span><br/><br/>
                     <span class="news-date">April 7, 2017 @15:30pm</span>
@@ -5800,13 +7088,11 @@
                         Is it true and if, yes, if the guarantee meets all the time?
                         Join Yakov on his talk to get answers on these questions and learn more about scalability and concurrency concepts implemented in Apache Ignite In-Memory Data Fabric.
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://jpoint.ru/talks/scalability-in-distributed-in-memory-systems/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://jpoint.ru/talks/scalability-in-distributed-in-memory-systems/"
@@ -5819,8 +7105,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="presenting-apache-ignite-performance-jbreak-2017" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="presenting-apache-ignite-performance-jbreak-2017" >
                     <div><h3 style="display:inline-block;">Scalability in Distributed In-Memory Systems&nbsp;<a href="/events.html#presenting-apache-ignite-performance-jbreak-2017" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a></h3></div>
                     <span class="news-date">JBreak 2017, Novosibirsk, Russia. Speaker - Yakov Zhdanov</span><br/><br/>
                     <span class="news-date">April 4, 2017 @15:15pm</span>
@@ -5830,13 +7125,11 @@
                         Is it true and if, yes, if the guarantee meets all the time?
                         Join Yakov on his talk to get answers on these questions and learn more about scalability and concurrency concepts implemented in Apache Ignite In-Memory Data Fabric.
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://2017.jbreak.ru/en/talks/scalability-in-distributed-in-memory-systems/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://2017.jbreak.ru/en/talks/scalability-in-distributed-in-memory-systems/"
@@ -5849,8 +7142,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="presenting-apache-ignite-sql-grid-pgconf-2017" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="presenting-apache-ignite-sql-grid-pgconf-2017" >
                     <div><h3 style="display:inline-block;">Presenting Apache Ignite SQL Grid at PGConf US 2017&nbsp;<a href="/events.html#presenting-apache-ignite-sql-grid-pgconf-2017" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a></h3></div>
                     <span class="news-date">Presentation, Denis Magda</span><br/><br/>
                     <span class="news-date">March 30, 2017 @14:00pm EDT</span>
@@ -5862,13 +7164,11 @@
                         It will be demonstrated how to connect to Apache Ignite from your favorite tool or application language using ODBC or JDBC driver and
                         start talking to a clustered data using familiar statements like SELECT, UPDATE, DELETE or INSERT.
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="http://pgconf.us/conferences/2017/program/proposals/340" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="http://pgconf.us/conferences/2017/program/proposals/340"
@@ -5881,8 +7181,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="presenting-apache-ignite-sql-grid" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="presenting-apache-ignite-sql-grid" >
                     <div><h3 style="display:inline-block;">Presenting Apache Ignite SQL Grid at Big Data Bootcamp&nbsp;<a href="/events.html#presenting-apache-ignite-sql-grid" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a></h3></div>
                     <span class="news-date">Presentation, Denis Magda</span><br/><br/>
                     <span class="news-date">March 28, 2017 @1:00pm PT</span>
@@ -5891,13 +7200,11 @@
                         traditional ANSI-99 SQL support of relational databases. Moreover, Denis will take an existing application that works with a relational database and
                         will show how to run it on top of Apache Ignite with minimum efforts.
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://blogs.apache.org/ignite/entry/presenting-apache-ignite-sql-grid" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://blogs.apache.org/ignite/entry/presenting-apache-ignite-sql-grid"
@@ -5910,8 +7217,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="presenting-apache-ignite-codemotion-rome-2017" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/conferences.svg" alt="Conference">
+					<p>Conference</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="presenting-apache-ignite-codemotion-rome-2017" >
                     <div><h3 style="display:inline-block;">Presenting Apache Ignite at Codemotion Rome 2017&nbsp;<a href="/events.html#presenting-apache-ignite-codemotion-rome-2017" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a></h3></div>
                     <span class="news-date">Presentation, Mandhir Gidda</span><br/><br/>
                     <span class="news-date">March 24, 2017 @15:00pm</span>
@@ -5920,13 +7236,11 @@
                         computing and transacting on large-scale data sets in real-time, orders of magnitude faster than possible with traditional
                         disk-based or flash technologies.
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="http://rome2017.codemotionworld.com/wp-content/themes/event/detail-talk.php?detail=5799" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="http://rome2017.codemotionworld.com/wp-content/themes/event/detail-talk.php?detail=5799"
@@ -5939,8 +7253,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="apacher-sql-grid-webinar" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/webinars.svg" alt="Webinars">
+					<p>Webinar</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="apacher-sql-grid-webinar" >
                     <div><h3 style="display:inline-block;">The Apache&reg; Ignite&reg; SQL Grid: A Hot Blend of Traditional SQL and In-Memory Data Grids&nbsp;<a href="/events.html#apacher-sql-grid-webinar" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a></h3></div>
                     <span class="news-date">Webinar, Denis Magda</span><br/><br/>
                     <span class="news-date">March 15, 2017 @11:00am PT / 2:00pm ET</span>
@@ -5953,13 +7276,11 @@
                         <li>Data modification with ANSI-99 DML (INSERT, UPDATE, DELETE, etc.)</li>
                         <li>Using Apache Ignite's JDBC and ODBC drivers</li>
                     </ul>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.gridgain.com/company/news/events/gridgain-webinar-apacher-ignitetm-sql-grid-hot-blend-traditional-sql-and-memory" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.gridgain.com/company/news/events/gridgain-webinar-apacher-ignitetm-sql-grid-hot-blend-traditional-sql-and-memory"
@@ -5972,8 +7293,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="london_ignite_meetup_feb_23" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="london_ignite_meetup_feb_23" >
                     <div><h3 style="display:inline-block;">Apache Ignite: Transform batch-based system into swift real-time solution&nbsp;<a href="/events.html#london_ignite_meetup_feb_23" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a></h3></div>
                     <span class="news-date">Apache Ignite London Meetup</span><br/><br/>
                     <span class="news-date">February 23, 2017</span>
@@ -5981,13 +7311,11 @@
                         IHS Markit will present first on how they have been using Apache Ignite on several major projects.
                         The 2nd part of the meetup will be led by Mandhir Gidda who's been working with in-memory technologies for nearly 10 years.
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.meetup.com/Apache-Ignite-London/events/237189063" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.meetup.com/Apache-Ignite-London/events/237189063"
@@ -6000,8 +7328,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="apacher-ignitetm-web-console" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/webinars.svg" alt="Webinar">
+					<p>Webinar</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="apacher-ignitetm-web-console" >
                     <div><h3 style="display:inline-block;">The Apache&reg; Ignite&reg; Web Console: Automating RDBMS Integration&nbsp;<a href="/events.html#apacher-ignitetm-web-console" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a></h3></div>
                     <span class="news-date">Webinar, Denis Magda</span><br/><br/>
                     <span class="news-date">February 15, 2017 @11:00am PT / 2:00pm ET</span>
@@ -6014,13 +7351,11 @@
                         <li>Create a Java POJO</li>
                         <li>Download a ready-to-run Apache Ignite based project that will be fully integrated with the RDBMS</li>
                     </ul>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.gridgain.com/resources/webinars/apacher-ignitetm-web-console-automating-rdbms-integration" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.gridgain.com/resources/webinars/apacher-ignitetm-web-console-automating-rdbms-integration"
@@ -6033,8 +7368,17 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="deploying-apacher-ignitetm-and-gridgain-top-7-faqs" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/webinars.svg" alt="Webinar">
+					<p>Webinar</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="deploying-apacher-ignitetm-and-gridgain-top-7-faqs" >
                     <div><h3 style="display:inline-block;">Deploying Apache&reg; Ignite&reg; – Top 7 FAQs&nbsp;<a href="/events.html#deploying-apacher-ignitetm-and-gridgain-top-7-faqs" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a></h3></div>
                     <span class="news-date">Webinar, Christos Erotocritou and Rachel Pedreschi</span><br/><br/>
                     <span class="news-date">January 25, 2017 @11:00am PT / 2:00pm ET</span>
@@ -6042,13 +7386,11 @@
                         Christos Erotocritou and Rachel Pedreschi have helped numerous customers get started with Apache&reg; Ignite&reg; and GridGain. During this 1-hour webinar, they will share answers to the most common questions asked prior to deployment.
                         They will also provide guidance that will save you time and make deploying Apache Ignite a more enjoyable experience.
                     </p>
-                    <div class="col-sm-12 col-md-9 col-xs-12 news-readmore">
+                    <div class="news-readmore">
                         <p>
                             <a href="https://www.gridgain.com/resources/webinars/deploying-apacher-ignitetm-and-gridgain-top-7-faqs" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                         </p>
-                    </div>
-                    <div class="col-sm-12 col-md-3 col-xs-12 ">
-
+                    </div>                    <div>
                         <!-- AddToAny BEGIN -->
                         <div class="a2a_kit a2a_kit_size_28 a2a_default_style news-socialmedia-icons"
                              data-a2a-url="https://www.gridgain.com/resources/webinars/deploying-apacher-ignitetm-and-gridgain-top-7-faqs"
@@ -6061,8 +7403,19 @@
                         <!-- AddToAny END -->
                     </div>
                     <p style="margin:0;">&nbsp;</p>
-                </section>
-                <section id="release-1.8.0" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+	</div>
+	<div class="tab-pane" id="2016">
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/release.svg" alt="Release">
+					<p>Release</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="release-1.8.0" >
                     <div><h3 style="display:inline-block;">Apache Ignite 1.8.0&nbsp;<a href="/events.html#release-1.8.0" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a></h3></div>
                     <span class="news-date">December 09, 2016</span>
                     <p>
@@ -6075,8 +7428,17 @@
                     <p>
                         <a href="/download.cgi" target="_blank" rel="noopener">Download Ignite 1.8.0</a>
                     </p>
-                </section>
-                <section id="apache-big-data-europe-nov-16-2" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/conferences.svg" alt="Conference">
+					<p>Conference</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="apache-big-data-europe-nov-16-2" >
                     <div><h3 style="display:inline-block;">Shared Memory Layer for Spark Applications&nbsp;<a href="/events.html#apache-big-data-europe-nov-16-2" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a></h3></div>
                     <span class="news-date">Dmitriy Setrakyan, Apache Big Data Europe</span><br/><br/>
                     <span class="news-date">November 16, 2016</span>
@@ -6087,8 +7449,17 @@
                     <p>
                         <a href="https://apachebigdataeu2016.sched.org/event/8m2O/shared-memory-layer-for-spark-applications-dmitriy-setrakyan-gridgain" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                     </p>
-                </section>
-                <section id="apache-big-data-europe-nov-16-1" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/conferences.svg" alt="Conference">
+					<p>Conference</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="apache-big-data-europe-nov-16-1" >
                     <div><h3 style="display:inline-block;">Shared Memory Layer and Faster SQL for Spark Applications&nbsp;<a href="/events.html#apache-big-data-europe-nov-16-1" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a></h3></div>
                     <span class="news-date">Dmitriy Setrakyan, Apache Big Data Europe</span><br/><br/>
                     <span class="news-date">November 16, 2016</span>
@@ -6098,8 +7469,17 @@
                     <p>
                         <a href="https://apachebigdataeu2016.sched.org/event/8m2i/shared-memory-layer-and-faster-sql-for-spark-applications-dmitriy-setrakyan-gridgain" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                     </p>
-                </section>
-                <section id="apache-big-data-europe-nov-15" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/conferences.svg" alt="Conference">
+					<p>Conference</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="apache-big-data-europe-nov-15" >
                     <div><h3 style="display:inline-block;">Apache Ignite - Path to Converged Data Platform&nbsp;<a href="/events.html#apache-big-data-europe-nov-15" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a></h3></div>
                     <span class="news-date">Dmitriy Setrakyan, Apache Big Data Europe</span><br/><br/>
                     <span class="news-date">November 15, 2016</span>
@@ -6109,9 +7489,17 @@
                     <p>
                         <a href="https://apachebigdataeu2016.sched.org/event/8TzM/apache-ignite-path-to-converged-data-platform-dmitriy-setrakyan-gridgain" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                     </p>
-                </section>
-
-                <section id="release-1.7.0" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/release.svg" alt="Release">
+					<p>Release</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="release-1.7.0" >
                     <div><h3 style="display:inline-block;">Apache Ignite 1.7.0&nbsp;<a href="/events.html#release-1.7.0" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a></h3></div>
                     <span class="news-date">August 05, 2016</span>
                     <p>
@@ -6121,9 +7509,17 @@
                     <p>
                         <a href="/download.cgi" target="_blank" rel="noopener">Download Ignite 1.7.0</a>
                     </p>
-                </section>
-
-                <section id="london-meetup-june-2016" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="london-meetup-june-2016" >
                     <div><h3 style="display:inline-block;">Apache Ignite London Meetup&nbsp;<a href="/events.html#london-meetup-june-2016" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a></h3></div>
                     <span class="news-date">July 13, 2016</span>
                     <p>
@@ -6136,9 +7532,17 @@
                     <p>
                         <a href="http://www.meetup.com/Apache-Ignite-London/events/231963106/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                     </p>
-                </section>
-
-                <section id="nyc-meetup-june-2016" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/meetup.svg" alt="Meetup">
+					<p>Meetup</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="nyc-meetup-june-2016" >
                     <div><h3 style="display:inline-block;">Apache Ignite NYC Meetup&nbsp;<a href="/events.html#nyc-meetup-june-2016" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a></h3></div>
                     <span class="news-date">June 28, 2016</span>
                     <p>
@@ -6151,10 +7555,17 @@
                     <p>
                         <a href="http://www.meetup.com/mysqlnyc/events/231578906/" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                     </p>
-                </section>
-
-
-                <section id="release-1.6.0" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/release.svg" alt="Release">
+					<p>Release</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="release-1.6.0" >
                     <div><h3 style="display:inline-block;">Apache Ignite 1.6.0&nbsp;<a href="/events.html#release-1.6.0" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a></h3></div>
                     <span class="news-date">May 23, 2016</span>
                     <p>
@@ -6164,10 +7575,17 @@
                     <p>
                         <a href="/download.cgi" target="_blank" rel="noopener">Download Ignite 1.6.0</a>
                     </p>
-                </section>
-
-
-                <section id="ignite-extensions" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/release.svg" alt="Release">
+					<p>Release</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="ignite-extensions" >
                     <div><h3 style="display:inline-block;">Ignite Adds Add-ons&nbsp;<a href="/events.html#ignite-extensions" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a></h3></div>
                     <span class="news-date">February 17, 2016</span>
                     <p>
@@ -6177,10 +7595,17 @@
                     <p>
                         <a href="/addons.html" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                     </p>
-                </section>
-
-
-                <section id="release-1.5.0.final" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/release.svg" alt="Release">
+					<p>Release</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="release-1.5.0.final" >
                     <div><h3 style="display:inline-block;">Apache Ignite 1.5.0.final Released&nbsp;<a href="/events.html#release-1.5.0.final" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a></h3></div>
                     <span class="news-date">January 4, 2016</span>
                     <p>
@@ -6190,10 +7615,19 @@
                     <p>
                         <a href="/download.cgi" target="_blank" rel="noopener">Download Ignite 1.5.0.final</a>
                     </p>
-                </section>
-
-
-                <section id="release-1.5.0-b1" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+	</div>
+	<div class="tab-pane" id="2015">		
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/release.svg" alt="Release">
+					<p>Release</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="release-1.5.0-b1" >
                     <div><h3 style="display:inline-block;">Apache Ignite 1.5.0-b1 Early Access Released&nbsp;<a href="/events.html#release-1.5.0-b1" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a></h3></div>
                     <span class="news-date">December 12, 2015</span>
                     <p>
@@ -6203,9 +7637,17 @@
                     <p>
                         <a href="/download.cgi" target="_blank" rel="noopener">Download Ignite 1.5.0-b1</a>
                     </p>
-                </section>
-
-                <section id="release-1.4.0" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/release.svg" alt="Release">
+					<p>Release</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="release-1.4.0" >
                     <div><h3 style="display:inline-block;">Apache Ignite 1.4.0 Released&nbsp;<a href="/events.html#release-1.4.0" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a></h3></div>
                     <span class="news-date">September 28, 2015</span>
                     <p>
@@ -6216,9 +7658,17 @@
                     <p>
                         <a href="/download.cgi" target="_blank" rel="noopener">Download Ignite 1.4.0</a>
                     </p>
-                </section>
-
-                <section id="apache-ignite-graduation" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/release.svg" alt="Release">
+					<p>Release</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="apache-ignite-graduation" >
                     <div><h3 style="display:inline-block;">Apache Ignite Graduated to a Top-Level Project&nbsp;<a href="/events.html#apache-ignite-graduation" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a></h3></div>
                     <span class="news-date">August 25, 2015</span>
                     <p>
@@ -6230,10 +7680,17 @@
                     <p>
                         <a href="http://globenewswire.com/news-release/2015/08/25/763148/10146997/en/The-Apache-Software-Foundation-Announces-Apache-tm-Ignite-tm-as-a-Top-Level-Project.html" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                     </p>
-                </section>
-
-
-                <section id="release-1.3.0" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/release.svg" alt="Release">
+					<p>Release</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="release-1.3.0" >
                     <div><h3 style="display:inline-block;">Apache Ignite 1.3.0 Released&nbsp;<a href="/events.html#release-1.3.0" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a></h3></div>
                     <span class="news-date">July 21, 2015</span>
                     <p>
@@ -6243,9 +7700,17 @@
                     <p>
                         <a href="/download.cgi" target="_blank" rel="noopener">Download Ignite 1.3.0</a>
                     </p>
-                </section>
-
-                <section id="release-1.2.0" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/release.svg" alt="Release">
+					<p>Release</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="release-1.2.0" >
                     <div><h3 style="display:inline-block;">Apache Ignite 1.2.0 Released&nbsp;<a href="/events.html#release-1.2.0" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a></h3></div>
                     <span class="news-date">June 29, 2015</span>
                     <p>
@@ -6257,9 +7722,17 @@
                     <p>
                         <a href="/download.cgi" target="_blank" rel="noopener">Download Ignite 1.2.0</a>
                     </p>
-                </section>
-
-                <section id="release-1.1.0" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/release.svg" alt="Release">
+					<p>Release</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="release-1.1.0" >
                     <div><h3 style="display:inline-block;">Apache Ignite 1.1.0 Released&nbsp;<a href="/events.html#release-1.1.0" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a></h3></div>
                     <span class="news-date">May 28, 2015</span>
                     <p>
@@ -6269,9 +7742,17 @@
                     <p>
                         <a href="/download.cgi" target="_blank" rel="noopener">Download Ignite 1.1.0</a>
                     </p>
-                </section>
-
-                <section id="release-1.0.0" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/release.svg" alt="Release">
+					<p>Release</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="release-1.0.0" >
                     <div><h3 style="display:inline-block;">Apache Ignite 1.0.0 Released&nbsp;<a href="/events.html#release-1.0.0" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a></h3></div>
                     <span class="news-date">April 2, 2015</span>
                     <p>
@@ -6282,9 +7763,17 @@
                     <p>
                         <a href="/download.cgi" target="_blank" rel="noopener">Download Ignite 1.0.0</a>
                     </p>
-                </section>
-
-                <section id="release-1.0.0-RC3" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/release.svg" alt="Release">
+					<p>Release</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="release-1.0.0-RC3" >
                     <div><h3 style="display:inline-block;">Apache Ignite 1.0.0-RC3 Released&nbsp;<a href="/events.html#release-1.0.0-RC3" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a></h3></div>
                     <span class="news-date">March 24, 2015</span>
                     <p>
@@ -6306,9 +7795,19 @@
                     <p>
                         <a href="/download.cgi" target="_blank" rel="noopener">Download Ignite 1.0.0-RC3</a>
                     </p>
-                </section>
-
-                <section id="nikita-interview-ignite-incubation" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+	</div>
+	<div class="tab-pane" id="2014">		
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/conferences.svg" alt="Interview">
+					<p>Interview</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="nikita-interview-ignite-incubation" >
                     <div><h3 style="display:inline-block;">InfoQ Interview with Nikita Ivanov on Apache Ignite Incubation&nbsp;<a href="/events.html#nikita-interview-ignite-incubation" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a></h3></div>
                     <span class="news-date">December 3, 2014</span>
                     <p>
@@ -6320,9 +7819,17 @@
                     <p>
                         <a href="http://www.infoq.com/articles/gridgain-apache-ignite" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                     </p>
-                </section>
-
-                <section id="apache-ignite-enters-incubation" class="page-section news-section">
+                </section>	
+			</div>
+		</div>
+		<div class="row new-event">
+			<div class="col-xl-2 col-md-2 hidden-sm hidden-xs"><div class="round-icon-block">
+					<img src="images/conferences.svg" alt="Interview">
+					<p>News</p>
+				</div>
+			</div>
+			<div class="col-md-10">
+				<section id="apache-ignite-enters-incubation">
                     <div><h3 style="display:inline-block;">Apache Ignite Enters Incubation&nbsp;<a href="/events.html#apache-ignite-enters-incubation" aria-label="Event Meetup"><i class="fa fa-anchor"></i></a></h3></div>
                     <span class="news-date">October 1, 2014</span>
                     <p>
@@ -6334,8 +7841,11 @@
                     <p>
                         <a href="http://www.infoq.com/news/2014/12/gridgain-ignite" target="_blank" rel="noopener" aria-label="Event Meetup">Read more</a>
                     </p>
-                </section>
-            </div>
+                </section>	
+			</div>
+		</div>
+	</div>
+</div>			
         </section>
     </main>
 
diff --git a/images/conferences.svg b/images/conferences.svg
new file mode 100644
index 0000000..d246dc3
--- /dev/null
+++ b/images/conferences.svg
@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 24.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
+<svg version="1.1" id="Capa_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
+	 viewBox="0 0 300 300" style="enable-background:new 0 0 300 300;" xml:space="preserve">
+<style type="text/css">
+	.st0{fill:#D93846;}
+</style>
+<g>
+	<g>
+		<g>
+			<path class="st0" d="M150,3.4c-34.3,0-62.1,27.9-62.1,62.1v89.3c0,34.3,27.9,62.1,62.1,62.1s62.1-27.9,62.1-62.1V65.5
+				C212.1,31.2,184.3,3.4,150,3.4z M194.9,155c-0.1,24.7-20.2,44.8-44.9,44.8s-44.9-20.1-44.9-44.8l0-89.5
+				c0-24.8,20.2-44.9,44.9-44.9s44.9,20.2,44.9,44.9L194.9,155z"/>
+		</g>
+	</g>
+	<g>
+		<g>
+			<path class="st0" d="M213.8,220.5c14.8-14.7,23.9-33.7,26.1-54.2c0.6-5-3.4-9.5-8.5-9.5h0c-4.4,0-8.1,3.3-8.6,7.7
+				c-4.1,36.6-35.3,65.1-72.9,65.1c-37.6,0-68.8-28.6-72.9-65.1c-0.5-4.4-4.2-7.7-8.6-7.7h0c-5.1,0-9.1,4.4-8.5,9.5
+				c2.2,20.5,11.3,39.5,26.1,54.2c15,14.9,34.4,24,55.2,25.9v33.1H119c-4.7,0-8.6,3.8-8.6,8.6l0,0c0,4.7,3.8,8.6,8.6,8.6H181
+				c4.7,0,8.6-3.8,8.6-8.6l0,0c0-4.7-3.8-8.6-8.6-8.6h-22.4v-33.1C179.4,244.5,198.8,235.4,213.8,220.5z"/>
+		</g>
+	</g>
+	<path class="st0" d="M123.4,164.4H120c-3.8,0-6.9-3.1-6.9-6.9V64.1c0-3.8,3.1-6.9,6.9-6.9h3.4c3.8,0,6.9,3.1,6.9,6.9v93.4
+		C130.3,161.3,127.2,164.4,123.4,164.4z"/>
+</g>
+</svg>
diff --git a/images/meetup.svg b/images/meetup.svg
new file mode 100644
index 0000000..9c591a9
--- /dev/null
+++ b/images/meetup.svg
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 24.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
+<svg version="1.1" id="Capa_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
+	 viewBox="0 0 300 300" style="enable-background:new 0 0 300 300;" xml:space="preserve">
+<style type="text/css">
+	.st0{fill:#ED1C40;}
+	.st1{fill:#FFFFFF;}
+</style>
+<g id="Layer_2">
+	<g id="Layer_1-2">
+		<path class="st0" d="M212.8,252.6c-5.8,4-7.2,11.9-3.2,17.7c4,5.8,11.9,7.2,17.7,3.2c5.8-4,7.2-11.9,3.2-17.7
+			C226.6,250.1,218.6,248.6,212.8,252.6C212.9,252.6,212.8,252.6,212.8,252.6 M138.4,275c-3.6,2.5-4.5,7.4-2,10.9
+			c2.5,3.6,7.4,4.5,10.9,2c3.6-2.5,4.5-7.4,2-10.9c0,0,0,0,0,0C146.9,273.4,142,272.5,138.4,275C138.4,275,138.4,275,138.4,275
+			 M48,238.5c0.7,3.1,3.7,5,6.7,4.3s5-3.7,4.3-6.7c-0.7-3-3.7-5-6.7-4.3C49.3,232.4,47.4,235.4,48,238.5C48,238.5,48,238.5,48,238.5
+			 M26.2,151c3.8-5.5,2.4-13.1-3.2-16.9c-5.5-3.8-13.1-2.4-16.9,3.2s-2.4,13.1,3.2,16.9c0,0,0,0,0,0C14.8,158,22.4,156.6,26.2,151
+			C26.2,151,26.2,151,26.2,151 M67.7,72.5c4.2-2.9,5.2-8.7,2.3-12.9c-2.9-4.2-8.7-5.2-12.9-2.3c-4.2,2.9-5.2,8.7-2.3,12.9
+			C57.8,74.4,63.5,75.4,67.7,72.5C67.7,72.5,67.7,72.5,67.7,72.5 M95.2,15.8c-0.8-3.5-4.2-5.7-7.7-4.9c-3.5,0.8-5.7,4.2-4.9,7.7
+			s4.2,5.7,7.7,4.9c0,0,0,0,0,0C93.7,22.7,96,19.3,95.2,15.8C95.2,15.8,95.2,15.8,95.2,15.8 M177.7,24.3c-3.4-5.7-10.9-7.6-16.6-4.1
+			c-5.7,3.4-7.6,10.9-4.1,16.6s10.9,7.6,16.6,4.1c0,0,0,0,0,0C179.3,37.4,181.1,30,177.7,24.3 M237,110.5
+			c2.3-29.9-20.1-55.9-50-58.2c-7.7-0.6-15.4,0.5-22.7,3.1c-20.3-13-47.1-13.5-68.1,1.1C86,63.6,78.1,73.6,73.7,85.3
+			C67.4,86.1,61.3,88.4,56,92c-18.1,12.5-22.9,37-11.4,55.5c-15.6,14.3-19.2,38.2-7.3,56.6c7.1,10.9,18.1,17.5,30,19.4
+			c0.6,26.2,22.4,46.8,48.5,46.2c9.3-0.2,18.3-3.2,25.9-8.5c0.8-0.6,1.5-1.3,2.2-1.9c12,10.7,30.1,12.5,43.9,2.9
+			c7.1-4.9,12.1-12.2,14.1-20.6c10.8,0.4,21.8-2.4,31.4-9c22.9-15.9,29.2-46.9,14.4-70.5c12.7-10.5,14.4-29.3,3.9-42
+			C247.9,115.5,242.8,112.2,237,110.5 M263,103.1c4.7-3.2,5.8-9.6,2.6-14.3c-3.2-4.7-9.6-5.8-14.3-2.6c-4.7,3.2-5.8,9.6-2.6,14.3
+			C251.9,105.2,258.3,106.4,263,103.1C263,103.1,263,103.1,263,103.1 M283,163.3c-0.9-4.1-5-6.7-9.1-5.8c-4.1,0.9-6.7,5-5.8,9.1
+			c0.9,4.1,5,6.7,9.1,5.8C281.2,171.5,283.9,167.4,283,163.3C283,163.3,283,163.3,283,163.3 M295.9,126.4c-0.7-3.1-3.7-5-6.8-4.4
+			c-3.1,0.7-5,3.7-4.4,6.8c0.7,3.1,3.7,5,6.8,4.4c0,0,0,0,0,0C294.6,132.5,296.6,129.4,295.9,126.4"/>
+		<path class="st1" d="M209.5,202.4c-1.8-11.2-22.5-2.5-23.8-14.8c-1.8-17.4,24.1-55.1,22-69.7c-1.8-13.1-10.7-15.9-18.4-16
+			c-7.5-0.1-9.5,1.1-12,2.5c-1.5,0.8-3.6,2.5-6.5-0.2c-1.9-1.8-3.2-3.1-5.3-4.8c-1.6-1.3-3.5-2-5.5-2.3c-2.8-0.4-6.4,0-8.7,1
+			c-2.3,1-4.1,2.7-6,4.3s-6.6,7-11.1,5c-1.9-0.9-8.5-4.1-13.2-6.2c-9.1-3.9-22.3,2.5-27,10.9c-7,12.5-20.9,61.7-23,68.2
+			c-4.7,14.6,6,26.4,20.4,25.7c6.1-0.3,10.2-2.5,14-9.5c2.2-4,23.1-58.7,24.7-61.4c1.1-1.9,4.9-4.4,8.1-2.8s3.8,5,3.4,8.3
+			c-0.8,5.2-15.5,38.6-16.1,42.3c-1,6.4,2.1,10,8.8,10.3c4.6,0.2,9.1-1.4,12.7-8.2c2-3.8,25.3-50.4,27.3-53.6
+			c2.2-3.4,4.1-4.5,6.4-4.4c1.8,0.1,4.7,0.5,3.9,5.9c-0.7,5.3-19.4,39.5-21.3,47.9c-2.6,11.2,3.5,22.5,13.7,27.5
+			C183.5,211.5,211.8,217,209.5,202.4"/>
+	</g>
+</g>
+</svg>
diff --git a/images/webinars.svg b/images/webinars.svg
new file mode 100644
index 0000000..9a9a0e7
--- /dev/null
+++ b/images/webinars.svg
@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 24.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
+<svg version="1.1" id="Capa_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
+	 viewBox="0 0 300 300" style="enable-background:new 0 0 300 300;" xml:space="preserve">
+<style type="text/css">
+	.st0{fill:#FFFFFF;}
+	.st1{fill:#D93846;}
+</style>
+<g>
+	<path class="st0" d="M294.6,224.6H5.4V40.9c0-2.7,2.2-4.9,4.9-4.9h279.5c2.7,0,4.9,2.2,4.9,4.9V224.6z"/>
+	<g>
+		<g>
+			<path class="st1" d="M288.6,267.7H11.4c-5.2,0-9.4-4.2-9.4-9.4V41.7c0-5.2,4.2-9.4,9.4-9.4h277.2c5.2,0,9.4,4.2,9.4,9.4v216.5
+				C298,263.5,293.8,267.7,288.6,267.7z M11.4,38.2c-1.9,0-3.5,1.6-3.5,3.5v216.5c0,1.9,1.6,3.5,3.5,3.5h277.2
+				c1.9,0,3.5-1.6,3.5-3.5V41.7c0-1.9-1.6-3.5-3.5-3.5H11.4z"/>
+			<path class="st1" d="M291.7,228.1H8.3c-1.6,0-2.9-1.3-2.9-2.9s1.3-2.9,2.9-2.9h283.4c1.6,0,2.9,1.3,2.9,2.9
+				S293.3,228.1,291.7,228.1z"/>
+		</g>
+	</g>
+	<g>
+		<path class="st1" d="M129.6,176.6c-0.9,0-1.7-0.2-2.5-0.6c-1.6-0.9-2.7-2.5-2.7-4.3v-77c0-1.8,1-3.4,2.7-4.3
+			c1.8-0.9,3.9-0.8,5.5,0.3l56,38.3c1.4,1,2.3,2.5,2.3,4.2c0,1.7-0.8,3.2-2.3,4.2l-56,38.3C131.7,176.2,130.7,176.6,129.6,176.6z
+			 M129.3,170.8C129.3,170.8,129.3,170.8,129.3,170.8L129.3,170.8L129.3,170.8z"/>
+	</g>
+</g>
+</svg>
diff --git a/includes/header.html b/includes/header.html
index 3bd4099..834ac95 100644
--- a/includes/header.html
+++ b/includes/header.html
@@ -266,13 +266,9 @@
                                         </li>
 
                                         <li class="divider"></li>
-                                        <li role="presentation" class="submenu-header">Events & Groups</li>
-                                        <li><a href="/events.html">Upcoming Events</a></li>
-                                        <li><a href="https://www.meetup.com/Bay-Area-In-Memory-Computing/" target="_blank" rel="noopener">Ignite Bay Area Meetup <i class="fa fa-external-link" style="padding-left:5px;"></i></a></li>
-                                        <li><a href="https://www.meetup.com/NYC-In-Memory-Computing-Meetup/" target="_blank" rel="noopener">Ignite New York Meetup <i class="fa fa-external-link" style="padding-left:5px;"></i></a></li>
-                                        <li><a href="http://www.meetup.com/Apache-Ignite-London" target="_blank" rel="noopener">Ignite London Meetup <i class="fa fa-external-link" style="padding-left:5px;"></i></a></li>
-                                        <li><a href="https://www.meetup.com/Moscow-Apache-Ignite-Meetup/" target="_blank" rel="noopener">Ignite Moscow Meetup <i class="fa fa-external-link" style="padding-left:5px;"></i></a></li>
-                                        <li><a href="https://vk.com/apacheignite" target="_blank" rel="noopener">Ignite VK Group (Russian) <i class="fa fa-external-link" style="padding-left:5px;"></i></a></li>
+                                        <li role="presentation" class="submenu-header">Events &amp; Groups</li>
+                                        <li><a href="/events.html">Apache Ignite Events</a></li>
+                                        <li><a href="/meetup-groups.html">Community Groups</a></li>
                                     </ul>
                                 </li>
                                 <li class="dropdown" style="cursor: pointer;">
diff --git a/includes/styles.html b/includes/styles.html
index 2c8ddc2..3ceafab 100644
--- a/includes/styles.html
+++ b/includes/styles.html
@@ -1,5 +1,5 @@
 <!-- REMEMBER TO COPY ALL CHANGES TO download.html -->
-<link media="screen" rel="stylesheet" href="/css/all.css?v=201912101618">
+<link media="screen" rel="stylesheet" href="/css/all.css?v=201912101620">
 <link href="https://netdna.bootstrapcdn.com/font-awesome/4.3.0/css/font-awesome.min.css" rel="stylesheet" media="screen">
 <link href='https://fonts.googleapis.com/css?family=Open+Sans:400,300,300italic,400italic,600,600italic,700,700italic,800,800italic' rel='stylesheet' type='text/css' media="screen">
 <link media="screen" rel="stylesheet" href="/css/syntaxhighlighter.css">
\ No newline at end of file
diff --git a/meetup-groups.html b/meetup-groups.html
new file mode 100644
index 0000000..028955a
--- /dev/null
+++ b/meetup-groups.html
@@ -0,0 +1,217 @@
+<!--
+ ▄▄▄       ██▓███   ▄▄▄       ▄████▄   ██░ ██ ▓█████     ██▓  ▄████  ███▄    █  ██▓▄▄▄█████▓▓█████
+▒████▄    ▓██░  ██▒▒████▄    ▒██▀ ▀█  ▓██░ ██▒▓█   ▀    ▓██▒ ██▒ ▀█▒ ██ ▀█   █ ▓██▒▓  ██▒ ▓▒▓█   ▀
+▒██  ▀█▄  ▓██░ ██▓▒▒██  ▀█▄  ▒▓█    ▄ ▒██▀▀██░▒███      ▒██▒▒██░▄▄▄░▓██  ▀█ ██▒▒██▒▒ ▓██░ ▒░▒███
+░██▄▄▄▄██ ▒██▄█▓▒ ▒░██▄▄▄▄██ ▒▓▓▄ ▄██▒░▓█ ░██ ▒▓█  ▄    ░██░░▓█  ██▓▓██▒  ▐▌██▒░██░░ ▓██▓ ░ ▒▓█  ▄
+ ▓█   ▓██▒▒██▒ ░  ░ ▓█   ▓██▒▒ ▓███▀ ░░▓█▒░██▓░▒████▒   ░██░░▒▓███▀▒▒██░   ▓██░░██░  ▒██▒ ░ ░▒████▒
+ ▒▒   ▓▒█░▒▓▒░ ░  ░ ▒▒   ▓▒█░░ ░▒ ▒  ░ ▒ ░░▒░▒░░ ▒░ ░   ░▓   ░▒   ▒ ░ ▒░   ▒ ▒ ░▓    ▒ ░░   ░░ ▒░ ░
+  ▒   ▒▒ ░░▒ ░       ▒   ▒▒ ░  ░  ▒    ▒ ░▒░ ░ ░ ░  ░    ▒ ░  ░   ░ ░ ░░   ░ ▒░ ▒ ░    ░     ░ ░  ░
+  ░   ▒   ░░         ░   ▒   ░         ░  ░░ ░   ░       ▒ ░░ ░   ░    ░   ░ ░  ▒ ░  ░         ░
+      ░  ░               ░  ░░ ░       ░  ░  ░   ░  ░    ░        ░          ░  ░              ░  ░
+-->
+
+<!--
+Licensed to the Apache Software Foundation (ASF) under one
+or more contributor license agreements.  See the NOTICE file
+distributed with this work for additional information
+regarding copyright ownership.  The ASF licenses this file
+to you under the Apache License, Version 2.0 (the
+"License"); you may not use this file except in compliance
+with the License.  You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing,
+software distributed under the License is distributed on an
+"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, either express or implied.  See the License for the
+specific language governing permissions and limitations
+under the License.
+-->
+
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <link rel="canonical" href="https://ignite.apache.org/meetup-groups.html" />
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <meta http-equiv="Cache-Control" content="no-cache, no-store, must-revalidate" />
+    <meta http-equiv="Pragma" content="no-cache" />
+    <meta http-equiv="Expires" content="0" />
+    <title>Community Groups - Apache Ignite</title>
+    <!--#include virtual="/includes/styles.html" -->
+</head>
+<body>
+<div id="wrapper">
+    <!--#include virtual="/includes/header.html" -->
+
+    <main id="main" role="main" class="container">
+        <section id="news" class="page-section">
+            <h1 class="first">Find an Apache Ignite Meetup Near You</h1>
+			<p>Get involved with Apache Ignite developers, experts, and practitioners by joining an Apache Ignite or
+				In-Memory Computing meetup group near you. Can't find a meetup nearby or considering starting your own?
+				Send us a note to <a href="mailto:dev@ignite.apache.org">dev@ignite.apache.org</a>
+				and we'll see what can be done. </p>
+
+			
+<div class="row new-event margin-headline">
+	
+		<div class="col-md-12">
+			<ul id="meetup-groups" class="nav nav-tabs">
+     			<li class="active"><a href="#northamerica" aria-controls="profile" data-toggle="tab">
+					<div class="round-icon-block-tab hidden-xs">
+						<img src="images/meetup.svg" alt="Meetup Logo">
+					</div>
+					<div class="continent">North America</div>
+					</a>
+				</li>
+     			<li><a href="#europe" aria-controls="profile" data-toggle="tab">
+						
+					<div class="round-icon-block-tab hidden-xs">
+						<img src="images/meetup.svg" alt="Meetup Logo">
+					</div>
+					<div class="continent">Europe</div>
+					</a>
+				</li>
+     			<li><a href="#asia" aria-controls="profile" data-toggle="tab">
+						
+					<div class="round-icon-block-tab hidden-xs">
+						<img src="images/meetup.svg" alt="Meetup Logo">
+					</div>
+					<div class="continent">Asia Pacific</div>
+					
+					</a>
+				</li>
+ 			</ul>		
+		</div>
+
+<div class="tab-content">	
+	<div class="tab-pane active" id="northamerica">		
+		<div class="row meet-groups margin-headline">
+			<div class="col-md-4">
+				<h4>Seattle</h4>
+				<ul>
+					<li><a href="https://www.meetup.com/seattle-imc-meetup/" target="_blank" rel="noopener">Seattle In Memory Computing Meetup</a></li>
+				</ul>
+			</div>
+			<div class="col-md-4">
+				<h4>California</h4>
+				<ul>
+					<li><a href="https://www.meetup.com/Bay-Area-In-Memory-Computing/" target="_blank" rel="noopener">Bay Area In-Memory Computing Meetup</a></li>
+				</ul>
+			</div>
+			<div class="col-md-4">
+				<h4>Texas</h4>
+				<ul>
+					<li><a href="https://www.meetup.com/meetup-group-QkZjmswG/" target="_blank" rel="noopener">Dallas In-Memory Computing Meetup</a></li>
+				</ul>
+			</div>
+		</div>
+		<div class="row meet-groups">
+				<div class="col-md-4">
+					<h4>Georgia</h4>
+					<ul>
+						<li><a href="https://www.meetup.com/Atlanta-In-Memory-Computing/" target="_blank" rel="noopener">Atlanta In-Memory Computing Meetup</a></li>
+					</ul>
+				</div>
+				<div class="col-md-4">
+					<h4>New York</h4>
+					<ul>
+						<li><a href="https://www.meetup.com/NYC-In-Memory-Computing-Meetup/" target="_blank" rel="noopener">New York City In-Memory Computing Meetup</a></li>
+					</ul>
+				</div>
+				<div class="col-md-4">
+					<h4>Massachusetts</h4>
+					<ul>
+						<li><a href="https://www.meetup.com/meetup-group-HMwxfjeG/" target="_blank" rel="noopener">Boston In-Memory Computing Meetup</a></li>
+					</ul>
+				</div>	
+		</div>
+		<div class="row meet-groups">
+				<div class="col-md-4">
+					<h4>Illinois</h4>
+					<ul>
+						<li><a href="https://www.meetup.com/meetup-group-mqTCMocI/" target="_blank" rel="noopener">Chicago In-Memory Computing Meetup</a></li>
+					</ul>
+				</div>
+		</div>
+	</div>
+	<div class="tab-pane" id="europe">		
+		<div class="row meet-groups margin-headline">
+			<div class="col-md-4">
+				<h4>United Kingdom</h4>
+				<ul>
+					<li><a href="https://www.meetup.com/London-In-Memory-Computing-Meetup/" target="_blank" rel="noopener">London In Memory Computing Meetup</a></li>
+					<li><a href="https://www.meetup.com/Apache-Ignite-London/" target="_blank" rel="noopener">Apache Ignite<sup>®</sup> Meetup London</a></li>
+				</ul>
+			</div>
+			<div class="col-md-4">
+				<h4>Ireland</h4>
+				<ul>
+					<li><a href="https://www.meetup.com/Dublin-In-Memory-Computing-Meetup/" target="_blank" rel="noopener">Dublin In-Memory Computing Meetup</a></li>
+				</ul>
+			</div>
+			<div class="col-md-4">
+				<h4>France</h4>
+				<ul>
+					<li><a href="https://www.meetup.com/Paris-In-Memory-Computing-Meetup/" target="_blank" rel="noopener">Paris In-Memory Computing Meetup</a></li>
+				</ul>
+			</div>
+		</div>
+		<div class="row meet-groups">
+			<div class="col-md-4">
+				<h4>Russia</h4>
+				<ul>
+					<li><a href="https://www.meetup.com/St-Petersburg-Apache-Ignite-Meetup/" target="_blank" rel="noopener">St. Petersburg Apache Ignite<sup>®</sup> Meetup</a></li>
+					<li><a href="https://www.meetup.com/Moscow-Apache-Ignite-Meetup/" target="_blank" rel="noopener">Moscow Apache Ignite<sup>®</sup> Meetup</a></li>
+					<li><a href="https://www.meetup.com/Moscow-In-Memory-Computing-Meetup/" target="_blank" rel="noopener">Moscow In-Memory Computing Meetup</a></li>
+				</ul>
+			</div>
+		</div>
+	</div>
+	<div class="tab-pane" id="asia">		
+		<div class="row meet-groups margin-headline">
+			<div class="col-md-4">
+				<h4>China</h4>
+				<ul>
+					<li><a href="https://www.meetup.com/Hong-Kong-In-Memory-Computing-Meetup/" target="_blank" rel="noopener">Hong Kong In Memory Computing Meetup</a></li>
+					<li><a href="https://www.meetup.com/Shanghai-In-Memory-Computing-Meetup/" target="_blank" rel="noopener">Shanghai In Memory Computing Meetup</a></li>
+				</ul>
+			</div>
+			<div class="col-md-4">
+				<h4>Japan</h4>
+				<ul>
+					<li><a href="https://www.meetup.com/Tokyo-In-Memory-Computing-Meetup/" target="_blank" rel="noopener">Tokio In-Memory Computing Meetup</a></li>
+				</ul>
+			</div>
+			<div class="col-md-4">
+				<h4>Singapore</h4>
+				<ul>
+					<li><a href="https://www.meetup.com/Singapore-In-Memory-Computing-Meetup/" target="_blank" rel="noopener">Singapore In-Memory Computing Meetup</a></li>
+				</ul>
+			</div>
+		</div>
+	</div>
+</div>	
+</div>
+<div class="row new-event margin-headline">
+	<div class="col-md-12 text-center">
+		<p><b><i>Submission proposal:</i></b> Have a topic to present at a local meetup group? Please fill in <a href="https://docs.google.com/forms/d/e/1FAIpQLSdiY7movHKvyWg3gOVedHgukJJnNiaejSO_X838vBseL9VmiQ/viewform" target="_blank" rel="noopener">this form</a>.</p>
+	</div>
+</div>
+<div class="row new-event margin-headline">
+	<div class="col-md-12 text-center">
+		<p>Check the <a href="events.html">upcoming talks</a> featuring Apache Ignite</p>
+	</div>
+</div>
+    </section>
+    </main>
+
+    <!--#include virtual="/includes/footer.html" -->
+</div>
+<!--#include virtual="/includes/scripts.html" -->
+<!--
+<script type="text/javascript" src="js/jquery.main.js"></script>
+-->
+</body>
+</html>
diff --git a/scss/all.scss b/scss/all.scss
index 80f0eea..a1c3573 100755
--- a/scss/all.scss
+++ b/scss/all.scss
@@ -1,861 +1,862 @@
-@import "compass";
-@import "bootstrap";
-@import "markup-mixins";
-@font-face { @include fontface(atillanormal, atilla_normal-webfont) }
-@font-face { @include fontface(harabara, harabara-webfont) }
-@font-face { @include fontface(icomoon, icomoon) }
-html{
-    background: $gray-light;
-}
-body {
-    margin: 0;
-    min-width: $base-min-width;
-    line-height: $base-line-height;
-}
-a:hover, a:focus {
-    text-decoration: none;
-    outline: none;
-}
-@viewport { width: device-width;}
-@-o-viewport { width: device-width;}
-@-ms-viewport { width: device-width;}
-@-moz-viewport { width: device-width;}
-@-webkit-viewport { width: device-width;}
-[class^="icon-"],
-[class*=" icon-"] {
-    font-family: 'icomoon';
-    speak: none;
-    font-style: normal;
-    font-weight: normal;
-    font-variant: normal;
-    text-transform: none;
-    line-height: 1;
-    -webkit-font-smoothing: antialiased;
-    -moz-osx-font-smoothing: grayscale;
-}
-.icon-rss:before { content: "\e600"; }
-.icon-linkedin:before { content: "\e601"; }
-.icon-twitter:before { content: "\e602"; }
-.icon-facebook:before { content: "\e603"; }
-.icon-google-plus:before { content: "\e604"; }
-.icon-youtube:before { content: "\e605"; }
-h1, .h1{
-    line-height: 30px;
-    margin: 0;
-}
-h2, .h2{
-    line-height: 25px;
-    margin: 0;
-}
-h3, .h3{
-    line-height: 22px;
-    margin: 0;
-}
-h4, .h4 {
-    line-height: 20px;
-    margin: 0;
-}
-h5, .h5,
-h6, .h6 {
-    line-height: 17px;
-    margin: 0;
-}
-p {
-    margin: 0 0 $base-line-height;
-}
-.btn{
-    min-width: 160px;
-    height: 40px;
-    border-radius: 4px;
-    text-align: center;
-    text-transform: capitalize;
-    font-size: 20px;
-    line-height: 28px;
-    padding: 5px;
-    
-    @media (max-width: $mobile) {
-        min-width: 130px;
-        height: 36px;
-        font-size: 17px;
-        line-height: 24px;
-    }
-}
-.btn-default:hover {
-    background: $white;
-    color: $gray;
-}
-.btn-danger {
-    border: none;
-    line-height: 30px;
-    @include background-image(linear-gradient(top, #ff0000 0%,#eb0101 21%,#940206 77%,#7a0308 100%));
-    $experimental-support-for-svg: true;
-    
-    @media (max-width: $mobile) {
-        line-height: 26px;
-    }
-    &:hover {
-        @include background-image(linear-gradient(top, #7b0308 0%,#840308 10%,#9b0206 28%,#eb0101 79%,#ff0000 100%));
-    }
-}
-#wrapper{
-    overflow: hidden;
-}
-#header {
-    left: 0;
-    right: 0;
-    top: 37px;
-    z-index: 9999;
-    padding: 5px 0;
-    
-    &.affix-top {
-        position: absolute;
-        
-        @media (max-width: $tablet) {
-            top: 0;
-        }
-    }
-    &.affix {
-        top: 0;
-        background: rgba(54,54,54,0.95);
-        
-        @media (max-width: $tablet) {
-            position: absolute;
-            /*background: none;*/
-        }
-    }
-    .container {
-        position: relative;
-    }
-    .logo {
-        width: 140px;
-        margin: 0 0 0 1px;
-        
-        img{
-            @extend %img-full-width;
-        }
-    }
-    div[class*="col-"] {
-        position: static;
-    }
-}
-#nav {
-    text-align: right;
-    font-size: 16px;
-    line-height: 20px;
-    padding: 21px 0 0;
-    letter-spacing: 0.1px;
-    position: static;
-    
-    @media (max-width: $mobile) {
-        padding: 10px 10px 0;
-        text-align: center;
-        
-        .navbar-collapse {
-            overflow: hidden;
-            position: absolute;
-            top: 100%;
-            left: 0;
-            right: 0;
-            z-index: 99;
-            margin: 10px 0 0;
-            background: rgba(54,54,54,0.95);
-        }
-    }
-    .container-fluid {
-        padding: 0;
-    }
-    .navbar-toggle {
-        margin: 0;
-    }
-    .navbar-nav {
-        float: none;
-        letter-spacing: -4px;
-        
-        @media (max-width: $mobile) {
-            padding: 10px 0;
-        }
-        > li {
-            @extend %align-top;
-            letter-spacing: normal;
-            float: none;
-            margin: 0 0 0 20px;
-            
-            @media (max-width: $mobile) {
-                display: block;
-                margin: 0;
-                padding: 5px 10px;
-            }
-            >a {
-                padding: 0;
-                @extend %align-top;
-            }
-        }
-    }
-}
-.carousel {
-    min-height: 597px;
-    padding: 114px 0 50px;
-    font-size: 18px;
-    line-height: 24px;
-    color: $white;
-    text-align: center;
-    position: relative;
-    z-index: 9;
-    background: url(../images/bg-carousel.jpg) no-repeat center/cover;
-    @include transition(all, 0.2s, linear);
-    
-    @media (max-width: $tablet) {
-        min-height: 470px;
-        padding: 100px 0 50px;
-    }
-    @media (max-width: $mobile) {
-        min-height: 300px;
-        font-size: 14px;
-        line-height: 17px;
-        padding: 100px 0 20px;
-    }
-    &:after {
-        height: 106px;
-        @include after(auto,0,0,0);
-        @include background-image(linear-gradient(top, rgba(47,47,47,0) 0%,rgba(47,47,47,0.05) 8%,rgba(47,47,47,0.18) 23%,rgba(47,47,47,0.82) 77%,rgba(47,47,47,0.95) 92%,rgba(47,47,47,1) 100%));
-        $experimental-support-for-svg: true;
-        pointer-events: none;
-        
-        @media (max-width: $tablet) {
-            height: 60px;
-        }
-        @media (max-width: $mobile) {
-            height: 30px;
-        }
-    }
-    .item {
-        padding: 82px 0 0;
-        
-        @media (max-width: $tablet) {
-            padding: 20px 0 0;
-        }
-    }
-    header {
-        font-size: 28px;
-        line-height: 36px;
-        text-transform: capitalize;
-        letter-spacing: 0.8px;
-        
-        @media (max-width: $tablet) {
-            font-size: 25px;
-            line-height: 30px;
-        }
-        @media (max-width: $mobile) {
-            font-size: 20px;
-        }
-        p{
-            margin: 0 0 18px;
-            
-            @media (max-width: $mobile) {
-                margin: 0 0 10px;
-            }
-        }
-    }
-    h2 {
-        font: 100px/100px $alt-font-harabara;
-        letter-spacing: 2.3px;
-        margin: 0 0 15px;
-        
-        @media (max-width: $tablet) {
-            font-size: 70px;
-            line-height: 70px;
-        }
-        @media (max-width: $mobile) {
-            font-size: 42px;
-            line-height: 42px;
-            margin: 0 0 5px;
-        }
-    }
-    .buttons {
-        margin: 0 0 12px;
-        letter-spacing: -4px;
-        
-        @media (max-width: $mobile) {
-            margin: 0;
-        }
-        li{
-            @extend %align-top;
-            letter-spacing: normal;
-            margin: 0 10px 10px;
-        }
-    }
-    .text {
-        max-width: 820px;
-        margin: 0 auto;
-    }
-    p{
-        margin: 0;
-    }
-    .item.cloud{
-        padding: 0;
-        text-align: right;
-        
-        @media (max-width: $mobile) {
-            text-align: center;
-        }
-        h1 {
-            font-size: 53px;
-            line-height: 53px;
-            letter-spacing: 1.3px;
-            margin: 0 0 6px;
-            
-            @media (max-width: $tablet) {
-                font-size: 42px;
-                line-height: 45px;
-            }
-        }
-        header {
-            font-size: 15px;
-            line-height: 20px;
-            letter-spacing: 0.4px;
-            margin: 104px -2px 0 0;
-            
-            @media (max-width: $tablet) {
-                font-size: 15px;
-                line-height: 18px;
-                margin: 50px 0 0;
-            }
-            @media (max-width: $mobile) {
-                margin: 0;
-            }
-            p{
-                margin: 0 0 7px;
-            }
-        }
-        .buttons li {
-            margin: 0 0 10px 13px;
-        }
-        .btn{
-            height: 26px;
-            min-width: 104px;
-            font-size: 13px;
-            line-height: 18px;
-            padding: 4px;
-        }
-    }
-    .img-holder {
-        overflow: hidden;
-        margin: 0 0 0 -9px;
-        
-        @media (max-width: $mobile) {
-            margin: 0;
-        }
-        img{
-            @extend %img-full-width;
-        }
-    }
-}
-#main {
-    margin-bottom: 50px;
-    
-    @media (max-width: $mobile) {
-        margin-bottom: 0;
-    }
-    table{
-        width: 100%;
-        border: 2px solid  $gray-light;
-        
-        th,
-        td {
-            height: 40px;
-            border-width: 0 0 2px 2px;
-            border-color: $gray-light;
-            border-style: solid;
-            padding: 5px 20px;
-            position: relative;
-            
-            &:first-child {
-                border-left-width: 0;
-            }
-        }
-        th{
-            font-size: 18px;
-            line-height: 20px;
-            height: 50px;
-            @media (max-width: $tablet) {
-                font-size: 15px;
-            }
-            &:first-child{
-                padding: 5px 38px;
-            }
-        }
-        td:first-child{
-            padding-left: 38px;
-        }
-        .btn-video {
-            color: $black;
-            
-            &:hover {
-                color: $red;
-            }
-        }
-        @media screen {
-            @media (max-width: $mobile) {
-                border: none;
-                display: block;
-                overflow:hidden;
-                border-top:1px solid $black;
-                
-                tbody {
-                    border-left:120px solid $gray;
-                    float:left;
-                    width:100%;
-                    padding:0 1px 0 1px;
-                }
-                tr {
-                    float:left;
-                    width:100%;
-                    clear:both;
-                    
-                    &:nth-child(odd) td {
-                        background-color: rgba(0,0,0,0.1);
-                    }
-                }
-                td {
-                    width: 100% !important;
-                    height: auto;
-                    padding:0 0 0 120px !important;
-                    margin:0 -1px 0 -121px;
-                    display: block;
-                    float:left;
-                    clear:both;
-                    width:100%;
-                    white-space:nowrap;
-                    border-width: 0 1px 1px 1px !important;
-                    border-color: $black;
-                    @include box-sizing(content-box);
-                    
-                    &:before {
-                        content:attr(title);
-                        padding: 10px;
-                        display:inline-block;
-                        color:$white !important;
-                        font-weight:bold;
-                        width:120px;
-                        vertical-align:middle;
-                        margin:0 0 0 -120px;
-                        position:relative;
-                        white-space:normal;
-                    }
-                    ul,
-                    span {
-                        white-space:normal;
-                        display:inline-block;
-                        vertical-align:middle;
-                        padding:5px;
-                    }
-                }
-                thead,
-                th {display:none;}
-            }
-        }
-    }
-}
-.overview {
-    margin: -8px 0 0;
-    padding: 80px 0 0;
-    position: relative;
-    z-index: 4;
-    
-    @media (max-width: $tablet) {
-        margin: 0;
-        padding: 30px 0 0;
-    }
-    h2{
-        position: relative;
-        padding: 3px 0 12px 40px;
-        
-        &:after {
-            @include size(21px,25px);
-            @include after(0,auto,auto,0);
-            background: url(../images/sprite.png) no-repeat;
-        }
-    }
-}
-.askquestion {
-    margin: -18px 0 0;
-    padding: 80px 0 0;
-    position: relative;
-    
-    @media (max-width: $tablet) {
-        margin: 0;
-        padding: 30px 0 0;
-    }
-    table {
-        @media (min-width: $min-mobile) {
-            
-            th,
-            td {
-                width: 60%;
-                padding: 5px 20px !important;
-                
-                &:first-child,
-                &:nth-child(2) {
-                    width: 20%;
-                }
-            }
-        }
-    }
-    h2{
-        position: relative;
-        padding: 4px 0 13px 40px;
-        
-        &:after {
-            @include size(21px,25px);
-            @include after(0,auto,auto,3px);
-            background: url(../images/sprite.png) no-repeat -52px 0;
-        }
-    }
-}
-.community {
-    margin: -18px 0 0;
-    padding: 80px 0 0;
-    position: relative;
-    z-index: 2;
-    
-    @media (max-width: $tablet) {
-        margin: 0;
-        padding: 30px 0 0;
-    }
-    table {
-        @media (min-width: $min-mobile) {
-            
-            th,
-            td {
-                width: 60%;
-                padding: 5px 20px !important;
-                
-                &:first-child,
-                &:nth-child(2) {
-                    width: 20%;
-                }
-            }
-        }
-    }
-    h2{
-        position: relative;
-        padding: 4px 0 13px 40px;
-        
-        &:after {
-            @include size(21px,25px);
-            @include after(0,auto,auto,3px);
-            background: url(../images/sprite.png) no-repeat -52px 0;
-        }
-    }
-}
-.download {
-    margin: -54px 0 0;
-    padding: 80px 0 94px;
-    
-    @media (max-width: $tablet) {
-        padding: 30px 0;
-        margin: 0;
-    }
-    h2{
-        position: relative;
-        padding: 3px 0 8px 40px;
-        
-        &:after {
-            @include size(21px,25px);
-            @include after(0,auto,auto,3px);
-            background: url(../images/sprite.png) no-repeat -78px 0;
-        }
-    }
-    th{
-        &:first-child {
-            width: 476px;
-        }
-        &.version {
-            width: 240px;
-        }
-        &.release {
-            width: 220px;
-        }
-    }
-}
-.info-blocks {
-    padding: 101px 0 24px;
-    border-top: 2px solid $gray-light;
-    
-    @media (max-width: $tablet) {
-        padding: 30px 0 20px;
-    }
-    h3{
-        margin: 0 0 10px;
-        
-        @media (max-width: $mobile) {
-            margin: 0;
-        }
-    }
-    p{
-        margin: 0 0 7px;
-    }
-    .list {
-        line-height: 18px;
-    }
-    li {
-        padding: 0 0 0 20px;
-        position: relative;
-        @include arrow-lazy(right, 5px, $gray-dark, 4px);
-        
-        &:before{
-            left: 0;
-            margin: 0;
-        }
-    }
-    a {
-        color: $black;
-        
-        &:hover {
-            color: $red;
-        }
-    }
-}
-#footer {
-    padding: 50px 0 30px;
-    background: $gray-light;
-
-    @media (max-width: $mobile) {
-        text-align: center;
-        padding: 30px 0 10px;
-    }
-    a {
-        color: $black;
-        
-        &:hover {
-            color: $red;
-        }
-    }
-    .logo {
-        width: 230px;
-        @extend %align-top;
-        margin: 0 0 20px;
-        
-        @media (max-width: $mobile) {
-            width: 150px;
-            margin: 0 0 10px;
-        }
-        img{
-            @extend %img-full-width;
-        }
-    }
-    p{
-        margin: 0 0 22px;
-        
-        @media (max-width: $mobile) {
-            margin: 0 0 10px;
-        }
-    }
-    .security {
-        letter-spacing: -4px;
-        margin: 0 -69px 0 0;
-        
-        @media (max-width: $mobile){
-            margin: 0;
-        }
-        li{
-            @extend %align-top;
-            letter-spacing: normal;
-            margin: 0 69px 20px 0;
-            
-            @media (max-width: $mobile) {
-                margin: 0 20px 10px;
-            }
-        }
-        a:hover {
-            @include opacity(0.8);
-        }
-        img {
-            display: block;
-        }
-    }
-}
-.footer-nav {
-    line-height: 18px;
-    
-    ul {
-        margin: 0;
-    }
-    li{
-        margin: 0 0 12px;
-        
-        @media (max-width: $mobile) {
-            margin: 0 0 5px;
-        }
-    }
-}
-.social-networks{
-    font-size: 30px;
-    letter-spacing: -4px;
-    margin: 0 0 16px;
-    
-    li{
-        @extend %align-top;
-        letter-spacing: normal;
-        margin: 0 3px 10px 0;
-        
-        @media (max-width: $mobile) {
-            margin: 0 3px 10px;
-        }
-    }
-    a{
-        color: $gray !important;
-        
-        &:hover {
-            color: $red !important;
-        }
-    }
-}
-.subnav {
-    padding: 55px 0 10px;
-    text-align: center;
-    
-    @media (max-width: $mobile) {
-        padding: 0 0 10px;
-    }
-    ul{
-        margin: 0;
-        letter-spacing: -4px;
-    }
-    li{
-        @extend %align-top;
-        letter-spacing: normal;
-        margin: 0 34px;
-        
-        @media (max-width: $mobile) {
-            display: block;
-            margin: 0 0 5px;
-        }
-    }
-}
-
-@import "ignite";
-
-.btn-transparent {
-    @include button-variant($btn-transparent-color, $btn-transparent-bg, $btn-transparent-border);
-}
-
-.btn-transparent:hover {
-    background: $white;
-    color: $gray;
-}
-
-.btn-group-export {
-    position: absolute;
-    margin: 5px;
-    top: 0;
-    right: 0;
-    z-index: 4;
-}
-
-.btn-export {
-    min-width: 0;
-}
-
-@media screen and (max-width: $screen-xs-max) {
-    .btn-group-export {
-        display: none;
-    }
-}
-
-/*
- * Reset media print style.
- */
-@media print {
-    #header {
-        position: absolute !important;
-    }
-
-    a[href]:after {
-        content: "";
-    }
-
-    /*
-     * Hide social icons.
-     */
-    .social-networks {
-        display: none;
-    }
-
-    /*
-     * Hide navigation menu.
-     */
-    footer nav {
-        display: none;
-    }
-
-    /*
-     * Hide button to download export for table.
-     */
-    .btn-group-export {
-        display: none;
-    }
-
-    body {
-        -webkit-print-color-adjust: exact;
-    }
-
-    footer {
-        page-break-inside: avoid;
-    }
-
-    section.page-section {
-        page-break-inside: avoid;
-    }
-
-    section.page-section table {
-        page-break-inside: avoid;
-    }
-
-    section.page-section:first-child {
-        margin-top: 50px;
-    }
-
-    section.page-section {
-        padding-top: 0;
-        margin-top: 0;
-        margin-bottom: 50px;
-
-        border-bottom: none;
-    }
-
-    section.page-section p.line-chart {
-        display: none;
-    }
-
-    /*
-     * Small grid
-     *
-     * Columns, offsets, pushes, and pulls for the small device range, from phones
-     * to tablets.
-     */
-
-    /* @media (min-width: $mobile) {
-        @include make-grid(print);
-    }*/
-
-    @media (min-width: $landscape) {
-        @include make-grid(print);
-
-        #main table td {
-            padding-left: 0;
-        }
-
-        #main table th {
-            padding-left: 0;
-        }
-
-        #main table td:first-child {
-            padding-left: 20px;
-        }
-
-        #main table th:first-child {
-            padding-left: 20px;
-        }
-    }
+@import "compass";
+@import "bootstrap";
+@import "markup-mixins";
+@font-face { @include fontface(atillanormal, atilla_normal-webfont) }
+@font-face { @include fontface(harabara, harabara-webfont) }
+@font-face { @include fontface(icomoon, icomoon) }
+html{
+    background: $gray-light;
+}
+body {
+    margin: 0;
+    min-width: $base-min-width;
+    line-height: $base-line-height;
+}
+a:hover, a:focus {
+    text-decoration: none;
+    outline: none;
+}
+@viewport { width: device-width;}
+@-o-viewport { width: device-width;}
+@-ms-viewport { width: device-width;}
+@-moz-viewport { width: device-width;}
+@-webkit-viewport { width: device-width;}
+[class^="icon-"],
+[class*=" icon-"] {
+    font-family: 'icomoon';
+    speak: none;
+    font-style: normal;
+    font-weight: normal;
+    font-variant: normal;
+    text-transform: none;
+    line-height: 1;
+    -webkit-font-smoothing: antialiased;
+    -moz-osx-font-smoothing: grayscale;
+}
+.icon-rss:before { content: "\e600"; }
+.icon-linkedin:before { content: "\e601"; }
+.icon-twitter:before { content: "\e602"; }
+.icon-facebook:before { content: "\e603"; }
+.icon-google-plus:before { content: "\e604"; }
+.icon-youtube:before { content: "\e605"; }
+h1, .h1{
+    line-height: 30px;
+    margin: 0;
+}
+h2, .h2{
+    line-height: 25px;
+    margin: 0;
+}
+h3, .h3{
+    line-height: 22px;
+    margin: 0;
+}
+h4, .h4 {
+    line-height: 20px;
+    margin: 0;
+}
+h5, .h5,
+h6, .h6 {
+    line-height: 17px;
+    margin: 0;
+}
+p {
+    margin: 0 0 $base-line-height;
+}
+.btn{
+    min-width: 160px;
+    height: 40px;
+    border-radius: 4px;
+    text-align: center;
+    text-transform: capitalize;
+    font-size: 20px;
+    line-height: 28px;
+    padding: 5px;
+    
+    @media (max-width: $mobile) {
+        min-width: 130px;
+        height: 36px;
+        font-size: 17px;
+        line-height: 24px;
+    }
+}
+.btn-default:hover {
+    background: $white;
+    color: $gray;
+}
+.btn-danger {
+    border: none;
+    line-height: 30px;
+    @include background-image(linear-gradient(top, #ff0000 0%,#eb0101 21%,#940206 77%,#7a0308 100%));
+    $experimental-support-for-svg: true;
+    
+    @media (max-width: $mobile) {
+        line-height: 26px;
+    }
+    &:hover {
+        @include background-image(linear-gradient(top, #7b0308 0%,#840308 10%,#9b0206 28%,#eb0101 79%,#ff0000 100%));
+    }
+}
+#wrapper{
+    overflow: hidden;
+}
+#header {
+    left: 0;
+    right: 0;
+    top: 37px;
+    z-index: 9999;
+    padding: 5px 0;
+    
+    &.affix-top {
+        position: absolute;
+        
+        @media (max-width: $tablet) {
+            top: 0;
+        }
+    }
+    &.affix {
+        top: 0;
+        background: rgba(54,54,54,0.95);
+        
+        @media (max-width: $tablet) {
+            position: absolute;
+            /*background: none;*/
+        }
+    }
+    .container {
+        position: relative;
+    }
+    .logo {
+        width: 140px;
+        margin: 0 0 0 1px;
+        
+        img{
+            @extend %img-full-width;
+        }
+    }
+    div[class*="col-"] {
+        position: static;
+    }
+}
+#nav {
+    text-align: right;
+    font-size: 16px;
+    line-height: 20px;
+    padding: 21px 0 0;
+    letter-spacing: 0.1px;
+    position: static;
+    
+    @media (max-width: $mobile) {
+        padding: 10px 10px 0;
+        text-align: center;
+        
+        .navbar-collapse {
+            overflow: hidden;
+            position: absolute;
+            top: 100%;
+            left: 0;
+            right: 0;
+            z-index: 99;
+            margin: 10px 0 0;
+            background: rgba(54,54,54,0.95);
+        }
+    }
+    .container-fluid {
+        padding: 0;
+    }
+    .navbar-toggle {
+        margin: 0;
+    }
+    .navbar-nav {
+        float: none;
+        letter-spacing: -4px;
+        
+        @media (max-width: $mobile) {
+            padding: 10px 0;
+        }
+        > li {
+            @extend %align-top;
+            letter-spacing: normal;
+            float: none;
+            margin: 0 0 0 20px;
+            
+            @media (max-width: $mobile) {
+                display: block;
+                margin: 0;
+                padding: 5px 10px;
+            }
+            >a {
+                padding: 0;
+                @extend %align-top;
+            }
+        }
+    }
+}
+.carousel {
+    min-height: 597px;
+    padding: 114px 0 50px;
+    font-size: 18px;
+    line-height: 24px;
+    color: $white;
+    text-align: center;
+    position: relative;
+    z-index: 9;
+    background: url(../images/bg-carousel.jpg) no-repeat center/cover;
+    @include transition(all, 0.2s, linear);
+    
+    @media (max-width: $tablet) {
+        min-height: 470px;
+        padding: 100px 0 50px;
+    }
+    @media (max-width: $mobile) {
+        min-height: 300px;
+        font-size: 14px;
+        line-height: 17px;
+        padding: 100px 0 20px;
+    }
+    &:after {
+        height: 106px;
+        @include after(auto,0,0,0);
+        @include background-image(linear-gradient(top, rgba(47,47,47,0) 0%,rgba(47,47,47,0.05) 8%,rgba(47,47,47,0.18) 23%,rgba(47,47,47,0.82) 77%,rgba(47,47,47,0.95) 92%,rgba(47,47,47,1) 100%));
+        $experimental-support-for-svg: true;
+        pointer-events: none;
+        
+        @media (max-width: $tablet) {
+            height: 60px;
+        }
+        @media (max-width: $mobile) {
+            height: 30px;
+        }
+    }
+    .item {
+        padding: 82px 0 0;
+        
+        @media (max-width: $tablet) {
+            padding: 20px 0 0;
+        }
+    }
+    header {
+        font-size: 28px;
+        line-height: 36px;
+        text-transform: capitalize;
+        letter-spacing: 0.8px;
+        
+        @media (max-width: $tablet) {
+            font-size: 25px;
+            line-height: 30px;
+        }
+        @media (max-width: $mobile) {
+            font-size: 20px;
+        }
+        p{
+            margin: 0 0 18px;
+            
+            @media (max-width: $mobile) {
+                margin: 0 0 10px;
+            }
+        }
+    }
+    h2 {
+        font: 100px/100px $alt-font-harabara;
+        letter-spacing: 2.3px;
+        margin: 0 0 15px;
+        
+        @media (max-width: $tablet) {
+            font-size: 70px;
+            line-height: 70px;
+        }
+        @media (max-width: $mobile) {
+            font-size: 42px;
+            line-height: 42px;
+            margin: 0 0 5px;
+        }
+    }
+    .buttons {
+        margin: 0 0 12px;
+        letter-spacing: -4px;
+        
+        @media (max-width: $mobile) {
+            margin: 0;
+        }
+        li{
+            @extend %align-top;
+            letter-spacing: normal;
+            margin: 0 10px 10px;
+        }
+    }
+    .text {
+        max-width: 820px;
+        margin: 0 auto;
+    }
+    p{
+        margin: 0;
+    }
+    .item.cloud{
+        padding: 0;
+        text-align: right;
+        
+        @media (max-width: $mobile) {
+            text-align: center;
+        }
+        h1 {
+            font-size: 53px;
+            line-height: 53px;
+            letter-spacing: 1.3px;
+            margin: 0 0 6px;
+            
+            @media (max-width: $tablet) {
+                font-size: 42px;
+                line-height: 45px;
+            }
+        }
+        header {
+            font-size: 15px;
+            line-height: 20px;
+            letter-spacing: 0.4px;
+            margin: 104px -2px 0 0;
+            
+            @media (max-width: $tablet) {
+                font-size: 15px;
+                line-height: 18px;
+                margin: 50px 0 0;
+            }
+            @media (max-width: $mobile) {
+                margin: 0;
+            }
+            p{
+                margin: 0 0 7px;
+            }
+        }
+        .buttons li {
+            margin: 0 0 10px 13px;
+        }
+        .btn{
+            height: 26px;
+            min-width: 104px;
+            font-size: 13px;
+            line-height: 18px;
+            padding: 4px;
+        }
+    }
+    .img-holder {
+        overflow: hidden;
+        margin: 0 0 0 -9px;
+        
+        @media (max-width: $mobile) {
+            margin: 0;
+        }
+        img{
+            @extend %img-full-width;
+        }
+    }
+}
+#main {
+    margin-bottom: 50px;
+    
+    @media (max-width: $mobile) {
+        margin-bottom: 0;
+    }
+	
+    table{
+        width: 100%;
+        border: 2px solid  $gray-light;
+        
+        th,
+        td {
+            height: 40px;
+            border-width: 0 0 2px 2px;
+            border-color: $gray-light;
+            border-style: solid;
+            padding: 5px 20px;
+            position: relative;
+            
+            &:first-child {
+                border-left-width: 0;
+            }
+        }
+        th{
+            font-size: 18px;
+            line-height: 20px;
+            height: 50px;
+            @media (max-width: $tablet) {
+                font-size: 15px;
+            }
+            &:first-child{
+                padding: 5px 38px;
+            }
+        }
+        td:first-child{
+            padding-left: 38px;
+        }
+        .btn-video {
+            color: $black;
+            
+            &:hover {
+                color: $red;
+            }
+        }
+        @media screen {
+            @media (max-width: $mobile) {
+                border: none;
+                display: block;
+                overflow:hidden;
+                border-top:1px solid $black;
+                
+                tbody {
+                    border-left:120px solid $gray;
+                    float:left;
+                    width:100%;
+                    padding:0 1px 0 1px;
+                }
+                tr {
+                    float:left;
+                    width:100%;
+                    clear:both;
+                    
+                    &:nth-child(odd) td {
+                        background-color: rgba(0,0,0,0.1);
+                    }
+                }
+                td {
+                    width: 100% !important;
+                    height: auto;
+                    padding:0 0 0 120px !important;
+                    margin:0 -1px 0 -121px;
+                    display: block;
+                    float:left;
+                    clear:both;
+                    width:100%;
+                    white-space:nowrap;
+                    border-width: 0 1px 1px 1px !important;
+                    border-color: $black;
+                    @include box-sizing(content-box);
+                    
+                    &:before {
+                        content:attr(title);
+                        padding: 10px;
+                        display:inline-block;
+                        color:$white !important;
+                        font-weight:bold;
+                        width:120px;
+                        vertical-align:middle;
+                        margin:0 0 0 -120px;
+                        position:relative;
+                        white-space:normal;
+                    }
+                    ul,
+                    span {
+                        white-space:normal;
+                        display:inline-block;
+                        vertical-align:middle;
+                        padding:5px;
+                    }
+                }
+                thead,
+                th {display:none;}
+            }
+        }
+    }
+}
+.overview {
+    margin: -8px 0 0;
+    padding: 80px 0 0;
+    position: relative;
+    z-index: 4;
+    
+    @media (max-width: $tablet) {
+        margin: 0;
+        padding: 30px 0 0;
+    }
+    h2{
+        position: relative;
+        padding: 3px 0 12px 40px;
+        
+        &:after {
+            @include size(21px,25px);
+            @include after(0,auto,auto,0);
+            background: url(../images/sprite.png) no-repeat;
+        }
+    }
+}
+.askquestion {
+    margin: -18px 0 0;
+    padding: 80px 0 0;
+    position: relative;
+    
+    @media (max-width: $tablet) {
+        margin: 0;
+        padding: 30px 0 0;
+    }
+    table {
+        @media (min-width: $min-mobile) {
+            
+            th,
+            td {
+                width: 60%;
+                padding: 5px 20px !important;
+                
+                &:first-child,
+                &:nth-child(2) {
+                    width: 20%;
+                }
+            }
+        }
+    }
+    h2{
+        position: relative;
+        padding: 4px 0 13px 40px;
+        
+        &:after {
+            @include size(21px,25px);
+            @include after(0,auto,auto,3px);
+            background: url(../images/sprite.png) no-repeat -52px 0;
+        }
+    }
+}
+.community {
+    margin: -18px 0 0;
+    padding: 80px 0 0;
+    position: relative;
+    z-index: 2;
+    
+    @media (max-width: $tablet) {
+        margin: 0;
+        padding: 30px 0 0;
+    }
+    table {
+        @media (min-width: $min-mobile) {
+            
+            th,
+            td {
+                width: 60%;
+                padding: 5px 20px !important;
+                
+                &:first-child,
+                &:nth-child(2) {
+                    width: 20%;
+                }
+            }
+        }
+    }
+    h2{
+        position: relative;
+        padding: 4px 0 13px 40px;
+        
+        &:after {
+            @include size(21px,25px);
+            @include after(0,auto,auto,3px);
+            background: url(../images/sprite.png) no-repeat -52px 0;
+        }
+    }
+}
+.download {
+    margin: -54px 0 0;
+    padding: 80px 0 94px;
+    
+    @media (max-width: $tablet) {
+        padding: 30px 0;
+        margin: 0;
+    }
+    h2{
+        position: relative;
+        padding: 3px 0 8px 40px;
+        
+        &:after {
+            @include size(21px,25px);
+            @include after(0,auto,auto,3px);
+            background: url(../images/sprite.png) no-repeat -78px 0;
+        }
+    }
+    th{
+        &:first-child {
+            width: 476px;
+        }
+        &.version {
+            width: 240px;
+        }
+        &.release {
+            width: 220px;
+        }
+    }
+}
+.info-blocks {
+    padding: 101px 0 24px;
+    border-top: 2px solid $gray-light;
+    
+    @media (max-width: $tablet) {
+        padding: 30px 0 20px;
+    }
+    h3{
+        margin: 0 0 10px;
+        
+        @media (max-width: $mobile) {
+            margin: 0;
+        }
+    }
+    p{
+        margin: 0 0 7px;
+    }
+    .list {
+        line-height: 18px;
+    }
+    li {
+        padding: 0 0 0 20px;
+        position: relative;
+        @include arrow-lazy(right, 5px, $gray-dark, 4px);
+        
+        &:before{
+            left: 0;
+            margin: 0;
+        }
+    }
+    a {
+        color: $black;
+        
+        &:hover {
+            color: $red;
+        }
+    }
+}
+#footer {
+    padding: 50px 0 30px;
+    background: $gray-light;
+
+    @media (max-width: $mobile) {
+        text-align: center;
+        padding: 30px 0 10px;
+    }
+    a {
+        color: $black;
+        
+        &:hover {
+            color: $red;
+        }
+    }
+    .logo {
+        width: 230px;
+        @extend %align-top;
+        margin: 0 0 20px;
+        
+        @media (max-width: $mobile) {
+            width: 150px;
+            margin: 0 0 10px;
+        }
+        img{
+            @extend %img-full-width;
+        }
+    }
+    p{
+        margin: 0 0 22px;
+        
+        @media (max-width: $mobile) {
+            margin: 0 0 10px;
+        }
+    }
+    .security {
+        letter-spacing: -4px;
+        margin: 0 -69px 0 0;
+        
+        @media (max-width: $mobile){
+            margin: 0;
+        }
+        li{
+            @extend %align-top;
+            letter-spacing: normal;
+            margin: 0 69px 20px 0;
+            
+            @media (max-width: $mobile) {
+                margin: 0 20px 10px;
+            }
+        }
+        a:hover {
+            @include opacity(0.8);
+        }
+        img {
+            display: block;
+        }
+    }
+}
+.footer-nav {
+    line-height: 18px;
+    
+    ul {
+        margin: 0;
+    }
+    li{
+        margin: 0 0 12px;
+        
+        @media (max-width: $mobile) {
+            margin: 0 0 5px;
+        }
+    }
+}
+.social-networks{
+    font-size: 30px;
+    letter-spacing: -4px;
+    margin: 0 0 16px;
+    
+    li{
+        @extend %align-top;
+        letter-spacing: normal;
+        margin: 0 3px 10px 0;
+        
+        @media (max-width: $mobile) {
+            margin: 0 3px 10px;
+        }
+    }
+    a{
+        color: $gray !important;
+        
+        &:hover {
+            color: $red !important;
+        }
+    }
+}
+.subnav {
+    padding: 55px 0 10px;
+    text-align: center;
+    
+    @media (max-width: $mobile) {
+        padding: 0 0 10px;
+    }
+    ul{
+        margin: 0;
+        letter-spacing: -4px;
+    }
+    li{
+        @extend %align-top;
+        letter-spacing: normal;
+        margin: 0 34px;
+        
+        @media (max-width: $mobile) {
+            display: block;
+            margin: 0 0 5px;
+        }
+    }
+}
+
+@import "ignite";
+
+.btn-transparent {
+    @include button-variant($btn-transparent-color, $btn-transparent-bg, $btn-transparent-border);
+}
+
+.btn-transparent:hover {
+    background: $white;
+    color: $gray;
+}
+
+.btn-group-export {
+    position: absolute;
+    margin: 5px;
+    top: 0;
+    right: 0;
+    z-index: 4;
+}
+
+.btn-export {
+    min-width: 0;
+}
+
+@media screen and (max-width: $screen-xs-max) {
+    .btn-group-export {
+        display: none;
+    }
+}
+
+/*
+ * Reset media print style.
+ */
+@media print {
+    #header {
+        position: absolute !important;
+    }
+
+    a[href]:after {
+        content: "";
+    }
+
+    /*
+     * Hide social icons.
+     */
+    .social-networks {
+        display: none;
+    }
+
+    /*
+     * Hide navigation menu.
+     */
+    footer nav {
+        display: none;
+    }
+
+    /*
+     * Hide button to download export for table.
+     */
+    .btn-group-export {
+        display: none;
+    }
+
+    body {
+        -webkit-print-color-adjust: exact;
+    }
+
+    footer {
+        page-break-inside: avoid;
+    }
+
+    section.page-section {
+        page-break-inside: avoid;
+    }
+
+    section.page-section table {
+        page-break-inside: avoid;
+    }
+
+    section.page-section:first-child {
+        margin-top: 50px;
+    }
+
+    section.page-section {
+        padding-top: 0;
+        margin-top: 0;
+        margin-bottom: 50px;
+
+        border-bottom: none;
+    }
+
+    section.page-section p.line-chart {
+        display: none;
+    }
+
+    /*
+     * Small grid
+     *
+     * Columns, offsets, pushes, and pulls for the small device range, from phones
+     * to tablets.
+     */
+
+    /* @media (min-width: $mobile) {
+        @include make-grid(print);
+    }*/
+
+    @media (min-width: $landscape) {
+        @include make-grid(print);
+
+        #main table td {
+            padding-left: 0;
+        }
+
+        #main table th {
+            padding-left: 0;
+        }
+
+        #main table td:first-child {
+            padding-left: 20px;
+        }
+
+        #main table th:first-child {
+            padding-left: 20px;
+        }
+    }
 }
\ No newline at end of file
diff --git a/scss/ignite.scss b/scss/ignite.scss
index c34b5da..2d69c60 100644
--- a/scss/ignite.scss
+++ b/scss/ignite.scss
@@ -58,6 +58,145 @@
 $color-concrete: #95A5A6;
 $color-asbestos: #7F8C8D;
 
+
+////////*****EVENTS PAGE CSS 2020 UPDATE*****////////
+
+
+.round-icon-block-tab {
+			border-radius: 10px;
+			background:#eeeeee;
+			padding:5px;
+			display: block;
+			float: left;
+			margin-right:8px;
+
+			img {
+					margin:0px auto;
+					max-width:20px;
+					width:20px;
+					display: block;
+			}
+}
+
+.continent {
+		display: block;
+		float: left;
+}
+
+
+.meet-groups {
+	padding:30px;
+	
+	ul {
+		margin-left:0px;
+		padding-left:0px;
+		margin-top:5px;
+		
+		li {
+			list-style:none;
+			margin-bottom:10px;
+			
+			a {
+				font-size:16px;
+				color:#555555;
+			}
+			
+			a:hover {
+				color:red;
+			}
+		}
+	}
+}
+
+#meetup-groups {
+	
+	li {
+		 a {clear:both; overflow:hidden;}
+	}
+		.active {
+			a {clear:both; overflow:hidden;}
+			.continent {font-weight:bold; padding-top:1px;}
+		}
+	
+}
+
+.sub-head-events {
+	font-size:24px;
+	margin-top:20px;
+	margin-bottom:30px;
+}
+
+.margin-headline {
+	margin-top:60px !important;
+}
+
+.new-event {
+	margin-top:20px;
+	margin-bottom:60px;
+	padding-bottom:20px;
+	border-bottom:2px #e1e1e1 dotted;
+	
+	.news-date {
+    font-size: 15px;
+    color: #888;
+	}
+	.news-date:before {
+		content: "•";
+		font-size: 14px;
+		color:#ed1c24;
+		display:inline-block;
+		margin-right:5px;
+	}
+	
+	p {margin-top:15px;}
+	
+}
+.round-icon-block {
+			border-radius: 10px;
+			background:#eeeeee;
+			padding:15px;
+			display: block;
+			img {
+					margin:0px auto;
+					max-width:100px;
+					width:100px;
+					display: block;
+			}
+			p{ text-align: center; margin-top: 10px;} 
+			
+		}
+
+
+@media (max-width: $mobile) {
+       
+	.col-md-4 {margin-top:10px; margin-bottom:40px;}
+	
+	.margin-headline {margin-top:15px;}
+	
+	.meet-groups {padding-top:0px; padding-bottom:0px;
+	}
+	
+			.continent {
+			font-size:16px !important;
+		}
+	
+	
+    }
+
+@media (max-width: $tablet) {
+       
+	.col-md-4 {margin-top:10px; margin-bottom:40px;}
+	
+	.margin-headline {margin-top:15px;}
+	
+	.meet-groups {padding-top:0px; padding-bottom:0px;}
+	
+    }
+
+///////***/////////****////
+
+
+
 .syntaxhighlighter {
     padding: 10px 5px;
     border-radius: 6px;
@@ -814,10 +953,7 @@
     color: #888;
 }
 
-.news-date {
-    font-size: 15px;
-    color: #888;
-}
+
 
 section.news-section {
     a > i {
