diff --git a/configbackuprestore/pom.xml b/configbackuprestore/pom.xml
index 4501ca7..b3b532d 100644
--- a/configbackuprestore/pom.xml
+++ b/configbackuprestore/pom.xml
@@ -12,13 +12,24 @@
 	<packaging>pom</packaging>
 
 	<parent>
-		<groupId>org.springframework.boot</groupId>
-		<artifactId>spring-boot-starter-parent</artifactId>
-		<version>1.5.4.RELEASE</version>
+		<groupId>org.onap.ccsdk.parent</groupId>
+		<artifactId>spring-boot-1-starter-parent</artifactId>
+		<version>1.1.0-SNAPSHOT</version>
 	</parent>
 
 	<properties>
 		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+
+		<!-- ONAP repositories -->
+		<onap.nexus.host>nexus.onap.org</onap.nexus.host>
+		<onap.nexus.port>443</onap.nexus.port>
+		<onap.nexus.protocol>https</onap.nexus.protocol>
+		<onap.nexus.public-url>https://nexus.onap.org/content/groups/public</onap.nexus.public-url>
+		<onap.nexus.staging-url>https://nexus.onap.org/content/groups/staging</onap.nexus.staging-url>
+		<onap.nexus.release-url>https://nexus.onap.org/content/repositories/releases</onap.nexus.release-url>
+		<onap.nexus.snapshot-url>https://nexus.onap.org/content/repositories/snapshots</onap.nexus.snapshot-url>
+		<onap.nexus.staging.server-id>ecomp-staging</onap.nexus.staging.server-id>
+		<onap.nexus.staging.profile-id>176c31dfe190a</onap.nexus.staging.profile-id>
 	</properties>
 
 	<dependencies>
