diff --git a/GSoC2011GUIOverhaul.wiki b/GSoC2011GUIOverhaul.wiki
index d66dae5..9e844e4 100644
--- a/GSoC2011GUIOverhaul.wiki
+++ b/GSoC2011GUIOverhaul.wiki
@@ -24,6 +24,8 @@
 
 = Iconic Dashboard Architecture =
 
+<table style="width:auto;"><tr><td><a href="https://picasaweb.google.com/lh/photo/QpZPJ_wyF4mDyzNWUHjkmw?feat=embedwebsite"><img src="https://lh3.googleusercontent.com/-tqvtiL64f74/Tm4-WWvrIVI/AAAAAAAAAxw/satfYm3AwTk/s144/Admin%252520dashboard_1315847658617.png" height="116" width="144" /></a></td></tr><tr><td style="font-family:arial,sans-serif; font-size:11px; text-align:right">From <a href="https://picasaweb.google.com/gedex.adc/MelangeIconicDashboard?authuser=0&feat=embedwebsite">Melange Iconic Dashboard</a></td></tr></table>
+
 Iconic dashboard basically is a chunk of template, or a Django view that will be rendered as a partial HTML. Specifically, the view will be rendered as a collection of links that either nested (link to another block/div in the same page) or linked to another page. Iconic dashboard consists of:
  * Django view (app/soc/views/dashboard.py). Classes in this view are not supposed to be instantiated directly, where each class acts as a base class. To implement iconic dashboard at least one derived class must be created.
  * Djano template (app/soc/templates/v2/soc/dashboard/*)
@@ -50,10 +52,10 @@
 Given use cases of GSoC program below on how to alter the dashboard will give you an understanding how the dashboard works.
 
 == Iconic Dashboard Use Case in Admin Dashboard (GSoC) ==
-
+<table style="width:auto;"><tr><td><a href="https://picasaweb.google.com/lh/photo/QpZPJ_wyF4mDyzNWUHjkmw?feat=embedwebsite"><img src="https://lh3.googleusercontent.com/-tqvtiL64f74/Tm4-WWvrIVI/AAAAAAAAAxw/satfYm3AwTk/s144/Admin%252520dashboard_1315847658617.png" height="116" width="144" /></a></td></tr><tr><td style="font-family:arial,sans-serif; font-size:11px; text-align:right">From <a href="https://picasaweb.google.com/gedex.adc/MelangeIconicDashboard?authuser=0&feat=embedwebsite">Melange Iconic Dashboard</a></td></tr></table>
 
 == Iconic Dashboard Use Case in Participant Dashboard (GSoC) ==
-
+<table style="width:auto;"><tr><td><a href="https://picasaweb.google.com/lh/photo/aq21LY58oBi0C4ndEovTFw?feat=embedwebsite"><img src="https://lh5.googleusercontent.com/-dFdhS-rpt7o/Tm4-iKLa3rI/AAAAAAAAAx0/EP2rwIReBKs/s144/Google%252520Summer%252520of%252520Code%2525202009_1315847795686.png" height="93" width="144" /></a></td></tr><tr><td style="font-family:arial,sans-serif; font-size:11px; text-align:right">From <a href="https://picasaweb.google.com/gedex.adc/MelangeIconicDashboard?authuser=0&feat=embedwebsite">Melange Iconic Dashboard</a></td></tr></table>
 ----
 
 = Meetings and Agendas =
