diff --git a/ipojo/examples/tutorial-maven/pom.xml b/ipojo/examples/tutorial-maven/pom.xml
index 99d12ac..8266daf 100644
--- a/ipojo/examples/tutorial-maven/pom.xml
+++ b/ipojo/examples/tutorial-maven/pom.xml
@@ -1,12 +1,26 @@
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements.  See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership.  The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied.  See the License for the
+ specific language governing permissions and limitations
+ under the License.
+-->
 <project>
-  <parent>
-    <groupId>ipojo.examples</groupId>
-  	<artifactId>ipojo.examples</artifactId>
-  	<version>0.7.6-SNAPSHOT</version>
-    <relativePath>../pom.xml</relativePath>
-  </parent>
   <modelVersion>4.0.0</modelVersion>
   <artifactId>ipojo.tutorial</artifactId>
+  <groupId>ipojo.examples</groupId>
+  <version>0.7.6-SNAPSHOT</version>
   <name>Apache Felix iPOJO Tutorial</name>
   <packaging>pom</packaging>
   <modules>
