diff --git a/webapp/src/main/java/org/apache/atlas/web/resources/AdminResource.java b/webapp/src/main/java/org/apache/atlas/web/resources/AdminResource.java
index 45a9bfd..c957bc8 100755
--- a/webapp/src/main/java/org/apache/atlas/web/resources/AdminResource.java
+++ b/webapp/src/main/java/org/apache/atlas/web/resources/AdminResource.java
@@ -187,6 +187,7 @@
 
                 Map<String, Object> response = new HashMap<String, Object>();
                 response.put("Version", configProperties.getString("build.version", "UNKNOWN"));
+                response.put("Revision",configProperties.getString("vc.revision", "UNKNOWN"));
                 response.put("Name", configProperties.getString("project.name", "apache-atlas"));
                 response.put("Description", configProperties.getString("project.description",
                         "Metadata Management and Data Governance Platform over Hadoop"));
diff --git a/webapp/src/main/resources/atlas-buildinfo.properties b/webapp/src/main/resources/atlas-buildinfo.properties
index f179d53..2404f8f 100755
--- a/webapp/src/main/resources/atlas-buildinfo.properties
+++ b/webapp/src/main/resources/atlas-buildinfo.properties
@@ -22,7 +22,7 @@
 build.user=${user.name}
 build.epoch=${timestamp}
 project.version=${pom.version}
-build.version=${pom.version}-r${buildNumber}
+build.version=${pom.version}
 vc.revision=${buildNumber}
 vc.source.url=${scm.connection}
 ######################
