diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
deleted file mode 100644
index c03af1a..0000000
--- a/CONTRIBUTING.md
+++ /dev/null
@@ -1,78 +0,0 @@
-# How to Contribute
-
-This guide will guide you on how to contribute to the site.
-
-This site uses [Hugo](https://gohugo.io) to organize and manage content with the following sections are available:
-
-## Homepage
-
-Located at `content/_index.html`。
-
-## Projects and Document
-
-Managed by HTML. Working on separating the text into YAML.
-
-## Event
-
-Located at `content/blog`.If you don't want to create a new blog, you need to create a new subdirectory under this directory. Here is a sample blog below.
-
-```yaml
----
-title: This is a title
-date: 2020-04-28
-author: Author
-description: This is description.
----
-
-Content
-```
-
-## Blog
-
-Located at `content/blog`.If you don't want to create a new blog, you need to create a new subdirectory under this directory. Here is a sample blog below.
-
-```yaml
----
-title: This is a title
-date: 2020-04-28
-author: Author
-description: This is description.
----
-
-Content
-```
-
-## Downloads
-
-This is a single page located at `content/downloads/_index.md`.
-
-## Team
-
-This is a single page located at `content/team/_index.md`.
-
-## 中文博客
-
-Located at `content/zh`.If you don't want to create a new blog, you need to create a new subdirectory under this directory. Here is a sample blog below.
-
-```yaml
----
-title: 博客标题
-date: 2020-04-28
-author: 作者姓名
-description: 博客摘要
----
-
-博客正文。
-```
-
-## Links
-
-Configure in the `config.toml` file. 
-
-## Website Configuration
-
-The website configuration file located at `config.toml`.
-
-## Images
-
-The images within the blogs, events and 中文博客 should keep at the same folder as the blog file, and you should reference that with the relative path.
diff --git a/README.md b/README.md
index 912531a..a60bf87 100755
--- a/README.md
+++ b/README.md
@@ -10,5 +10,83 @@
 1. Pull this repo into your local environment, and run `hugo server`  at the root folder, you can see the site preview from http://localhost:1313
 1. To generate the static website, run `hugo`
 
-See the [contribution guidelines](CONTRIBUTING.md).
+## Contributing
+
+This guide will guide you on how to contribute to the site.
+
+This site uses [Hugo](https://gohugo.io) to organize and manage content with the following sections are available:
+
+### Homepage
+
+Located at `content/_index.html`。
+
+### Projects and Document
+
+The data of documentation link is located in `data/docs.yml` and formated as `YAML`.
+
+### Event
+
+Located at `content/blog`. If you don't want to create a new blog, you need to create a new subdirectory under this directory. Here is a sample blog below.
+
+```yaml
+---
+title: This is a title
+date: 2020-04-28
+author: Author
+description: This is description.
+---
+
+Content
+```
+
+### Blog
+
+Located at `content/blog`. If you don't want to create a new blog, you need to create a new subdirectory under this directory. Here is a sample blog below.
+
+```yaml
+---
+title: This is a title
+date: 2020-04-28
+author: Author
+description: This is description.
+---
+
+Content
+```
+
+### Downloads
+
+The data of release is located in `data/releases.yml` and formated as `YAML`.
+The data of docker image is located in `data/dockerImages.yml` and formated as `YAML`.
+
+### Team
+
+This is a single page located at `content/team/_index.md`.
+
+### 中文博客
+
+Located at `content/zh`. If you don't want to create a new blog, you need to create a new subdirectory under this directory. Here is a sample blog below.
+
+```yaml
+---
+title: 博客标题
+date: 2020-04-28
+author: 作者姓名
+description: 博客摘要
+---
+
+博客正文。
+```
+
+### Links
+
+Configure in the `config.toml` file. 
+
+### Website Configuration
+
+The website configuration file located at `config.toml`.
+
+### Images
+
+The images within the blogs, events and 中文博客 should keep at the same folder as the blog file, and you should reference that with the relative path.
 
diff --git a/data/dockerImages.yml b/data/dockerImages.yml
index bbd9604..78931df 100644
--- a/data/dockerImages.yml
+++ b/data/dockerImages.yml
@@ -1,10 +1,10 @@
 - name: SkyWalking OAP Server
-  icon: D
+  icon: O
   description: This image would start up SkyWalking OAP server only.
     Note, choose *-es6 tags when use ElasticSearch 6, *-es7 tags when use ElasticSearch 7.
   link: https://hub.docker.com/r/apache/skywalking-oap-server
 
 - name: SkyWalking UI Image
-  icon: D
+  icon: U
   description: This image would start up SkyWalking UI only.
   link: https://hub.docker.com/r/apache/skywalking-ui
diff --git a/data/docs.yml b/data/docs.yml
index 598fa8d..35f0c77 100644
--- a/data/docs.yml
+++ b/data/docs.yml
@@ -18,8 +18,8 @@
       user: apache
       repo: skywalking-rocketbot-ui
 
-    - name: SkyWalking websit
-      icon: R
+    - name: SkyWalking Website
+      icon: W
       description: This is the repository including all source codes of http://skywalking.apache.org
       user: apache
       repo: skywalking-website
@@ -29,7 +29,7 @@
   description:
   list:
     - name: Nginx LUA Agent
-      icon: A
+      icon: N
       description: SkyWalking Nginx Agent provides the native tracing capability for Nginx powered by Nginx LUA module.
       user: apache
       repo: skywalking-nginx-lua
@@ -46,7 +46,7 @@
         - version: v0.4.0
           link: https://github.com/apache/skywalking-python/tree/v0.4.0
 
-    - name: Client JS
+    - name: Client JavaScript
       icon: C
       description: Apache SkyWalking Client-side JavaScript exception and tracing library.
       user: apache
@@ -78,7 +78,7 @@
           link: https://github.com/apache/skywalking-cli/tree/0.4.0
 
     - name: Kubernetes Helm
-      icon: K
+      icon: H
       description: SkyWalking Kubernetes repository provides ways to install and configure SkyWalking in a Kubernetes cluster. The scripts are written in Helm 3.
       user: apache
       repo: skywalking-kubernetes
@@ -86,9 +86,9 @@
         - version: v4.0.0
           link: https://github.com/apache/skywalking-kubernetes/tree/v4.0.0
 
-    - name: K8s Operator
+    - name: SkyWalking Cloud on Kubernetes
       icon: K
-      description: A bridge project between Apache SkyWalking and Kubernetes.
+      description: A bridge project between Apache SkyWalking and Kubernetes. 
       user: apache
       repo: skywalking-swck
       docs:
@@ -106,7 +106,7 @@
   description:
   list:
     - name: Data Collect Protocol
-      icon: D
+      icon: C
       description: Apache SkyWalking data collect protocol.
       user: apache
       repo: skywalking-data-collect-protocol
@@ -123,7 +123,7 @@
   list:
 
     - name: SkyAPM-dotnet
-      icon: S
+      icon: D
       description: SkyAPM-dotnet provides the native support agent in C# and .NETStandard platform, with the helps from Apache SkyWalking committer team.
       user: SkyAPM
       repo: SkyAPM-dotnet
@@ -141,13 +141,13 @@
       repo: go2sky-plugins
 
     - name: SkyAPM-php-sdk
-      icon: S
+      icon: P
       description: SkyAPM PHP is the PHP instrumentation agent, which is compatible with Apache SkyWalking backend and others compatible agents/SDKs.
       user: SkyAPM
       repo: SkyAPM-php-sdk
 
     - name: SkyAPM Node.js
-      icon: S
+      icon: O
       description: SkyAPM Node.js is the Node.js instrumentation agent, which is compatible with Apache SkyWalking backend and others compatible agents/SDKs.
       user: SkyAPM
       repo: SkyAPM-nodejs
diff --git a/data/releases.yml b/data/releases.yml
index a862288..4ab11c7 100644
--- a/data/releases.yml
+++ b/data/releases.yml
@@ -42,7 +42,7 @@
 
 
 - name: SkyWalking Nginx LUA
-  icon: S
+  icon: L
   description: SkyWalking Nginx Agent provides the native tracing capability for Nginx powered by Nginx LUA module.
   source:
     - version: v0.3.0
@@ -57,7 +57,7 @@
 
 
 - name: SkyWalking CLI
-  icon: S
+  icon: C
   description: SkyWalking CLI is a command interaction tool for the SkyWalking user or OPS team.
   source:
     - version: v0.4.0
@@ -82,7 +82,7 @@
 
 
 - name: SkyWalking Python
-  icon: S
+  icon: P
   description:  The Python Agent for Apache SkyWalking, which provides the native tracing abilities for Python.
   source:
     - version: v0.4.0
@@ -103,8 +103,8 @@
 
 
 
-- name: SkyWalking Chart
-  icon: S
+- name: SkyWalking Helm
+  icon: H
   description:  SkyWalking Kubernetes repository provides ways to install and configure SkyWalking in a Kubernetes cluster. The scripts are written in Helm 3.
   source:
     - version: v0.4.0
@@ -120,7 +120,7 @@
 
 
 - name: SkyWalking Cloud on Kubernetes
-  icon: S
+  icon: K
   description:  A bridge project between Apache SkyWalking and Kubernetes.
   source:
     - version: v0.1.0
@@ -145,7 +145,7 @@
 
 
 
-- name: SkyWalking Client JS
+- name: SkyWalking Client JavaScript
   icon: S
   description: Apache SkyWalking Client-side JavaScript exception and tracing library.
   source:
