diff --git a/component-support/pom.xml b/component-support/pom.xml
index a365bba..2e91f8f 100644
--- a/component-support/pom.xml
+++ b/component-support/pom.xml
@@ -51,7 +51,7 @@
         <dependency>
             <groupId>org.apache.myfaces.extensions.validator</groupId>
             <artifactId>myfaces-extval-core</artifactId>
-            <version>${build.version}</version>
+            <version>1.2.1-SNAPSHOT</version>
             <scope>compile</scope>
         </dependency>
     </dependencies>
diff --git a/validation-modules/pom.xml b/validation-modules/pom.xml
index eda9ab4..a59e1d0 100644
--- a/validation-modules/pom.xml
+++ b/validation-modules/pom.xml
@@ -51,7 +51,7 @@
         <dependency>
             <groupId>org.apache.myfaces.extensions.validator</groupId>
             <artifactId>myfaces-extval-core</artifactId>
-            <version>${build.version}</version>
+            <version>1.2.1-SNAPSHOT</version>
             <scope>compile</scope>
         </dependency>
     </dependencies>
