diff --git a/adapters/mso-tenant-adapter/pom.xml b/adapters/mso-tenant-adapter/pom.xml
index 58ca7b1..1479b28 100644
--- a/adapters/mso-tenant-adapter/pom.xml
+++ b/adapters/mso-tenant-adapter/pom.xml
@@ -4,7 +4,7 @@
 	<parent>
 		<groupId>org.openecomp.so</groupId>
 		<artifactId>adapters</artifactId>
-		<version>1.1.1-SNAPSHOT</version>
+		<version>1.2.0-SNAPSHOT</version>
 	</parent>
 	<groupId>org.openecomp.so.adapters</groupId>
 	<artifactId>mso-tenant-adapter</artifactId>
