diff --git a/maven-release-api/pom.xml b/maven-release-api/pom.xml
index e96feff..03985e6 100644
--- a/maven-release-api/pom.xml
+++ b/maven-release-api/pom.xml
@@ -41,6 +41,18 @@
       <artifactId>maven-artifact</artifactId>
     </dependency>
     <dependency>
+      <groupId>org.apache.maven</groupId>
+      <artifactId>maven-core</artifactId>
+    </dependency>
+    <dependency>
+      <groupId>org.apache.maven</groupId>
+      <artifactId>maven-model</artifactId>
+    </dependency>
+    <dependency>
+      <groupId>org.apache.maven</groupId>
+      <artifactId>maven-settings</artifactId>
+    </dependency>
+    <dependency>
       <groupId>org.eclipse.aether</groupId>
       <artifactId>aether-util</artifactId>
       <version>1.0.0.v20140518</version>
diff --git a/maven-release-manager/src/main/java/org/apache/maven/shared/release/ReleaseExecutionException.java b/maven-release-api/src/main/java/org/apache/maven/shared/release/ReleaseExecutionException.java
similarity index 100%
rename from maven-release-manager/src/main/java/org/apache/maven/shared/release/ReleaseExecutionException.java
rename to maven-release-api/src/main/java/org/apache/maven/shared/release/ReleaseExecutionException.java
diff --git a/maven-release-manager/src/main/java/org/apache/maven/shared/release/ReleaseFailureException.java b/maven-release-api/src/main/java/org/apache/maven/shared/release/ReleaseFailureException.java
similarity index 100%
rename from maven-release-manager/src/main/java/org/apache/maven/shared/release/ReleaseFailureException.java
rename to maven-release-api/src/main/java/org/apache/maven/shared/release/ReleaseFailureException.java
diff --git a/maven-release-manager/src/main/java/org/apache/maven/shared/release/ReleaseResult.java b/maven-release-api/src/main/java/org/apache/maven/shared/release/ReleaseResult.java
similarity index 96%
rename from maven-release-manager/src/main/java/org/apache/maven/shared/release/ReleaseResult.java
rename to maven-release-api/src/main/java/org/apache/maven/shared/release/ReleaseResult.java
index 088e820..04547ed 100644
--- a/maven-release-manager/src/main/java/org/apache/maven/shared/release/ReleaseResult.java
+++ b/maven-release-api/src/main/java/org/apache/maven/shared/release/ReleaseResult.java
@@ -132,10 +132,4 @@
 
         return byteStream.toString();
     }
-
-    @Deprecated
-    public StringBuffer getOutputBuffer()
-    {
-        return new StringBuffer( stdOut );
-    }
 }
diff --git a/maven-release-api/src/main/java/org/apache/maven/shared/release/config/ReleaseDescriptor.java b/maven-release-api/src/main/java/org/apache/maven/shared/release/config/ReleaseDescriptor.java
new file mode 100644
index 0000000..d9aa16a
--- /dev/null
+++ b/maven-release-api/src/main/java/org/apache/maven/shared/release/config/ReleaseDescriptor.java
@@ -0,0 +1,158 @@
+package org.apache.maven.shared.release.config;
+
+/*
+ * 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.
+ */
+
+import java.util.List;
+
+import org.apache.maven.model.Scm;
+
+/**
+ * 
+ * @author Robert Scholte
+ */
+public interface ReleaseDescriptor
+{
+    boolean isUpdateDependencies();
+
+    boolean isUseReleaseProfile();
+
+    boolean isAutoVersionSubmodules();
+
+    boolean isSnapshotReleasePluginAllowed();
+
+    boolean isCommitByProject();
+
+    boolean isBranchCreation();
+
+    boolean isUpdateBranchVersions();
+
+    boolean isUpdateWorkingCopyVersions();
+
+    boolean isSuppressCommitBeforeTagOrBranch();
+
+    boolean isAllowTimestampedSnapshots();
+
+    boolean isUpdateVersionsToSnapshot();
+
+    boolean isRemoteTagging();
+
+    boolean isLocalCheckout();
+
+    boolean isPushChanges();
+
+    String getDefaultDevelopmentVersion();
+
+    String getScmRelativePathProjectDirectory();
+
+    String getCheckoutDirectory();
+
+    String getPerformGoals();
+
+    String getDefaultReleaseVersion();
+
+    String getScmReleasedPomRevision();
+
+    boolean isAddSchema();
+
+    boolean isGenerateReleasePoms();
+
+    boolean isInteractive();
+
+    boolean isScmUseEditMode();
+
+    String getCompletedPhase();
+
+    List<String> getCheckModificationExcludes();
+
+    String getAdditionalArguments();
+
+    String getPreparationGoals();
+
+    String getCompletionGoals();
+
+    String getPomFileName();
+
+    String getScmCommentPrefix();
+
+    String getScmPrivateKeyPassPhrase();
+
+    String getScmPassword();
+
+    String getScmPrivateKey();
+
+    String getScmReleaseLabel();
+
+    String getScmTagBase();
+
+    String getScmBranchBase();
+
+    String getScmId();
+
+    String getScmSourceUrl();
+
+    String getScmUsername();
+
+    int getWaitBeforeTagging();
+
+    String getWorkingDirectory();
+
+    String getScmTagNameFormat();
+
+    String getProjectNamingPolicyId();
+
+    String getProjectVersionPolicyId(); 
+
+    String getReleaseStrategyId();
+
+    String getDependencyOriginalVersion( String artifactKey );
+    
+    String getDependencyReleaseVersion( String artifactKey ); 
+    
+    String getDependencyDevelopmentVersion( String artifactKey ); 
+
+    String getProjectOriginalVersion( String projectKey );
+
+    String getProjectDevelopmentVersion( String projectKey );
+
+    String getProjectReleaseVersion( String key );
+
+    Scm getOriginalScmInfo( String projectKey );
+
+    // Modifiable
+    void addDependencyOriginalVersion( String versionlessKey, String string );
+
+    void addDependencyReleaseVersion( String versionlessKey, String version ); 
+    
+    void addDependencyDevelopmentVersion( String versionlessKey, String version );
+
+    void addReleaseVersion( String projectId, String nextVersion );
+
+    void addDevelopmentVersion( String projectId, String nextVersion );
+
+    void setScmReleaseLabel( String tag );
+
+    void setScmReleasedPomRevision( String scmRevision );
+
+    void setScmRelativePathProjectDirectory( String scmRelativePathProjectDirectory );
+
+    void setScmSourceUrl( String scmUrl );
+
+
+}
diff --git a/maven-release-manager/src/main/java/org/apache/maven/shared/release/env/ReleaseEnvironment.java b/maven-release-api/src/main/java/org/apache/maven/shared/release/env/ReleaseEnvironment.java
similarity index 73%
rename from maven-release-manager/src/main/java/org/apache/maven/shared/release/env/ReleaseEnvironment.java
rename to maven-release-api/src/main/java/org/apache/maven/shared/release/env/ReleaseEnvironment.java
index dbbf86c..88ef9e2 100644
--- a/maven-release-manager/src/main/java/org/apache/maven/shared/release/env/ReleaseEnvironment.java
+++ b/maven-release-api/src/main/java/org/apache/maven/shared/release/env/ReleaseEnvironment.java
@@ -34,36 +34,18 @@
 
     String getMavenExecutorId();
 
-    ReleaseEnvironment setMavenExecutorId( String mavenExecutorId );
-
     File getLocalRepositoryDirectory();
 
-    ReleaseEnvironment setLocalRepositoryDirectory( File localRepositoryDirectory );
-
     Settings getSettings();
 
-    ReleaseEnvironment setSettings( Settings settings );
-
     File getMavenHome();
 
-    ReleaseEnvironment setMavenHome( File mavenHome );
-
     File getJavaHome();
 
-    ReleaseEnvironment setJavaHome( File javaHome );
-
     /**
      *
      * @return the locale
      * @since 2.4
      */
     Locale getLocale();
-
-    /**
-     * @param locale
-     * @return the locale
-     * @since 2.4
-     */
-    ReleaseEnvironment setLocale( Locale locale );
-
 }
diff --git a/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/ReleasePhase.java b/maven-release-api/src/main/java/org/apache/maven/shared/release/phase/ReleasePhase.java
similarity index 100%
rename from maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/ReleasePhase.java
rename to maven-release-api/src/main/java/org/apache/maven/shared/release/phase/ReleasePhase.java
diff --git a/maven-release-manager/src/main/java/org/apache/maven/shared/release/AbstractReleaseRequest.java b/maven-release-manager/src/main/java/org/apache/maven/shared/release/AbstractReleaseRequest.java
index 8e7070e..470c6c2 100644
--- a/maven-release-manager/src/main/java/org/apache/maven/shared/release/AbstractReleaseRequest.java
+++ b/maven-release-manager/src/main/java/org/apache/maven/shared/release/AbstractReleaseRequest.java
@@ -22,7 +22,7 @@
 import java.util.List;
 
 import org.apache.maven.project.MavenProject;
-import org.apache.maven.shared.release.config.ReleaseDescriptor;
+import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder;
 
 /**
  *
@@ -31,7 +31,7 @@
  */
 public abstract class AbstractReleaseRequest
 {
-    private ReleaseDescriptor releaseDescriptor;
+    private ReleaseDescriptorBuilder releaseDescriptorBuilder;
 
     private List<MavenProject> reactorProjects;
 
@@ -40,17 +40,17 @@
     /**
      * @return the releaseDescriptor
      */
-    public ReleaseDescriptor getReleaseDescriptor()
+    public ReleaseDescriptorBuilder getReleaseDescriptorBuilder()
     {
-        return releaseDescriptor;
+        return releaseDescriptorBuilder;
     }
 
     /**
      * @param releaseDescriptor the releaseDescriptor to set
      */
-    public void setReleaseDescriptor( ReleaseDescriptor releaseDescriptor )
+    public void setReleaseDescriptorBuilder( ReleaseDescriptorBuilder releaseDescriptor )
     {
-        this.releaseDescriptor = releaseDescriptor;
+        this.releaseDescriptorBuilder = releaseDescriptor;
     }
 
     /**
diff --git a/maven-release-manager/src/main/java/org/apache/maven/shared/release/DefaultReleaseManager.java b/maven-release-manager/src/main/java/org/apache/maven/shared/release/DefaultReleaseManager.java
index ad93daa..1cbcb89 100644
--- a/maven-release-manager/src/main/java/org/apache/maven/shared/release/DefaultReleaseManager.java
+++ b/maven-release-manager/src/main/java/org/apache/maven/shared/release/DefaultReleaseManager.java
@@ -28,8 +28,11 @@
 
 import org.apache.commons.lang3.BooleanUtils;
 import org.apache.maven.shared.release.config.ReleaseDescriptor;
+import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder;
+import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder.BuilderReleaseDescriptor;
 import org.apache.maven.shared.release.config.ReleaseDescriptorStore;
 import org.apache.maven.shared.release.config.ReleaseDescriptorStoreException;
+import org.apache.maven.shared.release.config.ReleaseUtils;
 import org.apache.maven.shared.release.phase.ReleasePhase;
 import org.apache.maven.shared.release.strategy.Strategy;
 import org.codehaus.plexus.component.annotations.Component;
@@ -99,15 +102,36 @@
     private void prepare( ReleasePrepareRequest prepareRequest, ReleaseResult result )
         throws ReleaseExecutionException, ReleaseFailureException
     {
-        ReleaseDescriptor config;
+
+        final ReleaseDescriptorBuilder builder = prepareRequest.getReleaseDescriptorBuilder();
+
+        // Create a config containing values from the session properties (ie command line properties with cli).
+        ReleaseUtils.copyPropertiesToReleaseDescriptor( prepareRequest.getUserProperties(),
+                                        new ReleaseDescriptorBuilder()
+                                        {
+                                            public ReleaseDescriptorBuilder addDevelopmentVersion( String key,
+                                                                                                   String value )
+                                            {
+                                                builder.addDevelopmentVersion( key, value );
+                                                return this;
+                                            }
+
+                                            public ReleaseDescriptorBuilder addReleaseVersion( String key,
+                                                                                               String value )
+                                            {
+                                                builder.addReleaseVersion( key, value );
+                                                return this;
+                                            };
+                                        } );
+
+        BuilderReleaseDescriptor config;
         if ( BooleanUtils.isNotFalse( prepareRequest.getResume() ) )
         {
-            config = loadReleaseDescriptor( prepareRequest.getReleaseDescriptor(),
-                                            prepareRequest.getReleaseManagerListener() );
+            config = loadReleaseDescriptor( builder, prepareRequest.getReleaseManagerListener() );
         }
         else
         {
-            config = prepareRequest.getReleaseDescriptor();
+            config = ReleaseUtils.buildReleaseDescriptor( prepareRequest.getReleaseDescriptorBuilder() );
         }
 
         Strategy releaseStrategy = getStrategy( config.getReleaseStrategyId() );
@@ -196,7 +220,8 @@
     public void rollback( ReleaseRollbackRequest rollbackRequest )
         throws ReleaseExecutionException, ReleaseFailureException
     {
-        ReleaseDescriptor releaseDescriptor = loadReleaseDescriptor( rollbackRequest.getReleaseDescriptor(), null );
+        ReleaseDescriptor releaseDescriptor =
+            loadReleaseDescriptor( rollbackRequest.getReleaseDescriptorBuilder(), null );
 
         Strategy releaseStrategy = getStrategy( releaseDescriptor.getReleaseStrategyId() );
 
@@ -260,8 +285,9 @@
     private void perform( ReleasePerformRequest performRequest, ReleaseResult result )
         throws ReleaseExecutionException, ReleaseFailureException
     {
-        ReleaseDescriptor releaseDescriptor = loadReleaseDescriptor( performRequest.getReleaseDescriptor(),
-                                                                     performRequest.getReleaseManagerListener() );
+        ReleaseDescriptor releaseDescriptor =
+            loadReleaseDescriptor( performRequest.getReleaseDescriptorBuilder(),
+                                   performRequest.getReleaseManagerListener() );
 
         Strategy releaseStrategy = getStrategy( releaseDescriptor.getReleaseStrategyId() );
 
@@ -320,8 +346,28 @@
     public void branch( ReleaseBranchRequest branchRequest )
         throws ReleaseExecutionException, ReleaseFailureException
     {
-        ReleaseDescriptor releaseDescriptor = loadReleaseDescriptor( branchRequest.getReleaseDescriptor(),
-                                                                     branchRequest.getReleaseManagerListener() );
+        final ReleaseDescriptorBuilder builder = branchRequest.getReleaseDescriptorBuilder();
+        
+        ReleaseUtils.copyPropertiesToReleaseDescriptor( branchRequest.getUserProperties(),
+                    new ReleaseDescriptorBuilder()
+                    {
+                        public ReleaseDescriptorBuilder addDevelopmentVersion( String key,
+                                                                               String value )
+                        {
+                            builder.addDevelopmentVersion( key, value );
+                            return this;
+                        }
+
+                        public ReleaseDescriptorBuilder addReleaseVersion( String key,
+                                                                           String value )
+                        {
+                            builder.addReleaseVersion( key, value );
+                            return this;
+                        };
+                    } );
+        
+        ReleaseDescriptor releaseDescriptor =
+            loadReleaseDescriptor( builder, branchRequest.getReleaseManagerListener() );
 
         boolean dryRun = BooleanUtils.isTrue( branchRequest.getDryRun() );
 
@@ -369,8 +415,29 @@
     public void updateVersions( ReleaseUpdateVersionsRequest updateVersionsRequest )
         throws ReleaseExecutionException, ReleaseFailureException
     {
-        ReleaseDescriptor releaseDescriptor = loadReleaseDescriptor( updateVersionsRequest.getReleaseDescriptor(),
-                                                                   updateVersionsRequest.getReleaseManagerListener() );
+        final ReleaseDescriptorBuilder builder = updateVersionsRequest.getReleaseDescriptorBuilder();
+        
+        // Create a config containing values from the session properties (ie command line properties with cli).
+        ReleaseUtils.copyPropertiesToReleaseDescriptor( updateVersionsRequest.getUserProperties(),
+                                    new ReleaseDescriptorBuilder()
+                                    {
+                                        public ReleaseDescriptorBuilder addDevelopmentVersion( String key,
+                                                                                               String value )
+                                        {
+                                            builder.addDevelopmentVersion( key, value );
+                                            return this;
+                                        }
+
+                                        public ReleaseDescriptorBuilder addReleaseVersion( String key,
+                                                                                           String value )
+                                        {
+                                            builder.addReleaseVersion( key, value );
+                                            return this;
+                                        };
+                                    } );
+
+        ReleaseDescriptor releaseDescriptor =
+            loadReleaseDescriptor( builder, updateVersionsRequest.getReleaseManagerListener() );
 
         Strategy releaseStrategy = getStrategy( releaseDescriptor.getReleaseStrategyId() );
 
@@ -421,14 +488,14 @@
         }
     }
 
-    private ReleaseDescriptor loadReleaseDescriptor( ReleaseDescriptor releaseDescriptor,
+    private BuilderReleaseDescriptor loadReleaseDescriptor( ReleaseDescriptorBuilder builder,
                                                      ReleaseManagerListener listener )
         throws ReleaseExecutionException
     {
         try
         {
             updateListener( listener, "verify-release-configuration", PHASE_START );
-            ReleaseDescriptor descriptor = configStore.read( releaseDescriptor );
+            BuilderReleaseDescriptor descriptor = ReleaseUtils.buildReleaseDescriptor( configStore.read( builder ) );
             updateListener( listener, "verify-release-configuration", PHASE_END );
             return descriptor;
         }
@@ -444,7 +511,7 @@
     protected void clean( AbstractReleaseRequest releaseRequest  ) throws ReleaseFailureException
     {
         ReleaseCleanRequest cleanRequest = new ReleaseCleanRequest();
-        cleanRequest.setReleaseDescriptor( releaseRequest.getReleaseDescriptor() );
+        cleanRequest.setReleaseDescriptorBuilder( releaseRequest.getReleaseDescriptorBuilder() );
         cleanRequest.setReleaseManagerListener( releaseRequest.getReleaseManagerListener() );
         cleanRequest.setReactorProjects( releaseRequest.getReactorProjects() );
 
@@ -458,7 +525,8 @@
 
         getLogger().info( "Cleaning up after release..." );
 
-        ReleaseDescriptor releaseDescriptor = cleanRequest.getReleaseDescriptor();
+        ReleaseDescriptor releaseDescriptor =
+            ReleaseUtils.buildReleaseDescriptor( cleanRequest.getReleaseDescriptorBuilder() );
 
         configStore.delete( releaseDescriptor );
 
diff --git a/maven-release-manager/src/main/java/org/apache/maven/shared/release/ReleaseBranchRequest.java b/maven-release-manager/src/main/java/org/apache/maven/shared/release/ReleaseBranchRequest.java
index 9900a17..45b69c8 100644
--- a/maven-release-manager/src/main/java/org/apache/maven/shared/release/ReleaseBranchRequest.java
+++ b/maven-release-manager/src/main/java/org/apache/maven/shared/release/ReleaseBranchRequest.java
@@ -19,6 +19,7 @@
  * under the License.
  */
 
+import java.util.Properties;
 import org.apache.maven.shared.release.env.ReleaseEnvironment;
 
 /**
@@ -32,6 +33,8 @@
     private Boolean dryRun;
 
     private ReleaseEnvironment releaseEnvironment;
+    
+    private Properties userProperties;
 
     /**
      * @return the dryRun
@@ -64,4 +67,14 @@
     {
         this.releaseEnvironment = releaseEnvironment;
     }
+    
+    public Properties getUserProperties()
+    {
+        return userProperties;
+    }
+    
+    public void setUserProperties( Properties userProperties )
+    {
+        this.userProperties = userProperties;
+    }
 }
\ No newline at end of file
diff --git a/maven-release-manager/src/main/java/org/apache/maven/shared/release/ReleasePrepareRequest.java b/maven-release-manager/src/main/java/org/apache/maven/shared/release/ReleasePrepareRequest.java
index 1ab4a2b..7ac6915 100644
--- a/maven-release-manager/src/main/java/org/apache/maven/shared/release/ReleasePrepareRequest.java
+++ b/maven-release-manager/src/main/java/org/apache/maven/shared/release/ReleasePrepareRequest.java
@@ -19,6 +19,8 @@
  * under the License.
  */
 
+import java.util.Properties;
+
 import org.apache.maven.shared.release.env.ReleaseEnvironment;
 
 /**
@@ -36,6 +38,8 @@
     private Boolean resume;
 
     private ReleaseEnvironment releaseEnvironment;
+    
+    private Properties userProperties;
 
     /**
      * @return the dryRun
@@ -84,4 +88,14 @@
     {
         this.releaseEnvironment = releaseEnvironment;
     }
+    
+    public Properties getUserProperties()
+    {
+        return userProperties;
+    }
+    
+    public void setUserProperties( Properties userProperties )
+    {
+        this.userProperties = userProperties;
+    }
 }
\ No newline at end of file
diff --git a/maven-release-manager/src/main/java/org/apache/maven/shared/release/ReleaseUpdateVersionsRequest.java b/maven-release-manager/src/main/java/org/apache/maven/shared/release/ReleaseUpdateVersionsRequest.java
index ba87ad0..81c768c 100644
--- a/maven-release-manager/src/main/java/org/apache/maven/shared/release/ReleaseUpdateVersionsRequest.java
+++ b/maven-release-manager/src/main/java/org/apache/maven/shared/release/ReleaseUpdateVersionsRequest.java
@@ -19,6 +19,8 @@
  * under the License.
  */
 
+import java.util.Properties;
+
 import org.apache.maven.shared.release.env.ReleaseEnvironment;
 
 /**
@@ -30,6 +32,8 @@
     extends AbstractReleaseRequest
 {
     private ReleaseEnvironment releaseEnvironment;
+    
+    private Properties userProperties;
 
     /**
      * @return the releaseEnvironment
@@ -46,4 +50,14 @@
     {
         this.releaseEnvironment = releaseEnvironment;
     }
+    
+    public Properties getUserProperties()
+    {
+        return userProperties;
+    }
+    
+    public void setUserProperties( Properties userProperties )
+    {
+        this.userProperties = userProperties;
+    }
 }
\ No newline at end of file
diff --git a/maven-release-manager/src/main/java/org/apache/maven/shared/release/config/PropertiesReleaseDescriptorStore.java b/maven-release-manager/src/main/java/org/apache/maven/shared/release/config/PropertiesReleaseDescriptorStore.java
index 7256ce3..259d9a3 100644
--- a/maven-release-manager/src/main/java/org/apache/maven/shared/release/config/PropertiesReleaseDescriptorStore.java
+++ b/maven-release-manager/src/main/java/org/apache/maven/shared/release/config/PropertiesReleaseDescriptorStore.java
@@ -30,6 +30,7 @@
 import java.util.Properties;
 
 import org.apache.maven.model.Scm;
+import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder.BuilderReleaseDescriptor;
 import org.apache.maven.shared.release.scm.IdentifiedScm;
 import org.codehaus.plexus.component.annotations.Component;
 import org.codehaus.plexus.component.annotations.Requirement;
@@ -61,19 +62,19 @@
     private DefaultSecDispatcher secDispatcher;
 
     @Override
-    public ReleaseDescriptor read( ReleaseDescriptor mergeDescriptor )
+    public ReleaseDescriptorBuilder read( ReleaseDescriptorBuilder mergeDescriptor )
         throws ReleaseDescriptorStoreException
     {
-        return read( mergeDescriptor, getDefaultReleasePropertiesFile( mergeDescriptor ) );
+        return read( mergeDescriptor, getDefaultReleasePropertiesFile( mergeDescriptor.build() ) );
     }
 
-    public ReleaseDescriptor read( File file )
+    public ReleaseDescriptorBuilder read( File file )
         throws ReleaseDescriptorStoreException
     {
         return read( null, file );
     }
 
-    public ReleaseDescriptor read( ReleaseDescriptor mergeDescriptor, File file )
+    public ReleaseDescriptorBuilder read( ReleaseDescriptorBuilder mergeDescriptor, File file )
         throws ReleaseDescriptorStoreException
     {
         Properties properties = new Properties();
@@ -92,21 +93,26 @@
                 "Error reading properties file '" + file.getName() + "': " + e.getMessage(), e );
         }
 
-        ReleaseDescriptor releaseDescriptor = ReleaseUtils.copyPropertiesToReleaseDescriptor( properties );
-
+        ReleaseDescriptorBuilder builder;
         if ( mergeDescriptor != null )
         {
-            releaseDescriptor = ReleaseUtils.merge( releaseDescriptor, mergeDescriptor );
+            builder = mergeDescriptor;
         }
+        else
+        {
+           builder = new ReleaseDescriptorBuilder(); 
+        }
+        
+        ReleaseUtils.copyPropertiesToReleaseDescriptor( properties, builder );
 
-        return releaseDescriptor;
+        return builder;
     }
 
     @Override
     public void write( ReleaseDescriptor config )
         throws ReleaseDescriptorStoreException
     {
-        write( config, getDefaultReleasePropertiesFile( config ) );
+        write( (BuilderReleaseDescriptor) config, getDefaultReleasePropertiesFile( config ) );
     }
 
     @Override
@@ -119,7 +125,7 @@
         }
     }
 
-    public void write( ReleaseDescriptor config, File file )
+    public void write( BuilderReleaseDescriptor config, File file )
         throws ReleaseDescriptorStoreException
     {
         Properties properties = new Properties();
@@ -226,14 +232,17 @@
         // others boolean properties are not written to the properties file because the value from the caller is always
         // used
 
-        for ( Map.Entry<String, String> entry : config.getReleaseVersions().entrySet() )
+        
+        for ( Map.Entry<String, ReleaseStageVersions> entry : config.getProjectVersions().entrySet() )
         {
-            properties.setProperty( "project.rel." + entry.getKey(), entry.getValue() );
-        }
-
-        for ( Map.Entry<String, String> entry : config.getDevelopmentVersions().entrySet() )
-        {
-            properties.setProperty( "project.dev." + entry.getKey(), (String) entry.getValue() );
+            if ( entry.getValue().getRelease() != null )
+            {
+                properties.setProperty( "project.rel." + entry.getKey(), entry.getValue().getRelease() );
+            }
+            if ( entry.getValue().getDevelopment() != null )
+            {
+                properties.setProperty( "project.dev." + entry.getKey(), entry.getValue().getDevelopment() );
+            }
         }
 
         for ( Map.Entry<String, Scm> entry : config.getOriginalScmInfo().entrySet() )
@@ -290,16 +299,16 @@
         }
     }
 
-    private void processResolvedDependencies( Properties prop, Map<String, Map<String, String>> resolvedDependencies )
+    private void processResolvedDependencies( Properties prop, Map<String, ReleaseStageVersions> resolvedDependencies )
     {
-        for ( Map.Entry<String, Map<String, String>> currentEntry : resolvedDependencies.entrySet() )
+        for ( Map.Entry<String, ReleaseStageVersions> currentEntry : resolvedDependencies.entrySet() )
         {
-            Map<String, String> versionMap = currentEntry.getValue();
+            ReleaseStageVersions versionMap = currentEntry.getValue();
             
             prop.setProperty( "dependency." + currentEntry.getKey() + ".release",
-                              versionMap.get( ReleaseDescriptor.RELEASE_KEY ) );
+                              versionMap.getRelease() );
             prop.setProperty( "dependency." + currentEntry.getKey() + ".development",
-                              versionMap.get( ReleaseDescriptor.DEVELOPMENT_KEY ) );
+                              versionMap.getDevelopment() );
         }
     }
 
diff --git a/maven-release-manager/src/main/java/org/apache/maven/shared/release/config/ReleaseDescriptorBuilder.java b/maven-release-manager/src/main/java/org/apache/maven/shared/release/config/ReleaseDescriptorBuilder.java
new file mode 100644
index 0000000..c2ed277
--- /dev/null
+++ b/maven-release-manager/src/main/java/org/apache/maven/shared/release/config/ReleaseDescriptorBuilder.java
@@ -0,0 +1,399 @@
+package org.apache.maven.shared.release.config;
+
+/*
+ * 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.
+ */
+
+import java.util.List;
+
+import org.apache.maven.model.Scm;
+
+/**
+ * 
+ * @author Robert Scholte
+ * @since 3.0.0
+ */
+public class ReleaseDescriptorBuilder
+{
+    /**
+     * Hides inner logic of the release descriptor
+     * 
+     * @author Robert Scholte
+     *
+     */
+    public static final class BuilderReleaseDescriptor extends ModelloReleaseDescriptor implements ReleaseDescriptor
+    {
+        private BuilderReleaseDescriptor()
+        {
+        }
+    }
+    
+    private final BuilderReleaseDescriptor releaseDescriptor;
+    
+    public ReleaseDescriptorBuilder()
+    {
+        this.releaseDescriptor = new BuilderReleaseDescriptor();
+    }
+
+    public ReleaseDescriptorBuilder addCheckModificationExclude( String string )
+    {
+        releaseDescriptor.addCheckModificationExclude( string );
+        return this;
+    }
+
+    public ReleaseDescriptorBuilder setAddSchema( boolean addSchema )
+    {
+        releaseDescriptor.setAddSchema( addSchema );
+        return this;
+    }
+
+    public ReleaseDescriptorBuilder setAdditionalArguments( String additionalArguments )
+    {
+        releaseDescriptor.setAdditionalArguments( additionalArguments );
+        return this;
+    }
+
+    public ReleaseDescriptorBuilder setAllowTimestampedSnapshots( boolean allowTimestampedSnapshots )
+    {
+        releaseDescriptor.setAllowTimestampedSnapshots( allowTimestampedSnapshots );
+        return this;
+    }
+
+    public ReleaseDescriptorBuilder setAutoVersionSubmodules( boolean autoVersionSubmodules )
+    {
+        releaseDescriptor.setAutoVersionSubmodules( autoVersionSubmodules );
+        return this;
+    }
+
+    public ReleaseDescriptorBuilder setBranchCreation( boolean branchCreation )
+    {
+        releaseDescriptor.setBranchCreation( branchCreation );
+        return this;
+    }
+
+    public ReleaseDescriptorBuilder setCheckModificationExcludes( List<String> checkModificationExcludes )
+    {
+        releaseDescriptor.setCheckModificationExcludes( checkModificationExcludes );
+        return this;
+    }
+
+    public ReleaseDescriptorBuilder setCheckoutDirectory( String checkoutDirectory )
+    {
+        releaseDescriptor.setCheckoutDirectory( checkoutDirectory );
+        return this;
+    }
+
+    public ReleaseDescriptorBuilder setCommitByProject( boolean commitByProject )
+    {
+        releaseDescriptor.setCommitByProject( commitByProject );
+        return this;
+    }
+
+    public ReleaseDescriptorBuilder setCompletedPhase( String completedPhase )
+    {
+        releaseDescriptor.setCompletedPhase( completedPhase );
+        return this;
+    }
+
+    public ReleaseDescriptorBuilder setCompletionGoals( String completionGoals )
+    {
+        releaseDescriptor.setCompletionGoals( completionGoals );
+        return this;
+    }
+
+    public ReleaseDescriptorBuilder setDefaultDevelopmentVersion( String defaultDevelopmentVersion )
+    {
+        releaseDescriptor.setDefaultDevelopmentVersion( defaultDevelopmentVersion );
+        return this;
+    }
+
+    public ReleaseDescriptorBuilder setDefaultReleaseVersion( String defaultReleaseVersion )
+    {
+        releaseDescriptor.setDefaultReleaseVersion( defaultReleaseVersion );
+        return this;
+    }
+
+    public ReleaseDescriptorBuilder setDescription( String description )
+    {
+        releaseDescriptor.setDescription( description );
+        return this;
+    }
+
+    public ReleaseDescriptorBuilder setGenerateReleasePoms( boolean generateReleasePoms )
+    {
+        releaseDescriptor.setGenerateReleasePoms( generateReleasePoms );
+        return this;
+    }
+
+    public ReleaseDescriptorBuilder setInteractive( boolean interactive )
+    {
+        releaseDescriptor.setInteractive( interactive );
+        return this;
+    }
+
+    public ReleaseDescriptorBuilder setLocalCheckout( boolean localCheckout )
+    {
+        releaseDescriptor.setLocalCheckout( localCheckout );
+        return this;
+    }
+
+    public ReleaseDescriptorBuilder setModelEncoding( String modelEncoding )
+    {
+        releaseDescriptor.setModelEncoding( modelEncoding );
+        return this;
+    }
+
+    public ReleaseDescriptorBuilder setName( String name )
+    {
+        releaseDescriptor.setName( name );
+        return this;
+    }
+
+    public ReleaseDescriptorBuilder setPerformGoals( String performGoals )
+    {
+        releaseDescriptor.setPerformGoals( performGoals );
+        return this;
+    }
+
+    public ReleaseDescriptorBuilder setPomFileName( String pomFileName )
+    {
+        releaseDescriptor.setPomFileName( pomFileName );
+        return this;
+    }
+
+    public ReleaseDescriptorBuilder setPreparationGoals( String preparationGoals )
+    {
+        releaseDescriptor.setPreparationGoals( preparationGoals );
+        return this;
+    }
+
+    public ReleaseDescriptorBuilder setProjectNamingPolicyId( String projectNamingPolicyId )
+    {
+        releaseDescriptor.setProjectNamingPolicyId( projectNamingPolicyId );
+        return this;
+    }
+
+    public ReleaseDescriptorBuilder setProjectVersionPolicyId( String projectVersionPolicyId )
+    {
+        releaseDescriptor.setProjectVersionPolicyId( projectVersionPolicyId );
+        return this;
+    }
+
+    public ReleaseDescriptorBuilder setPushChanges( boolean pushChanges )
+    {
+        releaseDescriptor.setPushChanges( pushChanges );
+        return this;
+    }
+
+    public ReleaseDescriptorBuilder setReleaseStrategyId( String releaseStrategyId )
+    {
+        releaseDescriptor.setReleaseStrategyId( releaseStrategyId );
+        return this;
+    }
+
+    public ReleaseDescriptorBuilder setRemoteTagging( boolean remoteTagging )
+    {
+        releaseDescriptor.setRemoteTagging( remoteTagging );
+        return this;
+    }
+
+    public ReleaseDescriptorBuilder setScmBranchBase( String scmBranchBase )
+    {
+        releaseDescriptor.setScmBranchBase( scmBranchBase );
+        return this;
+    }
+
+    public ReleaseDescriptorBuilder setScmCommentPrefix( String scmCommentPrefix )
+    {
+        releaseDescriptor.setScmCommentPrefix( scmCommentPrefix );
+        return this;
+    }
+
+    public ReleaseDescriptorBuilder setScmId( String scmId )
+    {
+        releaseDescriptor.setScmId( scmId );
+        return this;
+    }
+
+    public ReleaseDescriptorBuilder setScmPassword( String scmPassword )
+    {
+        releaseDescriptor.setScmPassword( scmPassword );
+        return this;
+    }
+
+    public ReleaseDescriptorBuilder setScmPrivateKey( String scmPrivateKey )
+    {
+        releaseDescriptor.setScmPrivateKey( scmPrivateKey );
+        return this;
+    }
+
+    public ReleaseDescriptorBuilder setScmPrivateKeyPassPhrase( String scmPrivateKeyPassPhrase )
+    {
+        releaseDescriptor.setScmPrivateKeyPassPhrase( scmPrivateKeyPassPhrase );
+        return this;
+    }
+
+    public ReleaseDescriptorBuilder setScmRelativePathProjectDirectory( String scmRelativePathProjectDirectory )
+    {
+        releaseDescriptor.setScmRelativePathProjectDirectory( scmRelativePathProjectDirectory );
+        return this;
+    }
+
+    public ReleaseDescriptorBuilder setScmReleaseLabel( String scmReleaseLabel )
+    {
+        releaseDescriptor.setScmReleaseLabel( scmReleaseLabel );
+        return this;
+    }
+
+    public ReleaseDescriptorBuilder setScmReleasedPomRevision( String scmReleasedPomRevision )
+    {
+        releaseDescriptor.setScmReleasedPomRevision( scmReleasedPomRevision );
+        return this;
+    }
+
+    public ReleaseDescriptorBuilder setScmSourceUrl( String scmSourceUrl )
+    {
+        releaseDescriptor.setScmSourceUrl( scmSourceUrl );
+        return this;
+    }
+
+    public ReleaseDescriptorBuilder setScmTagBase( String scmTagBase )
+    {
+        releaseDescriptor.setScmTagBase( scmTagBase );
+        return this;
+    }
+
+    public ReleaseDescriptorBuilder setScmTagNameFormat( String scmTagNameFormat )
+    {
+        releaseDescriptor.setScmTagNameFormat( scmTagNameFormat );
+        return this;
+    }
+
+    public ReleaseDescriptorBuilder setScmUseEditMode( boolean scmUseEditMode )
+    {
+        releaseDescriptor.setScmUseEditMode( scmUseEditMode );
+        return this;
+    }
+
+    public ReleaseDescriptorBuilder setScmUsername( String scmUsername )
+    {
+        releaseDescriptor.setScmUsername( scmUsername );
+        return this;
+    }
+
+    public ReleaseDescriptorBuilder setSnapshotReleasePluginAllowed( boolean snapshotReleasePluginAllowed )
+    {
+        releaseDescriptor.setSnapshotReleasePluginAllowed( snapshotReleasePluginAllowed );
+        return this;
+    }
+
+    public ReleaseDescriptorBuilder setSuppressCommitBeforeTagOrBranch( boolean suppressCommitBeforeTagOrBranch )
+    {
+        releaseDescriptor.setSuppressCommitBeforeTagOrBranch( suppressCommitBeforeTagOrBranch );
+        return this;
+    }
+
+    public ReleaseDescriptorBuilder setUpdateBranchVersions( boolean updateBranchVersions )
+    {
+        releaseDescriptor.setUpdateBranchVersions( updateBranchVersions );
+        return this;
+    }
+
+    public ReleaseDescriptorBuilder setUpdateDependencies( boolean updateDependencies )
+    {
+        releaseDescriptor.setUpdateDependencies( updateDependencies );
+        return this;
+    }
+
+    public ReleaseDescriptorBuilder setUpdateVersionsToSnapshot( boolean updateVersionsToSnapshot )
+    {
+        releaseDescriptor.setUpdateVersionsToSnapshot( updateVersionsToSnapshot );
+        return this;
+    }
+
+    public ReleaseDescriptorBuilder setUpdateWorkingCopyVersions( boolean updateWorkingCopyVersions )
+    {
+        releaseDescriptor.setUpdateWorkingCopyVersions( updateWorkingCopyVersions );
+        return this;
+    }
+
+    public ReleaseDescriptorBuilder setUseReleaseProfile( boolean useReleaseProfile )
+    {
+        releaseDescriptor.setUseReleaseProfile( useReleaseProfile );
+        return this;
+    }
+
+    public ReleaseDescriptorBuilder setWaitBeforeTagging( int waitBeforeTagging )
+    {
+        releaseDescriptor.setWaitBeforeTagging( waitBeforeTagging );
+        return this;
+    }
+
+    public ReleaseDescriptorBuilder setWorkingDirectory( String workingDirectory )
+    {
+        releaseDescriptor.setWorkingDirectory( workingDirectory );
+        return this;
+    }
+
+    public ReleaseDescriptorBuilder addReleaseVersion( String key, String value )
+    {
+        releaseDescriptor.addReleaseVersion( key, value );
+        return this;
+    }
+
+    public ReleaseDescriptorBuilder addDevelopmentVersion( String key, String value )
+    {
+        releaseDescriptor.addDevelopmentVersion( key, value );
+        return this;
+    }
+
+    public ReleaseDescriptorBuilder addOriginalScmInfo( String key, Scm value )
+    {
+        releaseDescriptor.addOriginalScmInfo( key, value );
+        return this;
+    }
+
+    public void putOriginalVersion( String projectKey, String version )
+    {
+        releaseDescriptor.addOriginalVersion( projectKey, version );
+    }
+    
+    public ReleaseDescriptorBuilder addDependencyOriginalVersion( String dependencyKey, String version )
+    {
+        releaseDescriptor.addDependencyOriginalVersion( dependencyKey, version );
+        return this;
+        
+    }
+    
+    public ReleaseDescriptorBuilder addDependencyReleaseVersion( String dependencyKey, String version )
+    {
+        releaseDescriptor.addDependencyReleaseVersion( dependencyKey, version );
+        return this;
+    }
+    
+    public ReleaseDescriptorBuilder addDependencyDevelopmentVersion( String dependencyKey, String version )
+    {
+        releaseDescriptor.addDependencyDevelopmentVersion( dependencyKey, version );
+        return this;
+    }
+
+    BuilderReleaseDescriptor build()
+    {
+        return releaseDescriptor;
+    }
+}
diff --git a/maven-release-manager/src/main/java/org/apache/maven/shared/release/config/ReleaseDescriptorStore.java b/maven-release-manager/src/main/java/org/apache/maven/shared/release/config/ReleaseDescriptorStore.java
index 5b1e8c4..69092c1 100644
--- a/maven-release-manager/src/main/java/org/apache/maven/shared/release/config/ReleaseDescriptorStore.java
+++ b/maven-release-manager/src/main/java/org/apache/maven/shared/release/config/ReleaseDescriptorStore.java
@@ -33,7 +33,7 @@
      *                        while others are used to override
      * @return the configuration
      */
-    ReleaseDescriptor read( ReleaseDescriptor mergeDescriptor )
+    ReleaseDescriptorBuilder read( ReleaseDescriptorBuilder mergeDescriptor )
         throws ReleaseDescriptorStoreException;
 
     /**
diff --git a/maven-release-manager/src/main/java/org/apache/maven/shared/release/config/ReleaseUtils.java b/maven-release-manager/src/main/java/org/apache/maven/shared/release/config/ReleaseUtils.java
index 743b062..36504c2 100644
--- a/maven-release-manager/src/main/java/org/apache/maven/shared/release/config/ReleaseUtils.java
+++ b/maven-release-manager/src/main/java/org/apache/maven/shared/release/config/ReleaseUtils.java
@@ -19,13 +19,12 @@
  * under the License.
  */
 
-import java.util.HashMap;
 import java.util.Iterator;
-import java.util.Map;
 import java.util.Map.Entry;
 import java.util.Properties;
 import java.util.Set;
 
+import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder.BuilderReleaseDescriptor;
 import org.apache.maven.shared.release.scm.IdentifiedScm;
 
 /**
@@ -35,152 +34,119 @@
  */
 public class ReleaseUtils
 {
+    private static final String DEVELOPMENT_KEY = "dev";
+
+    private static final String RELEASE_KEY = "rel";
+
     private ReleaseUtils()
     {
         // nothing to see here
     }
 
-    /**
-     * Merge two descriptors together. All SCM settings are overridden by the merge descriptor, as is the
-     * <code>workingDirectory</code> field. The <code>completedPhase</code> field is used as
-     * a default from the merge descriptor, but not overridden if it exists.
-     *
-     * @param mergeInto  the descriptor to be merged into
-     * @param toBeMerged the descriptor to merge into mergeInto
-     * @return ReleaseDescriptor the merged descriptor
-     */
-    public static ReleaseDescriptor merge( ReleaseDescriptor mergeInto, ReleaseDescriptor toBeMerged )
+    public static BuilderReleaseDescriptor buildReleaseDescriptor( ReleaseDescriptorBuilder builder )
     {
-        // Overridden if configured from the caller
-        mergeInto.setScmId( mergeOverride( mergeInto.getScmId(), toBeMerged.getScmId() ) );
-        mergeInto.setScmSourceUrl( mergeOverride( mergeInto.getScmSourceUrl(), toBeMerged.getScmSourceUrl() ) );
-        mergeInto.setScmCommentPrefix(
-            mergeOverride( mergeInto.getScmCommentPrefix(), toBeMerged.getScmCommentPrefix() ) );
-        mergeInto.setScmReleaseLabel( mergeOverride( mergeInto.getScmReleaseLabel(),
-                                                     toBeMerged.getScmReleaseLabel() ) );
-        mergeInto.setScmTagBase( mergeOverride( mergeInto.getScmTagBase(), toBeMerged.getScmTagBase() ) );
-        mergeInto.setScmTagNameFormat(
-            mergeOverride( mergeInto.getScmTagNameFormat(), toBeMerged.getScmTagNameFormat() ) );
-        mergeInto.setScmBranchBase( mergeOverride( mergeInto.getScmBranchBase(), toBeMerged.getScmBranchBase() ) );
-        mergeInto.setScmUsername( mergeOverride( mergeInto.getScmUsername(), toBeMerged.getScmUsername() ) );
-        mergeInto.setScmPassword( mergeOverride( mergeInto.getScmPassword(), toBeMerged.getScmPassword() ) );
-        mergeInto.setScmPrivateKey( mergeOverride( mergeInto.getScmPrivateKey(), toBeMerged.getScmPrivateKey() ) );
-        mergeInto.setScmPrivateKeyPassPhrase(
-            mergeOverride( mergeInto.getScmPrivateKeyPassPhrase(), toBeMerged.getScmPrivateKeyPassPhrase() ) );
-        mergeInto.setScmCommentPrefix(
-            mergeOverride( mergeInto.getScmCommentPrefix(), toBeMerged.getScmCommentPrefix() ) );
-        mergeInto.setAdditionalArguments(
-            mergeOverride( mergeInto.getAdditionalArguments(), toBeMerged.getAdditionalArguments() ) );
-        mergeInto.setPreparationGoals(
-            mergeOverride( mergeInto.getPreparationGoals(), toBeMerged.getPreparationGoals() ) );
-        mergeInto.setCompletionGoals(
-            mergeOverride( mergeInto.getCompletionGoals(), toBeMerged.getCompletionGoals() ) );
-        mergeInto.setPerformGoals( mergeOverride( mergeInto.getPerformGoals(), toBeMerged.getPerformGoals() ) );
-        mergeInto.setPomFileName( mergeOverride( mergeInto.getPomFileName(), toBeMerged.getPomFileName() ) );
-        mergeInto.setCheckModificationExcludes( toBeMerged.getCheckModificationExcludes() );
-        mergeInto.setScmUseEditMode( toBeMerged.isScmUseEditMode() );
-        mergeInto.setAddSchema( toBeMerged.isAddSchema() );
-        mergeInto.setGenerateReleasePoms( toBeMerged.isGenerateReleasePoms() );
-        mergeInto.setInteractive( toBeMerged.isInteractive() );
-        mergeInto.setUpdateDependencies( toBeMerged.isUpdateDependencies() );
-        mergeInto.setCommitByProject( mergeOverride( mergeInto.isCommitByProject(), toBeMerged.isCommitByProject(),
-                                                     false ) );
-        mergeInto.setUseReleaseProfile( toBeMerged.isUseReleaseProfile() );
-        mergeInto.setBranchCreation( toBeMerged.isBranchCreation() );
-        mergeInto.setUpdateBranchVersions( toBeMerged.isUpdateBranchVersions() );
-        mergeInto.setUpdateWorkingCopyVersions( toBeMerged.isUpdateWorkingCopyVersions() );
-        mergeInto.setSuppressCommitBeforeTagOrBranch( toBeMerged.isSuppressCommitBeforeTagOrBranch() );
-        mergeInto.setUpdateVersionsToSnapshot( toBeMerged.isUpdateVersionsToSnapshot() );
-        mergeInto.setAllowTimestampedSnapshots( toBeMerged.isAllowTimestampedSnapshots() );
-        mergeInto.setSnapshotReleasePluginAllowed( toBeMerged.isSnapshotReleasePluginAllowed() );
-        mergeInto.setAutoVersionSubmodules( toBeMerged.isAutoVersionSubmodules() );
-        mergeInto.setDefaultReleaseVersion( mergeOverride( mergeInto.getDefaultReleaseVersion(),
-                                                           toBeMerged.getDefaultReleaseVersion() ) );
-        mergeInto.setDefaultDevelopmentVersion( mergeOverride( mergeInto.getDefaultDevelopmentVersion(),
-                                                               toBeMerged.getDefaultDevelopmentVersion() ) );
-        mergeInto.setRemoteTagging( toBeMerged.isRemoteTagging() );
-        mergeInto.setLocalCheckout( toBeMerged.isLocalCheckout() );
-        mergeInto.setPushChanges( toBeMerged.isPushChanges() );
-        mergeInto.setWaitBeforeTagging( toBeMerged.getWaitBeforeTagging() );
+        return builder.build();
+    }
 
-        // If the user specifies versions, these should be override the existing versions
-        if ( toBeMerged.getReleaseVersions() != null )
+    public static void copyPropertiesToReleaseDescriptor( Properties properties, ReleaseDescriptorBuilder builder )
+    {
+        if ( properties.containsKey( "completedPhase" ) )
         {
-            mergeInto.getReleaseVersions().putAll( toBeMerged.getReleaseVersions() );
+            builder.setCompletedPhase( properties.getProperty( "completedPhase" ) );
         }
-        if ( toBeMerged.getDevelopmentVersions() != null )
+        if ( properties.containsKey( "commitByProject" ) )
         {
-            mergeInto.getDevelopmentVersions().putAll( toBeMerged.getDevelopmentVersions() );
+            builder.setCommitByProject( Boolean.parseBoolean( properties.getProperty( "commitByProject" ) ) );
         }
-        // These must be overridden, as they are not stored
-        mergeInto.setWorkingDirectory(
-            mergeOverride( mergeInto.getWorkingDirectory(), toBeMerged.getWorkingDirectory() ) );
-        mergeInto.setCheckoutDirectory(
-            mergeOverride( mergeInto.getCheckoutDirectory(), toBeMerged.getCheckoutDirectory() ) );
+        if ( properties.containsKey( "scm.id" ) )
+        {
+            builder.setScmId( properties.getProperty( "scm.id" ) );
+        }
+        if ( properties.containsKey( "scm.url" ) )
+        {
+            builder.setScmSourceUrl( properties.getProperty( "scm.url" ) );
+        }
+        if ( properties.containsKey( "scm.username" ) )
+        {
+            builder.setScmUsername( properties.getProperty( "scm.username" ) );
+        }
+        if ( properties.containsKey( "scm.password" ) )
+        {
+            builder.setScmPassword( properties.getProperty( "scm.password" ) );
+        }
+        if ( properties.containsKey( "scm.privateKey" ) )
+        {
+            builder.setScmPrivateKey( properties.getProperty( "scm.privateKey" ) );
+        }
+        if ( properties.containsKey( "scm.passphrase" ) )
+        {
+            builder.setScmPrivateKeyPassPhrase( properties.getProperty( "scm.passphrase" ) );
+        }
+        if ( properties.containsKey( "scm.tagBase" ) )
+        {
+            builder.setScmTagBase( properties.getProperty( "scm.tagBase" ) );
+        }
+        if ( properties.containsKey( "scm.tagNameFormat" ) )
+        {
+            builder.setScmTagNameFormat( properties.getProperty( "scm.tagNameFormat" ) );
+        }
+        if ( properties.containsKey( "scm.branchBase" ) )
+        {
+            builder.setScmBranchBase( properties.getProperty( "scm.branchBase" ) );
+        }
+        if ( properties.containsKey( "scm.tag" ) )
+        {
+            builder.setScmReleaseLabel( properties.getProperty( "scm.tag" ) );
+        }
+        if ( properties.containsKey( "scm.commentPrefix" ) )
+        {
+            builder.setScmCommentPrefix( properties.getProperty( "scm.commentPrefix" ) );
+        }
+        if ( properties.containsKey( "exec.additionalArguments" ) )
+        {
+            builder.setAdditionalArguments( properties.getProperty( "exec.additionalArguments" ) );
+        }
+        if ( properties.containsKey( "exec.pomFileName" ) )
+        {
+            builder.setPomFileName( properties.getProperty( "exec.pomFileName" ) );
+        }
+        if ( properties.containsKey( "preparationGoals" ) )
+        {
+            builder.setPreparationGoals( properties.getProperty( "preparationGoals" ) );
+        }
+        if ( properties.containsKey( "completionGoals" ) )
+        {
+            builder.setCompletionGoals( properties.getProperty( "completionGoals" ) );
+        }
+        if ( properties.containsKey( "projectVersionPolicyId" ) )
+        {
+            builder.setProjectVersionPolicyId( properties.getProperty( "projectVersionPolicyId" ) );
+        }
+        if ( properties.containsKey( "projectNamingPolicyId" ) )
+        {
+            builder.setProjectNamingPolicyId( properties.getProperty( "projectNamingPolicyId" ) );
+        }
+        if ( properties.containsKey( "releaseStrategyId" ) )
+        {
+            builder.setReleaseStrategyId( properties.getProperty( "releaseStrategyId" ) );
+        }
+        if ( properties.containsKey( "exec.snapshotReleasePluginAllowed" ) )
+        {
+            String snapshotReleasePluginAllowedStr = properties.getProperty( "exec.snapshotReleasePluginAllowed" );
+            builder.setSnapshotReleasePluginAllowed( Boolean.valueOf( snapshotReleasePluginAllowedStr ) );
+        }
+        if ( properties.containsKey( "remoteTagging" ) )
+        {
+            String remoteTaggingStr = properties.getProperty( "remoteTagging" );
+            builder.setRemoteTagging( Boolean.valueOf( remoteTaggingStr ) );
+        }
+        if ( properties.containsKey( "pushChanges" ) )
+        {
+            String pushChanges = properties.getProperty( "pushChanges" );
+            builder.setPushChanges( Boolean.valueOf( pushChanges ) );
+        }
 
-        // Not overridden - not configured from caller
-        mergeInto.setCompletedPhase( mergeDefault( mergeInto.getCompletedPhase(), toBeMerged.getCompletedPhase() ) );
-
-        mergeInto.setProjectVersionPolicyId( mergeDefault( mergeInto.getProjectVersionPolicyId(),
-                                                           toBeMerged.getProjectVersionPolicyId() ) );
-        mergeInto.setProjectNamingPolicyId( mergeDefault( mergeInto.getProjectNamingPolicyId(),
-                                                          toBeMerged.getProjectNamingPolicyId() ) );
-        mergeInto.setReleaseStrategyId( mergeOverride( mergeInto.getReleaseStrategyId(),
-                                                          toBeMerged.getReleaseStrategyId() ) );
-
-        return mergeInto;
-    }
-
-    private static String mergeOverride( String thisValue, String mergeValue )
-    {
-        return mergeValue != null ? mergeValue : thisValue;
-    }
-
-    private static String mergeDefault( String thisValue, String mergeValue )
-    {
-        return thisValue != null ? thisValue : mergeValue;
-    }
-
-    private static boolean mergeOverride( boolean thisValue, boolean mergeValue, boolean defaultValue )
-    {
-        return mergeValue != defaultValue ? mergeValue : thisValue;
-    }
-
-    public static ReleaseDescriptor copyPropertiesToReleaseDescriptor( Properties properties )
-    {
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setCompletedPhase( properties.getProperty( "completedPhase" ) );
-        releaseDescriptor.setCommitByProject( Boolean.parseBoolean( properties.getProperty( "commitByProject" ) ) );
-        releaseDescriptor.setScmId( properties.getProperty( "scm.id" ) );
-        releaseDescriptor.setScmSourceUrl( properties.getProperty( "scm.url" ) );
-        releaseDescriptor.setScmUsername( properties.getProperty( "scm.username" ) );
-        releaseDescriptor.setScmPassword( properties.getProperty( "scm.password" ) );
-        releaseDescriptor.setScmPrivateKey( properties.getProperty( "scm.privateKey" ) );
-        releaseDescriptor.setScmPrivateKeyPassPhrase( properties.getProperty( "scm.passphrase" ) );
-        releaseDescriptor.setScmTagBase( properties.getProperty( "scm.tagBase" ) );
-        releaseDescriptor.setScmTagNameFormat( properties.getProperty( "scm.tagNameFormat" ) );
-        releaseDescriptor.setScmBranchBase( properties.getProperty( "scm.branchBase" ) );
-        releaseDescriptor.setScmReleaseLabel( properties.getProperty( "scm.tag" ) );
-        releaseDescriptor.setScmCommentPrefix( properties.getProperty( "scm.commentPrefix" ) );
-        releaseDescriptor.setAdditionalArguments( properties.getProperty( "exec.additionalArguments" ) );
-        releaseDescriptor.setPomFileName( properties.getProperty( "exec.pomFileName" ) );
-        releaseDescriptor.setPreparationGoals( properties.getProperty( "preparationGoals" ) );
-        releaseDescriptor.setCompletionGoals( properties.getProperty( "completionGoals" ) );
-        releaseDescriptor.setProjectVersionPolicyId( properties.getProperty( "projectVersionPolicyId" ) );
-        releaseDescriptor.setProjectNamingPolicyId( properties.getProperty( "projectNamingPolicyId" ) );
-        releaseDescriptor.setReleaseStrategyId( properties.getProperty( "releaseStrategyId" ) );
-        String snapshotReleasePluginAllowedStr = properties.getProperty( "exec.snapshotReleasePluginAllowed" );
-        releaseDescriptor.setSnapshotReleasePluginAllowed( snapshotReleasePluginAllowedStr == null
-                                                               ? false
-                                                               : Boolean.valueOf(
-                                                                   snapshotReleasePluginAllowedStr ).booleanValue() );
-        String remoteTaggingStr = properties.getProperty( "remoteTagging" );
-        releaseDescriptor.setRemoteTagging(
-            remoteTaggingStr == null ? false : Boolean.valueOf( remoteTaggingStr ).booleanValue() );
-        String pushChanges = properties.getProperty( "pushChanges" );
-        releaseDescriptor.setPushChanges( pushChanges == null ? true : Boolean.valueOf( pushChanges ).booleanValue() );
-
-        loadResolvedDependencies( properties, releaseDescriptor );
+        loadResolvedDependencies( properties, builder );
 
         // boolean properties are not written to the properties file because the value from the caller is always used
 
@@ -189,12 +155,12 @@
             String property = (String) i.next();
             if ( property.startsWith( "project.rel." ) )
             {
-                releaseDescriptor.mapReleaseVersion( property.substring( "project.rel.".length() ),
+                builder.addReleaseVersion( property.substring( "project.rel.".length() ),
                                                      properties.getProperty( property ) );
             }
             else if ( property.startsWith( "project.dev." ) )
             {
-                releaseDescriptor.mapDevelopmentVersion( property.substring( "project.dev.".length() ),
+                builder.addDevelopmentVersion( property.substring( "project.dev.".length() ),
                                                          properties.getProperty( property ) );
             }
             else if ( property.startsWith( "project.scm." ) )
@@ -204,11 +170,11 @@
                 {
                     String key = property.substring( "project.scm.".length(), index );
 
-                    if ( !releaseDescriptor.getOriginalScmInfo().containsKey( key ) )
+                    if ( builder.build().getOriginalScmInfo( key ) == null )
                     {
                         if ( properties.getProperty( "project.scm." + key + ".empty" ) != null )
                         {
-                            releaseDescriptor.mapOriginalScmInfo( key, null );
+                            builder.addOriginalScmInfo( key, null );
                         }
                         else
                         {
@@ -220,19 +186,16 @@
                             scm.setTag( properties.getProperty( "project.scm." + key + ".tag" ) );
                             scm.setId( properties.getProperty( "project.scm." + key + ".id" ) );
 
-                            releaseDescriptor.mapOriginalScmInfo( key, scm );
+                            builder.addOriginalScmInfo( key, scm );
                         }
                     }
                 }
             }
         }
-        return releaseDescriptor;
     }
 
-    private static void loadResolvedDependencies( Properties prop, ReleaseDescriptor descriptor )
+    private static void loadResolvedDependencies( Properties prop, ReleaseDescriptorBuilder builder )
     {
-        Map<String, Map<String, String>> resolvedDependencies = new HashMap<>();
-
         Set entries = prop.entrySet();
         Iterator<Entry<String, String>> iterator = entries.iterator();
         String propertyName;
@@ -245,23 +208,20 @@
 
             if ( propertyName.startsWith( "dependency." ) )
             {
-                Map<String, String> versionMap;
                 String artifactVersionlessKey;
                 int startIndex = "dependency.".length();
                 int endIndex;
                 String versionType;
 
-                versionMap = new HashMap<>();
-
                 if ( propertyName.indexOf( ".development" ) != -1 )
                 {
                     endIndex = propertyName.lastIndexOf( ".development" );
-                    versionType = ReleaseDescriptor.DEVELOPMENT_KEY;
+                    versionType = DEVELOPMENT_KEY;
                 }
                 else if ( propertyName.indexOf( ".release" ) != -1 )
                 {
                     endIndex = propertyName.lastIndexOf( ".release" );
-                    versionType = ReleaseDescriptor.RELEASE_KEY;
+                    versionType = RELEASE_KEY;
                 }
                 else
                 {
@@ -271,21 +231,16 @@
 
                 artifactVersionlessKey = propertyName.substring( startIndex, endIndex );
 
-                if ( resolvedDependencies.containsKey( artifactVersionlessKey ) )
+                if ( RELEASE_KEY.equals( versionType ) )
                 {
-                    versionMap = resolvedDependencies.get( artifactVersionlessKey );
+                    builder.addDependencyReleaseVersion( artifactVersionlessKey, currentEntry.getValue() );
                 }
-                else
+                else if ( DEVELOPMENT_KEY.equals( versionType ) )
                 {
-                    versionMap = new HashMap<>();
-                    resolvedDependencies.put( artifactVersionlessKey, versionMap );
+                    builder.addDependencyDevelopmentVersion( artifactVersionlessKey, currentEntry.getValue() );
                 }
-
-                versionMap.put( versionType, currentEntry.getValue() );
             }
         }
-
-        descriptor.setResolvedSnapshotDependencies( resolvedDependencies );
     }
 
 }
diff --git a/maven-release-manager/src/main/java/org/apache/maven/shared/release/env/DefaultReleaseEnvironment.java b/maven-release-manager/src/main/java/org/apache/maven/shared/release/env/DefaultReleaseEnvironment.java
index 6b5659e..3305756 100644
--- a/maven-release-manager/src/main/java/org/apache/maven/shared/release/env/DefaultReleaseEnvironment.java
+++ b/maven-release-manager/src/main/java/org/apache/maven/shared/release/env/DefaultReleaseEnvironment.java
@@ -55,15 +55,13 @@
         return settings;
     }
 
-    @Override
-    public ReleaseEnvironment setMavenHome( File mavenHome )
+    public DefaultReleaseEnvironment setMavenHome( File mavenHome )
     {
         this.mavenHome = mavenHome;
         return this;
     }
 
-    @Override
-    public ReleaseEnvironment setSettings( Settings settings )
+    public DefaultReleaseEnvironment setSettings( Settings settings )
     {
         this.settings = settings;
         return this;
@@ -75,8 +73,7 @@
         return mavenExecutorId;
     }
 
-    @Override
-    public ReleaseEnvironment setMavenExecutorId( String mavenExecutorId )
+    public DefaultReleaseEnvironment setMavenExecutorId( String mavenExecutorId )
     {
         this.mavenExecutorId = mavenExecutorId;
         return this;
@@ -88,8 +85,7 @@
         return javaHome;
     }
 
-    @Override
-    public ReleaseEnvironment setJavaHome( File javaHome )
+    public DefaultReleaseEnvironment setJavaHome( File javaHome )
     {
         this.javaHome = javaHome;
         return this;
@@ -108,8 +104,7 @@
         return localRepo;
     }
 
-    @Override
-    public ReleaseEnvironment setLocalRepositoryDirectory( File localRepositoryDirectory )
+    public DefaultReleaseEnvironment setLocalRepositoryDirectory( File localRepositoryDirectory )
     {
         this.localRepositoryDirectory = localRepositoryDirectory;
         return this;
@@ -121,8 +116,7 @@
         return locale;
     }
 
-    @Override
-    public ReleaseEnvironment setLocale( Locale locale )
+    public DefaultReleaseEnvironment setLocale( Locale locale )
     {
         this.locale = locale;
         return this;
diff --git a/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/AbstractRewritePomsPhase.java b/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/AbstractRewritePomsPhase.java
index 6fd4cb6..ac6a682 100644
--- a/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/AbstractRewritePomsPhase.java
+++ b/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/AbstractRewritePomsPhase.java
@@ -35,7 +35,6 @@
 import org.apache.maven.model.ModelBase;
 import org.apache.maven.model.Plugin;
 import org.apache.maven.model.Profile;
-import org.apache.maven.model.Scm;
 import org.apache.maven.project.MavenProject;
 import org.apache.maven.scm.ScmException;
 import org.apache.maven.scm.ScmFileSet;
@@ -49,7 +48,6 @@
 import org.apache.maven.shared.release.ReleaseResult;
 import org.apache.maven.shared.release.config.ReleaseDescriptor;
 import org.apache.maven.shared.release.env.ReleaseEnvironment;
-import org.apache.maven.shared.release.scm.IdentifiedScm;
 import org.apache.maven.shared.release.scm.ReleaseScmCommandException;
 import org.apache.maven.shared.release.scm.ReleaseScmRepositoryException;
 import org.apache.maven.shared.release.scm.ScmRepositoryConfigurator;
@@ -239,51 +237,42 @@
                                     ReleaseResult result, boolean simulate )
         throws ReleaseExecutionException, ReleaseFailureException
     {
-        Map<String, String> mappedVersions = getNextVersionMap( releaseDescriptor );
-        Map<String, String> originalVersions = getOriginalVersionMap( releaseDescriptor, reactorProjects, simulate );
-        Map<String, Map<String, String>> resolvedSnapshotDependencies =
-            releaseDescriptor.getResolvedSnapshotDependencies();
         Model model = project.getModel();
 
         Properties properties = modelTarget.getProperties();
 
-        String parentVersion = rewriteParent( project, modelTarget, mappedVersions,
-                                              resolvedSnapshotDependencies, originalVersions );
+        String parentVersion = rewriteParent( project, modelTarget, releaseDescriptor, simulate );
 
         String projectId = ArtifactUtils.versionlessKey( project.getGroupId(), project.getArtifactId() );
 
-        rewriteVersion( modelTarget, mappedVersions, projectId, project, parentVersion );
+        rewriteVersion( modelTarget, releaseDescriptor, projectId, project, parentVersion );
 
         Build buildTarget = modelTarget.getBuild();
         if ( buildTarget != null )
         {
             // profile.build.extensions doesn't exist, so only rewrite project.build.extensions
-            rewriteArtifactVersions( toMavenCoordinates( buildTarget.getExtensions() ), mappedVersions,
-                                     resolvedSnapshotDependencies, originalVersions, model, properties, result,
-                                     releaseDescriptor );
+            rewriteArtifactVersions( toMavenCoordinates( buildTarget.getExtensions() ), 
+                                     model, properties, result, releaseDescriptor, simulate );
 
-            rewriteArtifactVersions( toMavenCoordinates( buildTarget.getPlugins() ), mappedVersions,
-                                     resolvedSnapshotDependencies, originalVersions, model, properties, result,
-                                     releaseDescriptor );
+            rewriteArtifactVersions( toMavenCoordinates( buildTarget.getPlugins() ), 
+                                     model, properties, result, releaseDescriptor, simulate );
 
             for ( Plugin plugin : buildTarget.getPlugins() )
             {
                 rewriteArtifactVersions( toMavenCoordinates( plugin.getDependencies() ),
-                                         mappedVersions, resolvedSnapshotDependencies, originalVersions, model,
-                                         properties, result, releaseDescriptor );
+                                         model, properties,
+                                         result, releaseDescriptor, simulate );
             }
 
             if ( buildTarget.getPluginManagement() != null )
             {
-                rewriteArtifactVersions( toMavenCoordinates( buildTarget.getPluginManagement().getPlugins() ),
-                                         mappedVersions, resolvedSnapshotDependencies, originalVersions, model,
-                                         properties, result, releaseDescriptor );
+                rewriteArtifactVersions( toMavenCoordinates( buildTarget.getPluginManagement().getPlugins() ), model,
+                                         properties, result, releaseDescriptor, simulate );
 
                 for ( Plugin plugin : buildTarget.getPluginManagement().getPlugins() )
                 {
-                    rewriteArtifactVersions( toMavenCoordinates( plugin.getDependencies() ), mappedVersions,
-                                             resolvedSnapshotDependencies, originalVersions, model, properties,
-                                             result, releaseDescriptor );
+                    rewriteArtifactVersions( toMavenCoordinates( plugin.getDependencies() ), model, properties, result,
+                                             releaseDescriptor, simulate );
                 }
             }
         }
@@ -293,28 +282,24 @@
             BuildBase profileBuild = profile.getBuild();
             if ( profileBuild != null )
             {
-                rewriteArtifactVersions( toMavenCoordinates( profileBuild.getPlugins() ), mappedVersions,
-                                         resolvedSnapshotDependencies, originalVersions, model, properties, result,
-                                         releaseDescriptor );
+                rewriteArtifactVersions( toMavenCoordinates( profileBuild.getPlugins() ), model, properties, result,
+                                         releaseDescriptor, simulate );
 
                 for ( Plugin plugin : profileBuild.getPlugins() )
                 {
-                    rewriteArtifactVersions( toMavenCoordinates( plugin.getDependencies() ),
-                                             mappedVersions, resolvedSnapshotDependencies, originalVersions, model,
-                                             properties, result, releaseDescriptor );
+                    rewriteArtifactVersions( toMavenCoordinates( plugin.getDependencies() ), model, properties, result,
+                                             releaseDescriptor, simulate );
                 }
 
                 if ( profileBuild.getPluginManagement() != null )
                 {
                     rewriteArtifactVersions( toMavenCoordinates( profileBuild.getPluginManagement().getPlugins() ),
-                                             mappedVersions, resolvedSnapshotDependencies, originalVersions, model,
-                                             properties, result, releaseDescriptor );
+                                             model, properties, result, releaseDescriptor, simulate );
 
                     for ( Plugin plugin : profileBuild.getPluginManagement().getPlugins() )
                     {
-                        rewriteArtifactVersions( toMavenCoordinates( plugin.getDependencies() ), mappedVersions,
-                                                 resolvedSnapshotDependencies, originalVersions, model, properties,
-                                                 result, releaseDescriptor );
+                        rewriteArtifactVersions( toMavenCoordinates( plugin.getDependencies() ), model, properties,
+                                                 result, releaseDescriptor, simulate );
                     }
                 }
             }
@@ -326,22 +311,19 @@
 
         for ( ModelBase modelBase : modelBases )
         {
-            rewriteArtifactVersions( toMavenCoordinates( modelBase.getDependencies() ), mappedVersions,
-                                     resolvedSnapshotDependencies, originalVersions, model, properties, result,
-                                     releaseDescriptor );
+            rewriteArtifactVersions( toMavenCoordinates( modelBase.getDependencies() ), model, properties, result,
+                                     releaseDescriptor, simulate );
 
             if ( modelBase.getDependencyManagement() != null )
             {
                 rewriteArtifactVersions( toMavenCoordinates( modelBase.getDependencyManagement().getDependencies() ),
-                                         mappedVersions, resolvedSnapshotDependencies, originalVersions, model,
-                                         properties, result, releaseDescriptor );
+                                         model, properties, result, releaseDescriptor, simulate );
             }
 
             if ( modelBase.getReporting() != null )
             {
-                rewriteArtifactVersions( toMavenCoordinates( modelBase.getReporting().getPlugins() ), mappedVersions,
-                                         resolvedSnapshotDependencies, originalVersions, model, properties, result,
-                                         releaseDescriptor );
+                rewriteArtifactVersions( toMavenCoordinates( modelBase.getReporting().getPlugins() ), model, properties,
+                                         result, releaseDescriptor, simulate );
             }
         }
 
@@ -360,11 +342,11 @@
                       commonBasedir );
     }
 
-    private void rewriteVersion( Model modelTarget, Map<String, String> mappedVersions, String projectId,
+    private void rewriteVersion( Model modelTarget, ReleaseDescriptor releaseDescriptor, String projectId,
                                  MavenProject project, String parentVersion )
         throws ReleaseFailureException
     {
-        String version = mappedVersions.get( projectId );
+        String version = getNextVersion( releaseDescriptor, projectId );
         if ( version == null )
         {
             throw new ReleaseFailureException( "Version for '" + project.getName() + "' was not mapped" );
@@ -373,9 +355,8 @@
         modelTarget.setVersion( version );
     }
 
-    private String rewriteParent( MavenProject project, Model targetModel, Map<String, String> mappedVersions,
-                                  Map<String, Map<String, String>> resolvedSnapshotDependencies,
-                                  Map<String, String> originalVersions )
+    private String rewriteParent( MavenProject project, Model targetModel, 
+                                  ReleaseDescriptor releaseDescriptor, boolean simulate )
         throws ReleaseFailureException
     {
         String parentVersion = null;
@@ -383,15 +364,16 @@
         {
             MavenProject parent = project.getParent();
             String key = ArtifactUtils.versionlessKey( parent.getGroupId(), parent.getArtifactId() );
-            parentVersion = mappedVersions.get( key );
+            parentVersion = getNextVersion( releaseDescriptor, key );
             if ( parentVersion == null )
             {
                 //MRELEASE-317
-                parentVersion = getResolvedSnapshotVersion( key, resolvedSnapshotDependencies );
+                parentVersion = getResolvedSnapshotVersion( key, releaseDescriptor );
             }
             if ( parentVersion == null )
             {
-                if ( parent.getVersion().equals( originalVersions.get( key ) ) )
+                String original = getOriginalVersion( releaseDescriptor, key, simulate );
+                if ( parent.getVersion().equals( original ) )
                 {
                     throw new ReleaseFailureException( "Version for parent '" + parent.getName() + "' was not mapped" );
                 }
@@ -404,11 +386,9 @@
         return parentVersion;
     }
 
-    private void rewriteArtifactVersions( Collection<MavenCoordinate> elements, Map<String, String> mappedVersions,
-                                          Map<String, Map<String, String>> resolvedSnapshotDependencies,
-                                          Map<String, String> originalVersions, Model projectModel,
+    private void rewriteArtifactVersions( Collection<MavenCoordinate> elements, Model projectModel,
                                           Properties properties, ReleaseResult result,
-                                          ReleaseDescriptor releaseDescriptor )
+                                          ReleaseDescriptor releaseDescriptor, boolean simulate )
         throws ReleaseExecutionException, ReleaseFailureException
     {
         if ( elements == null )
@@ -449,12 +429,12 @@
             String artifactId = ReleaseUtil.interpolate( rawArtifactId, projectModel );
 
             String key = ArtifactUtils.versionlessKey( groupId, artifactId );
-            String resolvedSnapshotVersion = getResolvedSnapshotVersion( key, resolvedSnapshotDependencies );
-            String mappedVersion = mappedVersions.get( key );
-            String originalVersion = originalVersions.get( key );
+            String resolvedSnapshotVersion = getResolvedSnapshotVersion( key, releaseDescriptor );
+            String mappedVersion = getNextVersion( releaseDescriptor, key );
+            String originalVersion = getOriginalVersion( releaseDescriptor, key, simulate );
             if ( originalVersion == null )
             {
-                originalVersion = getOriginalResolvedSnapshotVersion( key, resolvedSnapshotDependencies );
+                originalVersion = getOriginalResolvedSnapshotVersion( key, releaseDescriptor );
             }
 
             // MRELEASE-220
@@ -478,7 +458,7 @@
                     if ( expression.startsWith( "project." ) || expression.startsWith( "pom." )
                         || "version".equals( expression ) )
                     {
-                        if ( !mappedVersion.equals( mappedVersions.get( projectId ) ) )
+                        if ( !mappedVersion.equals( getNextVersion( releaseDescriptor, projectId ) ) )
                         {
                             logInfo( result, "  Updating " + artifactId + " to " + mappedVersion );
                             coordinate.setVersion( mappedVersion );
@@ -579,13 +559,12 @@
 
 
     protected abstract String getResolvedSnapshotVersion( String artifactVersionlessKey,
-                                                          Map<String, Map<String, String>> resolvedSnapshots );
+                                                          ReleaseDescriptor releaseDscriptor );
 
-    protected abstract Map<String, String> getOriginalVersionMap( ReleaseDescriptor releaseDescriptor,
-                                                                  List<MavenProject> reactorProjects,
-                                                                  boolean simulate );
+    protected abstract String getOriginalVersion( ReleaseDescriptor releaseDescriptor, String projectKey,
+                                                  boolean simulate );
 
-    protected abstract Map<String, String> getNextVersionMap( ReleaseDescriptor releaseDescriptor );
+    protected abstract String getNextVersion( ReleaseDescriptor releaseDescriptor, String key );
 
     protected abstract void transformScm( MavenProject project, Model modelTarget, ReleaseDescriptor releaseDescriptor,
                                           String projectId, ScmRepository scmRepository,
@@ -603,37 +582,9 @@
     }
 
     protected String getOriginalResolvedSnapshotVersion( String artifactVersionlessKey,
-                                                         Map<String, Map<String, String>> resolvedSnapshots )
+                                                         ReleaseDescriptor releaseDescriptor )
     {
-        Map<String, String> versionsMap = resolvedSnapshots.get( artifactVersionlessKey );
-
-        if ( versionsMap != null )
-        {
-            return versionsMap.get( ReleaseDescriptor.ORIGINAL_VERSION );
-        }
-        else
-        {
-            return null;
-        }
-    }
-
-    protected Scm buildScm( MavenProject project )
-    {
-        IdentifiedScm scm;
-        if ( project.getOriginalModel().getScm() == null )
-        {
-            scm = null;
-        }
-        else
-        {
-            scm = new IdentifiedScm();
-            scm.setConnection( project.getOriginalModel().getScm().getConnection() );
-            scm.setDeveloperConnection( project.getOriginalModel().getScm().getDeveloperConnection() );
-            scm.setTag( project.getOriginalModel().getScm().getTag() );
-            scm.setUrl( project.getOriginalModel().getScm().getUrl() );
-            scm.setId( project.getProperties().getProperty( "project.scm.id" ) );
-        }
-        return scm;
+        return releaseDescriptor.getDependencyOriginalVersion( artifactVersionlessKey );
     }
 
     /**
diff --git a/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/CheckDependencySnapshotsPhase.java b/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/CheckDependencySnapshotsPhase.java
index cc762c9..4dd43b7 100644
--- a/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/CheckDependencySnapshotsPhase.java
+++ b/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/CheckDependencySnapshotsPhase.java
@@ -22,7 +22,6 @@
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
-import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
@@ -78,10 +77,6 @@
     // We'll probably need to introduce specifiedSnapshots as well.
     // @TODO MRELEASE-378: verify custom dependencies in plugins. Be aware of deprecated/removed Components in M3, such as PluginCollector
     // @TODO MRELEASE-763: verify all dependencies in inactive profiles
-    private Set<Artifact> usedSnapshotDependencies = new HashSet<>();
-    private Set<Artifact> usedSnapshotReports = new HashSet<>();
-    private Set<Artifact> usedSnapshotExtensions = new HashSet<>();
-    private Set<Artifact> usedSnapshotPlugins = new HashSet<>();
     
     // Don't prompt for every project in reactor, remember state of questions
     private String resolveSnapshot;
@@ -99,11 +94,9 @@
         {
             logInfo( result, "Checking dependencies and plugins for snapshots ..." );
 
-            Map<String, String> originalVersions = releaseDescriptor.getOriginalVersions( reactorProjects );
-
             for ( MavenProject project : reactorProjects )
             {
-                checkProject( project, originalVersions, releaseDescriptor );
+                checkProject( project, releaseDescriptor );
             }
         }
         else
@@ -115,35 +108,36 @@
         return result;
     }
 
-    private void checkProject( MavenProject project, Map<String, String> originalVersions,
-                               ReleaseDescriptor releaseDescriptor )
+    private void checkProject( MavenProject project, ReleaseDescriptor releaseDescriptor )
         throws ReleaseFailureException, ReleaseExecutionException
     {
         Map<String, Artifact> artifactMap = ArtifactUtils.artifactMapByVersionlessId( project.getArtifacts() );
+        
+        Set<Artifact> usedSnapshotDependencies = new HashSet<>();
 
         if ( project.getParentArtifact() != null )
         {
-            if ( checkArtifact( project.getParentArtifact(), originalVersions, artifactMap, releaseDescriptor ) )
+            if ( checkArtifact( project.getParentArtifact(), artifactMap, releaseDescriptor ) )
             {
                 usedSnapshotDependencies.add( project.getParentArtifact() );
             }
         }
 
         Set<Artifact> dependencyArtifacts = project.getArtifacts();
-        checkDependencies( originalVersions, releaseDescriptor, artifactMap, dependencyArtifacts );
+        usedSnapshotDependencies.addAll( checkDependencies( releaseDescriptor, artifactMap, dependencyArtifacts ) );
 
         //@todo check dependencyManagement
 
         Set<Artifact> pluginArtifacts = project.getPluginArtifacts();
-        checkPlugins( originalVersions, releaseDescriptor, artifactMap, pluginArtifacts );
+        Set<Artifact> usedSnapshotPlugins = checkPlugins( releaseDescriptor, artifactMap, pluginArtifacts );
 
         //@todo check pluginManagement
 
         Set<Artifact> reportArtifacts = project.getReportArtifacts();
-        checkReports( originalVersions, releaseDescriptor, artifactMap, reportArtifacts );
+        Set<Artifact> usedSnapshotReports = checkReports( releaseDescriptor, artifactMap, reportArtifacts );
 
         Set<Artifact> extensionArtifacts = project.getExtensionArtifacts();
-        checkExtensions( originalVersions, releaseDescriptor, artifactMap, extensionArtifacts );
+        Set<Artifact> usedSnapshotExtensions = checkExtensions( releaseDescriptor, artifactMap, extensionArtifacts );
 
         //@todo check profiles
 
@@ -173,13 +167,14 @@
         }
     }
 
-    private void checkPlugins( Map<String, String> originalVersions, ReleaseDescriptor releaseDescriptor,
+    private Set<Artifact> checkPlugins( ReleaseDescriptor releaseDescriptor,
                                Map<String, Artifact> artifactMap, Set<Artifact> pluginArtifacts )
         throws ReleaseExecutionException
     {
+        Set<Artifact> usedSnapshotPlugins = new HashSet<>();
         for ( Artifact artifact : pluginArtifacts )
         {
-            if ( checkArtifact( artifact, originalVersions, artifactMap, releaseDescriptor ) )
+            if ( checkArtifact( artifact, artifactMap, releaseDescriptor ) )
             {
                 boolean addToFailures;
 
@@ -212,7 +207,6 @@
                             if ( result.toLowerCase( Locale.ENGLISH ).startsWith( "y" ) )
                             {
                                 addToFailures = false;
-                                releaseDescriptor.setSnapshotReleasePluginAllowed( true );
                             }
                             else
                             {
@@ -240,52 +234,60 @@
                 }
             }
         }
+        return usedSnapshotPlugins;
     }
 
-    private void checkDependencies( Map<String, String> originalVersions, ReleaseDescriptor releaseDescriptor,
-                                    Map<String, Artifact> artifactMap, Set<Artifact> dependencyArtifacts )
+    private Set<Artifact> checkDependencies( ReleaseDescriptor releaseDescriptor,
+                                    Map<String, Artifact> artifactMap, 
+                                    Set<Artifact> dependencyArtifacts )
     {
+        Set<Artifact> usedSnapshotDependencies = new HashSet<>();
         for ( Artifact artifact : dependencyArtifacts )
         {
-            if ( checkArtifact( artifact, originalVersions, artifactMap, releaseDescriptor ) )
+            if ( checkArtifact( artifact, artifactMap, releaseDescriptor ) )
             {
                 usedSnapshotDependencies.add( getArtifactFromMap( artifact, artifactMap ) );
             }
         }
+        return usedSnapshotDependencies;
     }
 
-    private void checkReports( Map<String, String> originalVersions, ReleaseDescriptor releaseDescriptor,
+    private Set<Artifact> checkReports( ReleaseDescriptor releaseDescriptor,
                                Map<String, Artifact> artifactMap, Set<Artifact> reportArtifacts )
     {
+        Set<Artifact> usedSnapshotReports = new HashSet<>();
         for ( Artifact artifact : reportArtifacts )
         {
-            if ( checkArtifact( artifact, originalVersions, artifactMap, releaseDescriptor ) )
+            if ( checkArtifact( artifact, artifactMap, releaseDescriptor ) )
             {
                 //snapshotDependencies.add( artifact );
                 usedSnapshotReports.add( artifact );
             }
         }
+        return usedSnapshotReports;
     }
 
-    private void checkExtensions( Map<String, String> originalVersions, ReleaseDescriptor releaseDescriptor,
+    private Set<Artifact> checkExtensions( ReleaseDescriptor releaseDescriptor,
                                   Map<String, Artifact> artifactMap, Set<Artifact> extensionArtifacts )
     {
+        Set<Artifact> usedSnapshotExtensions = new HashSet<>();
         for ( Artifact artifact : extensionArtifacts )
         {
-            if ( checkArtifact( artifact, originalVersions, artifactMap, releaseDescriptor ) )
+            if ( checkArtifact( artifact, artifactMap, releaseDescriptor ) )
             {
                 usedSnapshotExtensions.add( artifact );
             }
         }
+        return usedSnapshotExtensions;
     }
 
-    private static boolean checkArtifact( Artifact artifact, Map<String, String> originalVersions,
+    private static boolean checkArtifact( Artifact artifact,
                                           Map<String, Artifact> artifactMapByVersionlessId,
                                           ReleaseDescriptor releaseDescriptor )
     {
         Artifact checkArtifact = getArtifactFromMap( artifact, artifactMapByVersionlessId );
 
-        return checkArtifact( checkArtifact, originalVersions, releaseDescriptor );
+        return checkArtifact( checkArtifact, releaseDescriptor );
     }
 
     private static Artifact getArtifactFromMap( Artifact artifact, Map<String, Artifact> artifactMapByVersionlessId )
@@ -300,16 +302,14 @@
         return checkArtifact;
     }
 
-    private static boolean checkArtifact( Artifact artifact, Map<String, String> originalVersions,
-                                          ReleaseDescriptor releaseDescriptor )
+    private static boolean checkArtifact( Artifact artifact, ReleaseDescriptor releaseDescriptor )
     {
-        String versionlessArtifactKey = ArtifactUtils.versionlessKey( artifact.getGroupId(), artifact.getArtifactId() );
-
+        String versionlessKey = ArtifactUtils.versionlessKey( artifact.getGroupId(), artifact.getArtifactId() );
+        
         // We are only looking at dependencies external to the project - ignore anything found in the reactor as
         // it's version will be updated
-        boolean result =
-            artifact.isSnapshot()
-            && !artifact.getBaseVersion().equals( originalVersions.get( versionlessArtifactKey ) );
+        boolean result = artifact.isSnapshot()
+                && !artifact.getBaseVersion().equals( releaseDescriptor.getProjectOriginalVersion( versionlessKey ) );
 
         // If we have a snapshot but allowTimestampedSnapshots is true, accept the artifact if the version
         // indicates that it is a timestamped snapshot.
@@ -368,8 +368,6 @@
 
             if ( resolveSnapshot.toLowerCase( Locale.ENGLISH ).startsWith( "y" ) )
             {
-                Map<String, Map<String, String>> resolvedSnapshots = null;
-                
                 if ( resolveSnapshotType == null )
                 {
                     prompter.showMessage( RESOLVE_SNAPSHOT_TYPE_MESSAGE );
@@ -381,36 +379,34 @@
                 {
                     // all
                     case 0:
-                        resolvedSnapshots = processSnapshot( projectDependencies );
-                        resolvedSnapshots.putAll( processSnapshot( pluginDependencies ) );
-                        resolvedSnapshots.putAll( processSnapshot( reportDependencies ) );
-                        resolvedSnapshots.putAll( processSnapshot( extensionDependencies ) );
+                        processSnapshot( projectDependencies, releaseDescriptor );
+                        processSnapshot( pluginDependencies, releaseDescriptor );
+                        processSnapshot( reportDependencies, releaseDescriptor );
+                        processSnapshot( extensionDependencies, releaseDescriptor );
                         break;
 
                         // project dependencies
                     case 1:
-                        resolvedSnapshots = processSnapshot( projectDependencies );
+                        processSnapshot( projectDependencies, releaseDescriptor );
                         break;
 
                         // plugins
                     case 2:
-                        resolvedSnapshots = processSnapshot( pluginDependencies );
+                        processSnapshot( pluginDependencies, releaseDescriptor );
                         break;
 
                         // reports
                     case 3:
-                        resolvedSnapshots = processSnapshot( reportDependencies );
+                        processSnapshot( reportDependencies, releaseDescriptor );
                         break;
 
                         // extensions
                     case 4:
-                        resolvedSnapshots = processSnapshot( extensionDependencies );
+                        processSnapshot( extensionDependencies, releaseDescriptor );
                         break;
 
                     default:
                 }
-
-                releaseDescriptor.getResolvedSnapshotDependencies().putAll( resolvedSnapshots );
             }
         }
         catch ( PrompterException | VersionParseException e )
@@ -419,10 +415,9 @@
         }
     }
 
-    private Map<String, Map<String, String>> processSnapshot( Set<Artifact> snapshotSet )
+    private void processSnapshot( Set<Artifact> snapshotSet, ReleaseDescriptor releaseDescriptor )
         throws PrompterException, VersionParseException
     {
-        Map<String, Map<String, String>> resolvedSnapshots = new HashMap<>();
         Iterator<Artifact> iterator = snapshotSet.iterator();
 
         while ( iterator.hasNext() )
@@ -430,15 +425,15 @@
             Artifact currentArtifact = iterator.next();
             String versionlessKey = ArtifactUtils.versionlessKey( currentArtifact );
 
-            Map<String, String> versionMap = new HashMap<>();
             VersionInfo versionInfo = new DefaultVersionInfo( currentArtifact.getBaseVersion() );
-            versionMap.put( ReleaseDescriptor.ORIGINAL_VERSION, versionInfo.toString() );
+            releaseDescriptor.addDependencyOriginalVersion( versionlessKey, versionInfo.toString() );
 
             prompter.showMessage(
                 "Dependency '" + versionlessKey + "' is a snapshot (" + currentArtifact.getVersion() + ")\n" );
             String result = prompter.prompt( "Which release version should it be set to?",
                                              versionInfo.getReleaseVersionString() );
-            versionMap.put( ReleaseDescriptor.RELEASE_KEY, result );
+            
+            releaseDescriptor.addDependencyReleaseVersion( versionlessKey, result );
 
             iterator.remove();
 
@@ -457,11 +452,8 @@
             }
 
             result = prompter.prompt( "What version should the dependency be reset to for development?", nextVersion );
-            versionMap.put( ReleaseDescriptor.DEVELOPMENT_KEY, result );
-
-            resolvedSnapshots.put( versionlessKey, versionMap );
+            
+            releaseDescriptor.addDependencyDevelopmentVersion( versionlessKey, result );
         }
-
-        return resolvedSnapshots;
     }
 }
\ No newline at end of file
diff --git a/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/CheckPomPhase.java b/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/CheckPomPhase.java
index b5066d2..128721f 100644
--- a/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/CheckPomPhase.java
+++ b/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/CheckPomPhase.java
@@ -30,7 +30,6 @@
 import org.apache.maven.shared.release.env.ReleaseEnvironment;
 import org.apache.maven.shared.release.scm.ReleaseScmRepositoryException;
 import org.apache.maven.shared.release.scm.ScmRepositoryConfigurator;
-import org.apache.maven.shared.release.util.ReleaseUtil;
 import org.codehaus.plexus.util.StringUtils;
 
 import java.util.List;
@@ -64,30 +63,14 @@
         ReleaseResult result = new ReleaseResult();
 
         // Currently, we don't deal with multiple SCM locations in a multiproject
-        if ( scmRequired && StringUtils.isEmpty( releaseDescriptor.getScmSourceUrl() ) )
+        if ( scmRequired )
         {
-            MavenProject rootProject = ReleaseUtil.getRootProject( reactorProjects );
-            if ( rootProject != null && rootProject.getScm() != null )
-            {
-                if ( rootProject.getScm().getDeveloperConnection() != null )
-                {
-                    releaseDescriptor.setScmSourceUrl( rootProject.getScm().getDeveloperConnection() );
-                }
-                else if ( rootProject.getScm().getConnection() != null )
-                {
-                    releaseDescriptor.setScmSourceUrl( rootProject.getScm().getConnection() );
-                }
-            }
-
             if ( StringUtils.isEmpty( releaseDescriptor.getScmSourceUrl() ) )
             {
                 throw new ReleaseFailureException(
                     "Missing required setting: scm connection or developerConnection must be specified." );
             }
 
-            // As long as Scm.getId() does not exist, read it as a property
-            releaseDescriptor.setScmId( rootProject.getProperties().getProperty( "project.scm.id" ) );
-
             try
             {
                 scmRepositoryConfigurator.getConfiguredRepository( releaseDescriptor,
diff --git a/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/CheckoutProjectFromScm.java b/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/CheckoutProjectFromScm.java
index eec0f2c..33f9537 100644
--- a/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/CheckoutProjectFromScm.java
+++ b/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/CheckoutProjectFromScm.java
@@ -183,17 +183,10 @@
         }
 
         MavenProject rootProject = ReleaseUtil.getRootProject( reactorProjects );
+
         // TODO: sanity check that it is not . or .. or lower
-        File checkoutDirectory;
-        if ( StringUtils.isEmpty( releaseDescriptor.getCheckoutDirectory() ) )
-        {
-            checkoutDirectory = new File( rootProject.getFile().getParentFile(), "target/checkout" );
-            releaseDescriptor.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
-        }
-        else
-        {
-            checkoutDirectory = new File( releaseDescriptor.getCheckoutDirectory() );
-        }
+        File checkoutDirectory =
+            FileUtils.resolveFile( rootProject.getBasedir(), releaseDescriptor.getCheckoutDirectory() );
 
         if ( checkoutDirectory.exists() )
         {
diff --git a/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/GenerateReleasePomsPhase.java b/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/GenerateReleasePomsPhase.java
index fbb0749..455f9b4 100644
--- a/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/GenerateReleasePomsPhase.java
+++ b/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/GenerateReleasePomsPhase.java
@@ -216,9 +216,6 @@
                                       ReleaseResult result )
         throws ReleaseFailureException, ReleaseExecutionException
     {
-        Map<String, String> originalVersions = getOriginalVersionMap( releaseDescriptor, reactorProjects );
-        Map<String, String> mappedVersions = getNextVersionMap( releaseDescriptor );
-
         MavenProject releaseProject = project.clone();
         Model releaseModel = releaseProject.getModel();
 
@@ -232,7 +229,7 @@
         // update project version
         String projectVersion = releaseModel.getVersion();
         String releaseVersion =
-            getNextVersion( mappedVersions, project.getGroupId(), project.getArtifactId(), projectVersion );
+            getNextVersion( releaseDescriptor, project.getGroupId(), project.getArtifactId(), projectVersion );
         releaseModel.setVersion( releaseVersion );
 
         String originalFinalName = releaseModel.getBuild().getFinalName();
@@ -283,17 +280,17 @@
         }
 
         // rewrite dependencies
-        releaseModel.setDependencies( createReleaseDependencies( originalVersions, mappedVersions, releaseProject ) );
+        releaseModel.setDependencies( createReleaseDependencies( releaseDescriptor, releaseProject ) );
 
         // rewrite plugins
-        releaseModel.getBuild().setPlugins( createReleasePlugins( originalVersions, mappedVersions, releaseProject ) );
+        releaseModel.getBuild().setPlugins( createReleasePlugins( releaseDescriptor, releaseProject ) );
 
         // rewrite reports
-        releaseModel.getReporting().setPlugins( createReleaseReportPlugins( originalVersions, mappedVersions,
+        releaseModel.getReporting().setPlugins( createReleaseReportPlugins( releaseDescriptor, 
                                                                             releaseProject ) );
 
         // rewrite extensions
-        releaseModel.getBuild().setExtensions( createReleaseExtensions( originalVersions, mappedVersions,
+        releaseModel.getBuild().setExtensions( createReleaseExtensions( releaseDescriptor, 
                                                                         releaseProject ) );
 
         unalignFromBaseDirectory( releaseModel, project.getBasedir() );
@@ -419,18 +416,7 @@
         return execute( releaseDescriptor, releaseEnvironment, reactorProjects, true );
     }
 
-    protected Map<String, String> getOriginalVersionMap( ReleaseDescriptor releaseDescriptor,
-                                                         List<MavenProject> reactorProjects )
-    {
-        return releaseDescriptor.getOriginalVersions( reactorProjects );
-    }
-
-    protected Map<String, String> getNextVersionMap( ReleaseDescriptor releaseDescriptor )
-    {
-        return releaseDescriptor.getReleaseVersions();
-    }
-
-    private String getNextVersion( Map<String, String> mappedVersions, String groupId, String artifactId,
+    private String getNextVersion( ReleaseDescriptor releaseDescriptor, String groupId, String artifactId,
                                    String version )
         throws ReleaseFailureException
     {
@@ -438,7 +424,7 @@
 
         String id = ArtifactUtils.versionlessKey( groupId, artifactId );
 
-        String nextVersion = mappedVersions.get( id );
+        String nextVersion = releaseDescriptor.getProjectReleaseVersion( id );
 
         if ( nextVersion == null )
         {
@@ -489,8 +475,8 @@
         return releaseScm;
     }
 
-    private List<Dependency> createReleaseDependencies( Map<String, String> originalVersions,
-                                                        Map<String, String> mappedVersions, MavenProject project )
+    private List<Dependency> createReleaseDependencies( ReleaseDescriptor releaseDescriptor,
+                                                        MavenProject project )
         throws ReleaseFailureException
     {
         Set<Artifact> artifacts = project.getArtifacts();
@@ -513,7 +499,7 @@
                 releaseDependency.setGroupId( artifact.getGroupId() );
                 releaseDependency.setArtifactId( artifact.getArtifactId() );
 
-                String version = getReleaseVersion( originalVersions, mappedVersions, artifact );
+                String version = getReleaseVersion( releaseDescriptor, artifact );
 
                 releaseDependency.setVersion( version );
                 releaseDependency.setType( artifact.getType() );
@@ -527,14 +513,14 @@
         return releaseDependencies;
     }
 
-    private String getReleaseVersion( Map<String, String> originalVersions, Map<String, String> mappedVersions,
+    private String getReleaseVersion( ReleaseDescriptor releaseDescriptor,
                                       Artifact artifact )
         throws ReleaseFailureException
     {
         String key = ArtifactUtils.versionlessKey( artifact );
 
-        String originalVersion = originalVersions.get( key );
-        String mappedVersion = mappedVersions.get( key );
+        String originalVersion = releaseDescriptor.getProjectOriginalVersion( key );
+        String mappedVersion = releaseDescriptor.getProjectReleaseVersion( key );
 
         String version = artifact.getVersion();
 
@@ -560,8 +546,8 @@
         return version;
     }
 
-    private List<Plugin> createReleasePlugins( Map<String, String> originalVersions,
-                                               Map<String, String> mappedVersions, MavenProject project )
+    private List<Plugin> createReleasePlugins( ReleaseDescriptor releaseDescriptor,
+                                               MavenProject project )
         throws ReleaseFailureException
     {
         List<Plugin> releasePlugins = null;
@@ -583,7 +569,7 @@
                 {
                     String id = ArtifactUtils.versionlessKey( plugin.getGroupId(), plugin.getArtifactId() );
                     Artifact artifact = artifactsById.get( id );
-                    String version = getReleaseVersion( originalVersions, mappedVersions, artifact );
+                    String version = getReleaseVersion( releaseDescriptor, artifact );
 
                     Plugin releasePlugin = new Plugin();
                     releasePlugin.setGroupId( plugin.getGroupId() );
@@ -607,8 +593,8 @@
         return releasePlugins;
     }
 
-    private List<ReportPlugin> createReleaseReportPlugins( Map<String, String> originalVersions,
-                                                           Map<String, String> mappedVersions, MavenProject project )
+    private List<ReportPlugin> createReleaseReportPlugins( ReleaseDescriptor releaseDescriptor,
+                                                           MavenProject project )
         throws ReleaseFailureException
     {
         List<ReportPlugin> releaseReportPlugins = null;
@@ -629,7 +615,7 @@
                 {
                     String id = ArtifactUtils.versionlessKey( reportPlugin.getGroupId(), reportPlugin.getArtifactId() );
                     Artifact artifact = artifactsById.get( id );
-                    String version = getReleaseVersion( originalVersions, mappedVersions, artifact );
+                    String version = getReleaseVersion( releaseDescriptor, artifact );
 
                     ReportPlugin releaseReportPlugin = new ReportPlugin();
                     releaseReportPlugin.setGroupId( reportPlugin.getGroupId() );
@@ -647,8 +633,8 @@
         return releaseReportPlugins;
     }
 
-    private List<Extension> createReleaseExtensions( Map<String, String> originalVersions,
-                                                     Map<String, String> mappedVersions, MavenProject project )
+    private List<Extension> createReleaseExtensions( ReleaseDescriptor releaseDescriptor,
+                                                     MavenProject project )
         throws ReleaseFailureException
     {
         List<Extension> releaseExtensions = null;
@@ -668,7 +654,7 @@
                 {
                     String id = ArtifactUtils.versionlessKey( extension.getGroupId(), extension.getArtifactId() );
                     Artifact artifact = project.getExtensionArtifactMap().get( id );
-                    String version = getReleaseVersion( originalVersions, mappedVersions, artifact );
+                    String version = getReleaseVersion( releaseDescriptor, artifact );
 
                     Extension releaseExtension = new Extension();
                     releaseExtension.setGroupId( extension.getGroupId() );
diff --git a/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/InputVariablesPhase.java b/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/InputVariablesPhase.java
index 985b9cf..c155e3c 100644
--- a/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/InputVariablesPhase.java
+++ b/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/InputVariablesPhase.java
@@ -134,7 +134,7 @@
         {
             // Must get default version from mapped versions, as the project will be the incorrect snapshot
             String key = ArtifactUtils.versionlessKey( project.getGroupId(), project.getArtifactId() );
-            String releaseVersion = releaseDescriptor.getReleaseVersions().get( key );
+            String releaseVersion = releaseDescriptor.getProjectReleaseVersion( key );
             if ( releaseVersion == null )
             {
                 throw new ReleaseExecutionException( "Project tag cannot be selected if version is not yet mapped" );
diff --git a/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/MapVersionsPhase.java b/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/MapVersionsPhase.java
index eedf50a..1b585ab 100644
--- a/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/MapVersionsPhase.java
+++ b/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/MapVersionsPhase.java
@@ -121,16 +121,16 @@
             {
                 if ( releaseDescriptor.isBranchCreation() && convertToBranch )
                 {
-                    releaseDescriptor.mapReleaseVersion( projectId, nextVersion );
+                    releaseDescriptor.addReleaseVersion( projectId, nextVersion );
                 }
                 else
                 {
-                    releaseDescriptor.mapDevelopmentVersion( projectId, nextVersion );
+                    releaseDescriptor.addDevelopmentVersion( projectId, nextVersion );
                 }
             }
             else
             {
-                releaseDescriptor.mapReleaseVersion( projectId, nextVersion );
+                releaseDescriptor.addReleaseVersion( projectId, nextVersion );
             }
 
             for ( MavenProject subProject : reactorProjects )
@@ -152,16 +152,16 @@
 
                     if ( releaseDescriptor.isBranchCreation() && convertToBranch )
                     {
-                        releaseDescriptor.mapReleaseVersion( subProjectId, v );
+                        releaseDescriptor.addReleaseVersion( subProjectId, v );
                     }
                     else
                     {
-                        releaseDescriptor.mapDevelopmentVersion( subProjectId, v );
+                        releaseDescriptor.addDevelopmentVersion( subProjectId, v );
                     }
                 }
                 else
                 {
-                    releaseDescriptor.mapReleaseVersion( subProjectId, nextVersion );
+                    releaseDescriptor.addReleaseVersion( subProjectId, nextVersion );
                 }
             }
         }
@@ -177,16 +177,16 @@
                 {
                     if ( releaseDescriptor.isBranchCreation() && convertToBranch )
                     {
-                        releaseDescriptor.mapReleaseVersion( projectId, nextVersion );
+                        releaseDescriptor.addReleaseVersion( projectId, nextVersion );
                     }
                     else
                     {
-                        releaseDescriptor.mapDevelopmentVersion( projectId, nextVersion );
+                        releaseDescriptor.addDevelopmentVersion( projectId, nextVersion );
                     }
                 }
                 else
                 {
-                    releaseDescriptor.mapReleaseVersion( projectId, nextVersion );
+                    releaseDescriptor.addReleaseVersion( projectId, nextVersion );
                 }
             }
         }
@@ -333,7 +333,7 @@
         String defaultVersion = releaseDescriptor.getDefaultDevelopmentVersion();
         if ( StringUtils.isEmpty( defaultVersion ) )
         {
-            defaultVersion = releaseDescriptor.getDevelopmentVersions().get( projectId );
+            defaultVersion = releaseDescriptor.getProjectDevelopmentVersion( projectId );
         }
         return defaultVersion;
     }
@@ -343,7 +343,7 @@
         String nextVersion = releaseDescriptor.getDefaultReleaseVersion();
         if ( StringUtils.isEmpty( nextVersion ) )
         {
-            nextVersion = releaseDescriptor.getReleaseVersions().get( projectId );
+            nextVersion = releaseDescriptor.getProjectReleaseVersion( projectId );
         }
         return nextVersion;
     }
diff --git a/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/RewritePomVersionsPhase.java b/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/RewritePomVersionsPhase.java
index 2ed4376..0ef834e 100644
--- a/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/RewritePomVersionsPhase.java
+++ b/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/RewritePomVersionsPhase.java
@@ -19,9 +19,6 @@
  * under the License.
  */
 
-import java.util.List;
-import java.util.Map;
-
 import org.apache.maven.model.Model;
 import org.apache.maven.project.MavenProject;
 import org.apache.maven.scm.repository.ScmRepository;
@@ -61,21 +58,20 @@
     }
 
     @Override
-    protected Map<String, String> getOriginalVersionMap( ReleaseDescriptor releaseDescriptor,
-                                                         List<MavenProject> reactorProjects, boolean simulate )
+    protected String getOriginalVersion( ReleaseDescriptor releaseDescriptor, String projectKey, boolean simulate )
     {
-        return releaseDescriptor.getOriginalVersions( reactorProjects );
+        return releaseDescriptor.getProjectOriginalVersion( projectKey );
     }
 
     @Override
-    protected Map<String, String> getNextVersionMap( ReleaseDescriptor releaseDescriptor )
+    protected String getNextVersion( ReleaseDescriptor releaseDescriptor, String key )
     {
-        return releaseDescriptor.getDevelopmentVersions();
+        return releaseDescriptor.getProjectDevelopmentVersion( key );
     }
 
     @Override
     protected String getResolvedSnapshotVersion( String artifactVersionlessKey,
-                                                 Map<String, Map<String, String>> resolvedSnapshotsMap )
+                                                 ReleaseDescriptor resolvedSnapshotsMap )
     {
         // Only update the pom version, not the dependency versions
         return null;
diff --git a/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/RewritePomsForBranchPhase.java b/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/RewritePomsForBranchPhase.java
index 1907e6a..586e97d 100644
--- a/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/RewritePomsForBranchPhase.java
+++ b/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/RewritePomsForBranchPhase.java
@@ -20,8 +20,6 @@
  */
 
 import java.io.IOException;
-import java.util.List;
-import java.util.Map;
 
 import org.apache.maven.artifact.ArtifactUtils;
 import org.apache.maven.model.Model;
@@ -64,9 +62,6 @@
 
             if ( scmRoot != null )
             {
-                Scm scm = buildScm( project );
-                releaseDescriptor.mapOriginalScmInfo( projectId, scm );
-
                 try
                 {
                     translateScm( project, releaseDescriptor, scmRoot, scmRepository, result, commonBasedir );
@@ -78,15 +73,13 @@
             }
             else
             {
-                releaseDescriptor.mapOriginalScmInfo( projectId, null );
-
                 MavenProject parent = project.getParent();
                 if ( parent != null )
                 {
                     // If the SCM element is not present, only add it if the parent was not mapped (ie, it's external to
                     // the release process and so has not been modified, so the values will not be correct on the tag),
                     String parentId = ArtifactUtils.versionlessKey( parent.getGroupId(), parent.getArtifactId() );
-                    if ( !releaseDescriptor.getOriginalScmInfo().containsKey( parentId ) )
+                    if ( releaseDescriptor.getOriginalScmInfo( parentId ) == null )
                     {
                         // we need to add it, since it has changed from the inherited value
                         scmRoot = new Scm();
@@ -244,31 +237,21 @@
     }
 
     @Override
-    protected Map<String, String> getOriginalVersionMap( ReleaseDescriptor releaseDescriptor,
-                                                         List<MavenProject> reactorProjects, boolean simulate )
+    protected String getOriginalVersion( ReleaseDescriptor releaseDescriptor, String projectKey, boolean simulate )
     {
-        return releaseDescriptor.getOriginalVersions( reactorProjects );
+        return releaseDescriptor.getProjectOriginalVersion( projectKey );
     }
 
     @Override
-    protected Map<String, String> getNextVersionMap( ReleaseDescriptor releaseDescriptor )
+    protected String getNextVersion( ReleaseDescriptor releaseDescriptor, String key )
     {
-        return releaseDescriptor.getReleaseVersions();
+        return releaseDescriptor.getProjectReleaseVersion( key );
     }
 
     @Override
     protected String getResolvedSnapshotVersion( String artifactVersionlessKey,
-                                                 Map<String, Map<String, String>> resolvedSnapshotsMap )
+                                                 ReleaseDescriptor releaseDescriptor )
     {
-        Map<String, String> versionsMap = resolvedSnapshotsMap.get( artifactVersionlessKey );
-
-        if ( versionsMap != null )
-        {
-            return versionsMap.get( ReleaseDescriptor.RELEASE_KEY );
-        }
-        else
-        {
-            return null;
-        }
+        return releaseDescriptor.getDependencyReleaseVersion( artifactVersionlessKey );
     }
 }
diff --git a/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/RewritePomsForDevelopmentPhase.java b/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/RewritePomsForDevelopmentPhase.java
index 01bd7ef..cb65866 100644
--- a/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/RewritePomsForDevelopmentPhase.java
+++ b/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/RewritePomsForDevelopmentPhase.java
@@ -19,9 +19,6 @@
  * under the License.
  */
 
-import java.util.List;
-import java.util.Map;
-
 import org.apache.maven.model.Model;
 import org.apache.maven.model.Scm;
 import org.apache.maven.project.MavenProject;
@@ -59,9 +56,8 @@
             Scm scmRoot = modelTarget.getScm();
             if ( scmRoot != null )
             {
-                Map<String, Scm> originalScmInfo = releaseDescriptor.getOriginalScmInfo();
                 // check containsKey, not == null, as we store null as a value
-                if ( !originalScmInfo.containsKey( projectId ) )
+                if ( releaseDescriptor.getOriginalScmInfo( projectId ) == null )
                 {
                     throw new ReleaseExecutionException(
                         "Unable to find original SCM info for '" + project.getName() + "'" );
@@ -70,7 +66,7 @@
                 ScmTranslator translator = getScmTranslators().get( scmRepository.getProvider() );
                 if ( translator != null )
                 {
-                    Scm scm = originalScmInfo.get( projectId );
+                    Scm scm = releaseDescriptor.getOriginalScmInfo( projectId );
 
                     if ( scm != null )
                     {
@@ -96,33 +92,23 @@
     }
 
     @Override
-    protected Map<String, String> getOriginalVersionMap( ReleaseDescriptor releaseDescriptor,
-                                                         List<MavenProject> reactorProjects, boolean simulate )
+    protected String getOriginalVersion( ReleaseDescriptor releaseDescriptor, String projectKey, boolean simulate )
     {
         return simulate
-            ? releaseDescriptor.getOriginalVersions( reactorProjects )
-            : releaseDescriptor.getReleaseVersions();
+                        ? releaseDescriptor.getProjectOriginalVersion( projectKey )
+                        : releaseDescriptor.getProjectReleaseVersion( projectKey );
     }
 
     @Override
-    protected Map<String, String> getNextVersionMap( ReleaseDescriptor releaseDescriptor )
+    protected String getNextVersion( ReleaseDescriptor releaseDescriptor, String key )
     {
-        return releaseDescriptor.getDevelopmentVersions();
+        return releaseDescriptor.getProjectDevelopmentVersion( key );
     }
 
     @Override
     protected String getResolvedSnapshotVersion( String artifactVersionlessKey,
-                                                 Map<String, Map<String, String>> resolvedSnapshotsMap )
+                                                 ReleaseDescriptor releaseDescriptor )
     {
-        Map<String, String> versionsMap = resolvedSnapshotsMap.get( artifactVersionlessKey );
-
-        if ( versionsMap != null )
-        {
-            return versionsMap.get( ReleaseDescriptor.DEVELOPMENT_KEY );
-        }
-        else
-        {
-            return null;
-        }
+        return releaseDescriptor.getDependencyDevelopmentVersion( artifactVersionlessKey );
     }
 }
diff --git a/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/RewritePomsForReleasePhase.java b/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/RewritePomsForReleasePhase.java
index 6e2b47e..dc774a1 100644
--- a/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/RewritePomsForReleasePhase.java
+++ b/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/RewritePomsForReleasePhase.java
@@ -20,8 +20,6 @@
  */
 
 import java.io.IOException;
-import java.util.List;
-import java.util.Map;
 
 import org.apache.maven.artifact.ArtifactUtils;
 import org.apache.maven.model.Model;
@@ -62,9 +60,6 @@
             Scm scmRoot = modelTarget.getScm();
             if ( scmRoot != null )
             {
-                Scm scm = buildScm( project );
-                releaseDescriptor.mapOriginalScmInfo( projectId, scm );
-
                 try
                 {
                     translateScm( project, releaseDescriptor, scmRoot, scmRepository, result, commonBasedir );
@@ -76,15 +71,13 @@
             }
             else
             {
-                releaseDescriptor.mapOriginalScmInfo( projectId, null );
-
                 MavenProject parent = project.getParent();
                 if ( parent != null )
                 {
                     // If the SCM element is not present, only add it if the parent was not mapped (ie, it's external to
                     // the release process and so has not been modified, so the values will not be correct on the tag),
                     String parentId = ArtifactUtils.versionlessKey( parent.getGroupId(), parent.getArtifactId() );
-                    if ( !releaseDescriptor.getOriginalScmInfo().containsKey( parentId ) )
+                    if ( releaseDescriptor.getOriginalScmInfo( parentId ) == null )
                     {
                         // we need to add it, since it has changed from the inherited value
                         Scm scmTarget = new Scm();
@@ -238,31 +231,21 @@
     }
 
     @Override
-    protected Map<String, String> getOriginalVersionMap( ReleaseDescriptor releaseDescriptor,
-                                                         List<MavenProject> reactorProjects, boolean simulate )
+    protected String getOriginalVersion( ReleaseDescriptor releaseDescriptor, String projectKey, boolean simulate )
     {
-        return releaseDescriptor.getOriginalVersions( reactorProjects );
+        return releaseDescriptor.getProjectOriginalVersion( projectKey );
     }
 
     @Override
-    protected Map<String, String> getNextVersionMap( ReleaseDescriptor releaseDescriptor )
+    protected String getNextVersion( ReleaseDescriptor releaseDescriptor, String key )
     {
-        return releaseDescriptor.getReleaseVersions();
+        return releaseDescriptor.getProjectReleaseVersion( key );
     }
 
     @Override
     protected String getResolvedSnapshotVersion( String artifactVersionlessKey,
-                                                 Map<String, Map<String, String>> resolvedSnapshotsMap )
+                                                 ReleaseDescriptor releaseDescriptor )
     {
-        Map<String, String> versionsMap = resolvedSnapshotsMap.get( artifactVersionlessKey );
-
-        if ( versionsMap != null )
-        {
-            return versionsMap.get( ReleaseDescriptor.RELEASE_KEY );
-        }
-        else
-        {
-            return null;
-        }
+        return releaseDescriptor.getDependencyReleaseVersion( artifactVersionlessKey );
     }
 }
diff --git a/maven-release-manager/src/main/java/org/apache/maven/shared/release/util/ReleaseUtil.java b/maven-release-manager/src/main/java/org/apache/maven/shared/release/util/ReleaseUtil.java
index ea76dba..00f2c1e 100644
--- a/maven-release-manager/src/main/java/org/apache/maven/shared/release/util/ReleaseUtil.java
+++ b/maven-release-manager/src/main/java/org/apache/maven/shared/release/util/ReleaseUtil.java
@@ -34,6 +34,8 @@
 import org.apache.maven.project.MavenProject;
 import org.apache.maven.shared.release.ReleaseExecutionException;
 import org.apache.maven.shared.release.config.ReleaseDescriptor;
+import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder;
+import org.apache.maven.shared.release.config.ReleaseUtils;
 import org.codehaus.plexus.interpolation.InterpolationException;
 import org.codehaus.plexus.interpolation.MapBasedValueSource;
 import org.codehaus.plexus.interpolation.ObjectBasedValueSource;
@@ -188,10 +190,10 @@
         String url = releaseDescriptor.getScmSourceUrl();
         url = realignScmUrl( parentLevels, url );
 
-        ReleaseDescriptor descriptor = new ReleaseDescriptor();
-        descriptor.setWorkingDirectory( basedir );
-        descriptor.setScmSourceUrl( url );
-        return descriptor;
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setWorkingDirectory( basedir );
+        builder.setScmSourceUrl( url );
+        return ReleaseUtils.buildReleaseDescriptor( builder );
     }
 
     public static String getCommonBasedir( List<MavenProject> reactorProjects )
diff --git a/maven-release-manager/src/main/mdo/release-descriptor.mdo b/maven-release-manager/src/main/mdo/release-descriptor.mdo
index 6191087..4123d12 100644
--- a/maven-release-manager/src/main/mdo/release-descriptor.mdo
+++ b/maven-release-manager/src/main/mdo/release-descriptor.mdo
@@ -37,7 +37,7 @@
   </defaults>
   <classes>
     <class rootElement="true">
-      <name>ReleaseDescriptor</name>
+      <name>ModelloReleaseDescriptor</name>
       <version>1.0.0+</version>
       <fields>
         <!-- Descriptive Information -->
@@ -241,6 +241,7 @@
           <name>checkoutDirectory</name>
           <version>1.0.0+</version>
           <type>String</type>
+          <defaultValue>target/checkout</defaultValue>
           <description>
             The directory where the tag will be checked out.
           </description>
@@ -534,71 +535,50 @@
         <codeSegment>
           <version>2.1.0+</version>
           <code><![CDATA[
-    public static final String DEVELOPMENT_KEY = "dev";
-
-    public static final String RELEASE_KEY = "rel";
-
-    public static final String ORIGINAL_VERSION = "original";
-
     /**
      * Field resolvedSnapshotDependencies.
      */
-    private java.util.Map<String, java.util.Map<String, String>> resolvedSnapshotDependencies;
+    private java.util.Map<String, ReleaseStageVersions> resolvedSnapshotDependencies = new java.util.HashMap<>();
 
     /**
-     * Field releaseVersions.
+     * Field projectVersions
      */
-    private java.util.Map<String, String> releaseVersions;
-
-    /**
-     * Field developmentVersions.
-     */
-    private java.util.Map<String, String> developmentVersions;
+    private java.util.Map<String, ReleaseStageVersions> projectVersions = new java.util.HashMap<>();
     
     /**
      * Field originalScmInfo.
      */
-    private java.util.Map<String, org.apache.maven.model.Scm> originalScmInfo;
+    private java.util.Map<String, org.apache.maven.model.Scm> originalScmInfo = new java.util.HashMap<>();
+    
+    
+    java.util.Map<String, ReleaseStageVersions> getProjectVersions()
+    {
+        return projectVersions;
+    }
+    
+    java.util.Map<String, org.apache.maven.model.Scm> getOriginalScmInfo()
+    {
+        return originalScmInfo;
+    }
     
     /**
      * Method getResolvedSnapshotDependencies.
      * 
      * @return Map
      */
-    public java.util.Map<String, java.util.Map<String, String>> getResolvedSnapshotDependencies()
+    java.util.Map<String, ReleaseStageVersions> getResolvedSnapshotDependencies()
     {
-        if ( this.resolvedSnapshotDependencies == null )
-        {
-            this.resolvedSnapshotDependencies = new java.util.HashMap<>();
-        }
-
         return this.resolvedSnapshotDependencies;
-    } //-- java.util.Map<String, java.util.Map<String, String>> getResolvedSnapshotDependencies()
-    
-    /**
-     * Set a map of resolved snapshot dependencies versions.
-     * 
-     * @param resolvedSnapshotDependencies
-     */
-    public void setResolvedSnapshotDependencies( java.util.Map<String, java.util.Map<String, String>> resolvedSnapshotDependencies )
-    {
-        this.resolvedSnapshotDependencies = resolvedSnapshotDependencies;
-    } //-- void setResolvedSnapshotDependencies( java.util.Map<String, java.util.Map<String, String>> )
+    } //-- java.util.Map<String, ReleaseStageVersions> getResolvedSnapshotDependencies()
 
-    /**
-     * Method getReleaseVersions.
-     * 
-     * @return Map
-     */
-    public java.util.Map<String, String> getReleaseVersions()
+    public String getProjectReleaseVersion( String projectId )
     {
-        if ( this.releaseVersions == null )
-        {
-            this.releaseVersions = new java.util.HashMap<>();
-        }
-
-        return this.releaseVersions;
-    } //-- java.util.Map<String, String> getReleaseVersions()
+      if ( projectVersions.containsKey( projectId ) )
+      {
+        return projectVersions.get( projectId ).getRelease();
+      }
+      return null;
+    }
 
     /**
      * Method addReleaseVersion.
@@ -606,25 +586,19 @@
      * @param key
      * @param value
      */
-    public void addReleaseVersion( String key, String value )
+    public void addReleaseVersion( String projectId, String version )
     {
-        getReleaseVersions().put( key, value );
+        computeIfAbsent( projectVersions, projectId ).setRelease( version ); 
     } //-- void addReleaseVersion( String, String )
 
-    /**
-     * Method getDevelopmentVersions.
-     * 
-     * @return Map
-     */
-    public java.util.Map<String, String> getDevelopmentVersions()
+    public String getProjectDevelopmentVersion( String projectId )
     {
-        if ( this.developmentVersions == null )
-        {
-            this.developmentVersions = new java.util.HashMap<>();
-        }
-
-        return this.developmentVersions;
-    } //-- java.util.Map<String, String> getDevelopmentVersions()
+      if ( projectVersions.containsKey( projectId ) )
+      {
+        return projectVersions.get( projectId ).getDevelopment();
+      }
+      return null;
+    }
 
     /**
      * Method addDevelopmentVersion.
@@ -632,9 +606,9 @@
      * @param key
      * @param value
      */
-    public void addDevelopmentVersion( String key, String value )
+    public void addDevelopmentVersion( String projectId, String version )
     {
-        getDevelopmentVersions().put( key, value );
+        computeIfAbsent( projectVersions, projectId ).setDevelopment( version ); 
     } //-- void addDevelopmentVersion( String, String )
 
     /**
@@ -642,14 +616,9 @@
      * 
      * @return Map
      */
-    public java.util.Map<String, org.apache.maven.model.Scm> getOriginalScmInfo()
+    public org.apache.maven.model.Scm getOriginalScmInfo( String id )
     {
-        if ( this.originalScmInfo == null )
-        {
-            this.originalScmInfo = new java.util.HashMap<>();
-        }
-
-        return this.originalScmInfo;
+        return this.originalScmInfo.get( id );
     } //-- java.util.Map<Object, String> getOriginalScmInfo()
     
     /**
@@ -663,104 +632,18 @@
         getOriginalScmInfo().put( key, value );
     } //-- void addOriginalScmInfo( String, org.apache.maven.model.Scm )
 
-    /**
-     * Map a given snapshot dependency to a specified version from when it is released.
-     *
-     */
-    public void mapResolvedSnapshotDependencies( String artifactName, String releaseVersion, String developmentVersion )
+    public String getProjectOriginalVersion( String projectId )
     {
-        if ( resolvedSnapshotDependencies == null )
-        {
-            resolvedSnapshotDependencies = new java.util.HashMap<>();
-        }
-        else
-        {
-            assert !resolvedSnapshotDependencies.containsKey( artifactName );
-        }
-
-        java.util.Map versionsMap = new java.util.HashMap<>();
-
-        versionsMap.put( DEVELOPMENT_KEY, developmentVersion );
-        versionsMap.put( RELEASE_KEY, releaseVersion );
-        resolvedSnapshotDependencies.put( artifactName, versionsMap );
+      if ( projectVersions.containsKey( projectId ) )
+      {
+        return projectVersions.get( projectId ).getOriginal();
+      }
+      return null;
     }
-
-    /**
-     * Map a given project to a specified version from when it is released.
-     *
-     * @param projectId   the project's group and artifact ID
-     * @param nextVersion the version to map to
-     */
-    public void mapReleaseVersion( String projectId, String nextVersion )
+    
+    public void addOriginalVersion( String projectId, String version )
     {
-        if ( releaseVersions == null )
-        {
-            releaseVersions = new java.util.HashMap<>();
-        }
-
-        releaseVersions.put( projectId, nextVersion );
-    }
-
-    /**
-     * Map a given project to a specified version from when it is incremented and placed back into development.
-     *
-     * @param projectId   the project's group and artifact ID
-     * @param nextVersion the version to map to
-     */
-    public void mapDevelopmentVersion( String projectId, String nextVersion )
-    {
-        if ( developmentVersions == null )
-        {
-            developmentVersions = new java.util.HashMap<>();
-        }
-
-        developmentVersions.put( projectId, nextVersion );
-    }
-
-    /**
-     * Map a given project to a specified set of SCM information.
-     *
-     * @param projectId the project's group and artifact ID
-     * @param scm       the original SCM information to store
-     */
-    public void mapOriginalScmInfo( String projectId, org.apache.maven.model.Scm scm )
-    {
-        if ( originalScmInfo == null )
-        {
-            originalScmInfo = new java.util.HashMap<>();
-        }
-        else
-        {
-            assert !originalScmInfo.containsKey( projectId );
-        }
-
-        originalScmInfo.put( projectId, scm );
-    }
-
-    /**
-     * A map of projects to original versions before any transformation.
-     */
-    private java.util.Map originalVersions;
-
-    /**
-     * Retrieve the original version map, before transformation, keyed by project's versionless identifier.
-     *
-     * @param reactorProjects The reactor projects.
-     *
-     * @return the map of project IDs to versions.
-     */
-    public synchronized java.util.Map<String, String> getOriginalVersions( java.util.List<org.apache.maven.project.MavenProject> reactorProjects )
-    {
-        if ( originalVersions == null )
-        {
-            originalVersions = new java.util.HashMap<>();
-            for ( org.apache.maven.project.MavenProject project : reactorProjects )
-            {
-                originalVersions.put( org.apache.maven.artifact.ArtifactUtils.versionlessKey( project.getGroupId(),
-                                      project.getArtifactId() ), project.getVersion() );
-            }
-        }
-        return originalVersions;
+      computeIfAbsent( projectVersions, projectId ).setOriginal( version ); 
     }
 
     /**
@@ -769,10 +652,10 @@
      */
     public String getDependencyDevelopmentVersion( String artifactConflictId )
     {
-        if ( ( resolvedSnapshotDependencies == null ) && ( resolvedSnapshotDependencies.containsKey( artifactConflictId ) ) )
+        if ( resolvedSnapshotDependencies.containsKey( artifactConflictId ) )
         {
-            java.util.Map<String, String> versionMap = resolvedSnapshotDependencies.get( artifactConflictId );
-            return versionMap.get( DEVELOPMENT_KEY );
+            ReleaseStageVersions versionMap = resolvedSnapshotDependencies.get( artifactConflictId );
+            return versionMap.getDevelopment();
         }
         return null;
     }
@@ -783,19 +666,55 @@
      */
     public String getDependencyReleaseVersion( String artifactConflictId )
     {
-        if ( ( resolvedSnapshotDependencies == null ) && ( resolvedSnapshotDependencies.containsKey( artifactConflictId ) ) )
+        if ( resolvedSnapshotDependencies.containsKey( artifactConflictId ) )
         {
-            java.util.Map<String, String> versionMap = resolvedSnapshotDependencies.get( artifactConflictId );
-            return versionMap.get( RELEASE_KEY );
+            ReleaseStageVersions versionMap = resolvedSnapshotDependencies.get( artifactConflictId );
+            return versionMap.getRelease();
         }
         return null;
     }
 
-    boolean safeEquals( String a, String b )
+    /**
+     * Retrieve the original version for the resolved snapshot dependency.
+     *
+     */
+    public String getDependencyOriginalVersion( String artifactConflictId )
     {
-        return a != null ? a.equals( b ) : b == null;
+        if ( resolvedSnapshotDependencies.containsKey( artifactConflictId ) )
+        {
+            ReleaseStageVersions versionMap = resolvedSnapshotDependencies.get( artifactConflictId );
+            return versionMap.getOriginal();
+        }
+        return null;
+    }
+    
+    public void addDependencyOriginalVersion( String dependencyKey, String version )
+    {
+        computeIfAbsent( resolvedSnapshotDependencies, dependencyKey ).setOriginal( version );
     }
 
+    public void addDependencyReleaseVersion( String dependencyKey, String version )
+    {
+        computeIfAbsent( resolvedSnapshotDependencies, dependencyKey ).setRelease( version );
+    }
+
+    public void addDependencyDevelopmentVersion( String dependencyKey, String version )
+    {
+        computeIfAbsent( resolvedSnapshotDependencies, dependencyKey ).setDevelopment( version );
+    }
+    
+    private static ReleaseStageVersions computeIfAbsent( java.util.Map<String, ReleaseStageVersions> map, String key )
+    {
+        ReleaseStageVersions value = map.get( key );
+        if ( value == null )
+        {
+            value = new ReleaseStageVersions();
+            map.put( key, value );
+        }
+        return value;
+    }
+
+    @Override
     public boolean equals( Object obj )
     {
         if ( this == obj )
@@ -807,165 +726,148 @@
             return false;
         }
 
-        ReleaseDescriptor that = (ReleaseDescriptor) obj;
+        ModelloReleaseDescriptor that = (ModelloReleaseDescriptor) obj;
 
-        if ( updateDependencies        != that.updateDependencies       ||
-             useReleaseProfile         != that.useReleaseProfile        ||
-             autoVersionSubmodules     != that.autoVersionSubmodules    ||
-             snapshotReleasePluginAllowed != that.snapshotReleasePluginAllowed ||
-             commitByProject           != that.commitByProject          ||
-             branchCreation            != that.branchCreation           ||
-             updateBranchVersions      != that.updateBranchVersions     ||
-             updateWorkingCopyVersions != that.updateWorkingCopyVersions||
-             suppressCommitBeforeTagOrBranch   != that.suppressCommitBeforeTagOrBranch  ||
-             updateVersionsToSnapshot  != that.updateVersionsToSnapshot ||
-             allowTimestampedSnapshots != that.allowTimestampedSnapshots||
-             remoteTagging             != that.remoteTagging            ||
-             localCheckout             != that.localCheckout            ||
-             pushChanges               != that.pushChanges
+        if ( updateDependencies               != that.isUpdateDependencies()               ||
+             useReleaseProfile                != that.isUseReleaseProfile()                ||
+             autoVersionSubmodules            != that.isAutoVersionSubmodules()            ||
+             snapshotReleasePluginAllowed     != that.isSnapshotReleasePluginAllowed()     ||
+             commitByProject                  != that.isCommitByProject()                  ||
+             branchCreation                   != that.isBranchCreation()                   ||
+             updateBranchVersions             != that.isUpdateBranchVersions()             ||
+             updateWorkingCopyVersions        != that.isUpdateWorkingCopyVersions()        ||
+             suppressCommitBeforeTagOrBranch  != that.isSuppressCommitBeforeTagOrBranch()  ||
+             updateVersionsToSnapshot         != that.isUpdateVersionsToSnapshot()         ||
+             allowTimestampedSnapshots        != that.isAllowTimestampedSnapshots()        ||
+             remoteTagging                    != that.isRemoteTagging()                    ||
+             localCheckout                    != that.isLocalCheckout()                    ||
+             pushChanges                      != that.isPushChanges()
            )
            {
                return false;
            }
 
-        if ( !safeEquals( defaultDevelopmentVersion, that.defaultDevelopmentVersion ) ||
-             !safeEquals( scmRelativePathProjectDirectory, that.scmRelativePathProjectDirectory ) ||
-             !safeEquals( checkoutDirectory, that.checkoutDirectory ) ||
-             !safeEquals( performGoals, that.performGoals ) ||
-             !safeEquals( defaultReleaseVersion, that.defaultReleaseVersion ) ||
-             !safeEquals( scmReleasedPomRevision, that.scmReleasedPomRevision )
+        if ( !java.util.Objects.equals( defaultDevelopmentVersion, that.getDefaultDevelopmentVersion() ) ||
+             !java.util.Objects.equals( scmRelativePathProjectDirectory, that.getScmRelativePathProjectDirectory() ) ||
+             !java.util.Objects.equals( checkoutDirectory, that.getCheckoutDirectory() ) ||
+             !java.util.Objects.equals( performGoals, that.getPerformGoals() ) ||
+             !java.util.Objects.equals( defaultReleaseVersion, that.getDefaultReleaseVersion() ) ||
+             !java.util.Objects.equals( scmReleasedPomRevision, that.getScmReleasedPomRevision() )
            )
         {
             return false;
         }
 
-        if ( addSchema != that.addSchema )
+        if ( addSchema != that.isAddSchema() )
         {
             return false;
         }
-        if ( generateReleasePoms != that.generateReleasePoms )
+        if ( generateReleasePoms != that.isGenerateReleasePoms() )
         {
             return false;
         }
-        if ( interactive != that.interactive )
+        if ( interactive != that.isInteractive() )
         {
             return false;
         }
-        if ( scmUseEditMode != that.scmUseEditMode )
+        if ( scmUseEditMode != that.isScmUseEditMode() )
         {
             return false;
         }
-        if ( !safeEquals( completedPhase, that.completedPhase ) )
+        if ( !java.util.Objects.equals( completedPhase, that.getCompletedPhase() ) )
         {
             return false;
         }
         if ( ( checkModificationExcludes == null || ( checkModificationExcludes != null && checkModificationExcludes.size() == 0) ) &&
-            ( that.checkModificationExcludes == null || ( that.checkModificationExcludes != null && that.checkModificationExcludes.size() == 0) ) )
+            ( that.getCheckModificationExcludes() == null || ( that.getCheckModificationExcludes() != null && that.getCheckModificationExcludes().size() == 0) ) )
         {
             // Do nothing.  This is a Modello workaround
         }
         else
         {
-            if ( checkModificationExcludes != null ? !checkModificationExcludes.equals( that.checkModificationExcludes )
-                : that.checkModificationExcludes != null )
-            {
-                return false;
-            }
-        }
-        if ( ( developmentVersions == null || ( developmentVersions != null && developmentVersions.size() == 0) ) &&
-            ( that.developmentVersions == null || ( that.developmentVersions != null && that.developmentVersions.size() == 0) ) )
-        {
-            // Do nothing.  This is a Modello workaround
-        }
-        else
-        {
-            if ( developmentVersions != null ? !developmentVersions.equals( that.developmentVersions )
-                : that.developmentVersions != null )
+            if ( checkModificationExcludes != null ? !checkModificationExcludes.equals( that.getCheckModificationExcludes() )
+                : that.getCheckModificationExcludes() != null )
             {
                 return false;
             }
         }
         if ( ( originalScmInfo == null || (originalScmInfo != null && originalScmInfo.size() == 0 ) ) &&
-            ( that.originalScmInfo == null || ( that.originalScmInfo != null && that.originalScmInfo.size() == 0 ) ) )
+            ( that.getOriginalScmInfo() == null || ( that.getOriginalScmInfo() != null && that.getOriginalScmInfo().size() == 0 ) ) )
         {
             // Do nothing.  This is a Modello workaround
         }
         else
         {
-            if ( originalScmInfo != null ? !compareScmCollections( that.originalScmInfo ) : that.originalScmInfo != null )
+            if ( originalScmInfo != null ? !compareScmCollections( that.getOriginalScmInfo() ) : that.getOriginalScmInfo() != null )
             {
                 return false;
             }
         }
-        if ( ( releaseVersions == null || ( releaseVersions != null && releaseVersions.size() == 0 ) ) &&
-            ( that.releaseVersions == null || ( that.releaseVersions != null && that.releaseVersions.size() == 0 ) ) )
-        {
-            // Do nothing.  This is a Modello workaround
-        }
-        else
-        {
-            if ( releaseVersions != null ? !releaseVersions.equals( that.releaseVersions ) : that.releaseVersions != null )
-            {
-                return false;
-            }
-        }
-        if ( !safeEquals( additionalArguments, that.additionalArguments ) )
+        if ( !java.util.Objects.equals( additionalArguments, that.getAdditionalArguments() ) )
         {
             return false;
         }
-        if ( !safeEquals( preparationGoals, that.preparationGoals ) )
+        if ( !java.util.Objects.equals( preparationGoals, that.getPreparationGoals() ) )
         {
             return false;
         }
-        if ( !safeEquals( completionGoals, that.completionGoals ) )
+        if ( !java.util.Objects.equals( completionGoals, that.getCompletionGoals() ) )
         {
             return false;
         }
-        if ( !safeEquals( pomFileName, that.pomFileName ) )
+        if ( !java.util.Objects.equals( pomFileName, that.getPomFileName() ) )
         {
             return false;
         }
-        if ( !safeEquals( scmPrivateKeyPassPhrase, that.scmPrivateKeyPassPhrase ) )
+        if ( !java.util.Objects.equals( scmPrivateKeyPassPhrase, that.getScmPrivateKeyPassPhrase() ) )
         {
             return false;
         }
-        if ( !safeEquals( scmPassword, that.scmPassword ) )
+        if ( !java.util.Objects.equals( scmPassword, that.getScmPassword() ) )
         {
             return false;
         }
-        if ( !safeEquals( scmPrivateKey, that.scmPrivateKey ) )
+        if ( !java.util.Objects.equals( scmPrivateKey, that.getScmPrivateKey() ) )
         {
             return false;
         }
-        if ( !safeEquals( scmReleaseLabel, that.scmReleaseLabel ) )
+        if ( !java.util.Objects.equals( scmReleaseLabel, that.getScmReleaseLabel() ) )
         {
             return false;
         }
-        if ( !safeEquals( scmTagBase, that.scmTagBase ) )
+        if ( !java.util.Objects.equals( scmTagBase, that.getScmTagBase() ) )
         {
             return false;
         }
-        if ( !safeEquals( scmBranchBase, that.scmBranchBase ) )
+        if ( !java.util.Objects.equals( scmBranchBase, that.getScmBranchBase() ) )
         {
             return false;
         }
-        if ( !safeEquals( scmId, that.scmId ) )
+        if ( !java.util.Objects.equals( scmId, that.getScmId() ) )
         {
             return false;
         }
-        if ( !safeEquals( scmSourceUrl, that.scmSourceUrl ) )
+        if ( !java.util.Objects.equals( scmSourceUrl, that.getScmSourceUrl() ) )
         {
             return false;
         }
-        if ( !safeEquals( scmUsername, that.scmUsername ) )
+        if ( !java.util.Objects.equals( scmUsername, that.getScmUsername() ) )
         {
             return false;
         }
-        if ( !safeEquals( workingDirectory, that.workingDirectory ) )
+        if ( !java.util.Objects.equals( workingDirectory, that.getWorkingDirectory() ) )
         {
             return false;
         }
-        if ( !safeEquals( scmTagNameFormat, that.scmTagNameFormat ) )
+        if ( !java.util.Objects.equals( scmTagNameFormat, that.getScmTagNameFormat() ) )
+        {
+            return false;
+        }
+        if ( !java.util.Objects.equals( scmTagNameFormat, that.getScmTagNameFormat() ) )
+        {
+            return false;
+        }
+        if ( !java.util.Objects.deepEquals( projectVersions, that.getProjectVersions() ) )
         {
             return false;
         }
@@ -973,7 +875,7 @@
         return true;
     }
 
-    private boolean compareScmCollections( java.util.Map that )
+    private boolean compareScmCollections( java.util.Map<String, org.apache.maven.model.Scm> that )
     {
         // Must manually compare as Scm doesn't have an equals method
         if ( that == null && originalScmInfo == null )
@@ -991,13 +893,13 @@
             return false;
         }
 
-        for ( java.util.Iterator i = originalScmInfo.entrySet().iterator(); i.hasNext(); )
+        for ( java.util.Iterator<java.util.Map.Entry<String, org.apache.maven.model.Scm>> i = originalScmInfo.entrySet().iterator(); i.hasNext(); )
         {
-            java.util.Map.Entry entry = (java.util.Map.Entry) i.next();
+            java.util.Map.Entry<String, org.apache.maven.model.Scm> entry = i.next();
 
-            org.apache.maven.model.Scm thatScm = (org.apache.maven.model.Scm) that.get( entry.getKey() );
+            org.apache.maven.model.Scm thatScm = that.get( entry.getKey() );
 
-            org.apache.maven.model.Scm thisScm = (org.apache.maven.model.Scm) entry.getValue();
+            org.apache.maven.model.Scm thisScm = entry.getValue();
             if ( thatScm == null && thisScm == null )
             {
                 return true;
@@ -1044,51 +946,51 @@
         return true;
     }
 
+    @Override
     public int hashCode()
     {
-        int result = completedPhase != null ? completedPhase.hashCode() : 0;
-        result = 29 * result + ( scmReleaseLabel != null ? scmReleaseLabel.hashCode() : 0 );
-        result = 29 * result + ( additionalArguments != null ? additionalArguments.hashCode() : 0 );
-        result = 29 * result + ( preparationGoals != null ? preparationGoals.hashCode() : 0 );
-        result = 29 * result + ( completionGoals != null ? completionGoals.hashCode() : 0 );
-        result = 29 * result + ( pomFileName != null ? pomFileName.hashCode() : 0 );
-        result = 29 * result + ( checkModificationExcludes != null ? checkModificationExcludes.hashCode() : 0 );
-        result = 29 * result + ( scmTagBase != null ? scmTagBase.hashCode() : 0 );
-        result = 29 * result + ( scmBranchBase != null ? scmBranchBase.hashCode() : 0 );
-        result = 29 * result + ( scmUsername != null ? scmUsername.hashCode() : 0 );
-        result = 29 * result + ( scmPassword != null ? scmPassword.hashCode() : 0 );
-        result = 29 * result + ( scmId != null ? scmId.hashCode() : 0 );
-        result = 29 * result + ( scmSourceUrl != null ? scmSourceUrl.hashCode() : 0 );
-        result = 29 * result + ( scmPrivateKey != null ? scmPrivateKey.hashCode() : 0 );
-        result = 29 * result + ( scmPrivateKeyPassPhrase != null ? scmPrivateKeyPassPhrase.hashCode() : 0 );
-        result = 29 * result + ( workingDirectory != null ? workingDirectory.hashCode() : 0 );
-        result = 29 * result + ( scmUseEditMode ? 1 : 0 );
-        result = 29 * result + ( addSchema ? 1 : 0 );
-        result = 29 * result + ( generateReleasePoms ? 1 : 0 );
-        result = 29 * result + ( interactive ? 1 : 0 );
-        result = 29 * result + ( releaseVersions != null ? releaseVersions.hashCode() : 0 );
-        result = 29 * result + ( developmentVersions != null ? developmentVersions.hashCode() : 0 );
-        result = 29 * result + ( originalScmInfo != null ? originalScmInfo.hashCode() : 0 );
-        result = 29 * result + ( updateDependencies ? 1 : 0 );
-        result = 29 * result + ( useReleaseProfile ? 1 : 0 );
-        result = 29 * result + ( autoVersionSubmodules ? 1 : 0 );
-        result = 29 * result + ( snapshotReleasePluginAllowed ? 1 : 0 );
-        result = 29 * result + ( commitByProject ? 1 : 0 );
-        result = 29 * result + ( branchCreation ? 1 : 0 );
-        result = 29 * result + ( updateBranchVersions ? 1 : 0 );
-        result = 29 * result + ( updateWorkingCopyVersions ? 1 : 0 );
-        result = 29 * result + ( suppressCommitBeforeTagOrBranch ? 1 : 0 );
-        result = 29 * result + ( updateVersionsToSnapshot ? 1 : 0 );
-        result = 29 * result + ( allowTimestampedSnapshots ? 1 : 0 );
-        result = 29 * result + ( remoteTagging ? 1 : 0 );
-        result = 29 * result + ( localCheckout ? 1 : 0 );
-        result = 29 * result + ( pushChanges ? 1 : 0 );
-        result = 29 * result + ( defaultDevelopmentVersion != null ? defaultDevelopmentVersion.hashCode() : 0 );
-        result = 29 * result + ( scmRelativePathProjectDirectory != null ? scmRelativePathProjectDirectory.hashCode() : 0 );
-        result = 29 * result + ( checkoutDirectory != null ? checkoutDirectory.hashCode() : 0 );
-        result = 29 * result + ( performGoals != null ? performGoals.hashCode() : 0 );
-        result = 29 * result + ( defaultReleaseVersion != null ? defaultReleaseVersion.hashCode() : 0 );
-        result = 29 * result + ( scmReleasedPomRevision != null ? scmReleasedPomRevision.hashCode() : 0 );
+        int result = java.util.Objects.hashCode( completedPhase );
+        result = 29 * result + java.util.Objects.hashCode( scmReleaseLabel );
+        result = 29 * result + java.util.Objects.hashCode( additionalArguments );
+        result = 29 * result + java.util.Objects.hashCode( preparationGoals );
+        result = 29 * result + java.util.Objects.hashCode( completionGoals );
+        result = 29 * result + java.util.Objects.hashCode( pomFileName );
+        result = 29 * result + java.util.Objects.hashCode( checkModificationExcludes );
+        result = 29 * result + java.util.Objects.hashCode( scmTagBase );
+        result = 29 * result + java.util.Objects.hashCode( scmBranchBase );
+        result = 29 * result + java.util.Objects.hashCode( scmUsername );
+        result = 29 * result + java.util.Objects.hashCode( scmPassword  );
+        result = 29 * result + java.util.Objects.hashCode( scmId );
+        result = 29 * result + java.util.Objects.hashCode( scmSourceUrl );
+        result = 29 * result + java.util.Objects.hashCode( scmPrivateKey );
+        result = 29 * result + java.util.Objects.hashCode( scmPrivateKeyPassPhrase );
+        result = 29 * result + java.util.Objects.hashCode( workingDirectory );
+        result = 29 * result + java.util.Objects.hashCode( scmUseEditMode );
+        result = 29 * result + java.util.Objects.hashCode( addSchema );
+        result = 29 * result + java.util.Objects.hashCode( generateReleasePoms );
+        result = 29 * result + java.util.Objects.hashCode( interactive );
+        result = 29 * result + java.util.Objects.hashCode( projectVersions );
+        result = 29 * result + java.util.Objects.hashCode( originalScmInfo  );
+        result = 29 * result + java.util.Objects.hashCode( updateDependencies );
+        result = 29 * result + java.util.Objects.hashCode( useReleaseProfile );
+        result = 29 * result + java.util.Objects.hashCode( autoVersionSubmodules );
+        result = 29 * result + java.util.Objects.hashCode( snapshotReleasePluginAllowed );
+        result = 29 * result + java.util.Objects.hashCode( commitByProject );
+        result = 29 * result + java.util.Objects.hashCode( branchCreation );
+        result = 29 * result + java.util.Objects.hashCode( updateBranchVersions );
+        result = 29 * result + java.util.Objects.hashCode( updateWorkingCopyVersions );
+        result = 29 * result + java.util.Objects.hashCode( suppressCommitBeforeTagOrBranch );
+        result = 29 * result + java.util.Objects.hashCode( updateVersionsToSnapshot );
+        result = 29 * result + java.util.Objects.hashCode( allowTimestampedSnapshots );
+        result = 29 * result + java.util.Objects.hashCode( remoteTagging );
+        result = 29 * result + java.util.Objects.hashCode( localCheckout );
+        result = 29 * result + java.util.Objects.hashCode( pushChanges );
+        result = 29 * result + java.util.Objects.hashCode( defaultDevelopmentVersion  );
+        result = 29 * result + java.util.Objects.hashCode( scmRelativePathProjectDirectory );
+        result = 29 * result + java.util.Objects.hashCode( checkoutDirectory );
+        result = 29 * result + java.util.Objects.hashCode( performGoals );
+        result = 29 * result + java.util.Objects.hashCode( defaultReleaseVersion );
+        result = 29 * result + java.util.Objects.hashCode( scmReleasedPomRevision );
 
         return result;
     }
@@ -1096,5 +998,69 @@
         </codeSegment>
       </codeSegments>
     </class>
+    <class>
+      <name>ReleaseStageVersions</name>
+      <fields>
+        <field>
+          <name>original</name>
+          <version>3.0.0+</version>
+          <type>String</type>
+        </field>
+        <field>
+          <name>release</name>
+          <version>3.0.0+</version>
+          <type>String</type>
+        </field>
+        <field>
+          <name>development</name>
+          <version>3.0.0+</version>
+          <type>String</type>
+        </field>
+      </fields>
+      <codeSegments>
+        <codeSegment>
+          <version>2.1.0+</version>
+          <code><![CDATA[
+    @Override
+    public boolean equals( Object obj )
+    {
+        if ( this == obj )
+        {
+            return true;
+        }
+        if ( obj == null || getClass() != obj.getClass() )
+        {
+            return false;
+        }
+
+        ReleaseStageVersions that = (ReleaseStageVersions) obj;
+        if ( !java.util.Objects.equals( original, that.original ) )
+        {
+            return false;
+        }
+        if ( !java.util.Objects.equals( release, that.release ) )
+        {
+            return false;
+        }
+        if ( !java.util.Objects.equals( development, that.development ) )
+        {
+            return false;
+        }
+        return true;
+    }
+          
+    @Override
+    public int hashCode()
+    {
+        int result = java.util.Objects.hashCode( original );
+        result = 29 * result + java.util.Objects.hashCode( release );
+        result = 29 * result + java.util.Objects.hashCode( development );
+        return result;
+    }      
+          
+]]></code>
+        </codeSegment>
+      </codeSegments>          
+    </class>
   </classes>
 </model>
diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/DefaultReleaseManagerTest.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/DefaultReleaseManagerTest.java
index d68f9f6..142d49b 100644
--- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/DefaultReleaseManagerTest.java
+++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/DefaultReleaseManagerTest.java
@@ -32,6 +32,7 @@
 import java.io.IOException;
 import java.util.Collections;
 import java.util.List;
+import java.util.Properties;
 
 import org.apache.maven.project.MavenProject;
 import org.apache.maven.scm.CommandParameters;
@@ -45,6 +46,7 @@
 import org.apache.maven.scm.provider.ScmProviderStub;
 import org.apache.maven.scm.repository.ScmRepository;
 import org.apache.maven.shared.release.config.ReleaseDescriptor;
+import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder;
 import org.apache.maven.shared.release.config.ReleaseDescriptorStore;
 import org.apache.maven.shared.release.config.ReleaseDescriptorStoreException;
 import org.apache.maven.shared.release.config.ReleaseDescriptorStoreStub;
@@ -80,12 +82,13 @@
     {
         ReleaseManager releaseManager = lookup( ReleaseManager.class, "test" );
 
-        ReleaseDescriptor releaseDescriptor = configStore.getReleaseConfiguration();
-        releaseDescriptor.setCompletedPhase( null );
+        ReleaseDescriptorBuilder builder = configStore.getReleaseConfiguration();
+        builder.setCompletedPhase( null );
 
         ReleasePrepareRequest prepareRequest = new ReleasePrepareRequest();
-        prepareRequest.setReleaseDescriptor( releaseDescriptor );
+        prepareRequest.setReleaseDescriptorBuilder( builder );
         prepareRequest.setReleaseEnvironment( new DefaultReleaseEnvironment() );
+        prepareRequest.setUserProperties( new Properties() );
         
         releaseManager.prepare( prepareRequest );
 
@@ -105,12 +108,13 @@
     {
         ReleaseManager releaseManager = lookup( ReleaseManager.class, "test" );
 
-        ReleaseDescriptor releaseDescriptor = configStore.getReleaseConfiguration();
-        releaseDescriptor.setCompletedPhase( "step1" );
+        ReleaseDescriptorBuilder builder = configStore.getReleaseConfiguration();
+        builder.setCompletedPhase( "step1" );
 
         ReleasePrepareRequest prepareRequest = new ReleasePrepareRequest();
-        prepareRequest.setReleaseDescriptor( releaseDescriptor );
+        prepareRequest.setReleaseDescriptorBuilder( builder );
         prepareRequest.setReleaseEnvironment( new DefaultReleaseEnvironment() );
+        prepareRequest.setUserProperties( new Properties() );
         
         releaseManager.prepare( prepareRequest );
 
@@ -130,14 +134,15 @@
     {
         ReleaseManager releaseManager = lookup( ReleaseManager.class, "test" );
 
-        ReleaseDescriptor releaseDescriptor = configStore.getReleaseConfiguration();
-        releaseDescriptor.setCompletedPhase( "step1" );
+        ReleaseDescriptorBuilder builder = configStore.getReleaseConfiguration();
+        builder.setCompletedPhase( "step1" );
 
         ReleasePrepareRequest prepareRequest = new ReleasePrepareRequest();
-        prepareRequest.setReleaseDescriptor( releaseDescriptor );
+        prepareRequest.setReleaseDescriptorBuilder( builder );
         prepareRequest.setReleaseEnvironment( new DefaultReleaseEnvironment() );
         prepareRequest.setDryRun( false );
         prepareRequest.setResume( false );
+        prepareRequest.setUserProperties( new Properties() );
         
         releaseManager.prepare( prepareRequest );
 
@@ -157,12 +162,13 @@
     {
         ReleaseManager releaseManager = lookup( ReleaseManager.class, "test" );
 
-        ReleaseDescriptor releaseDescriptor = configStore.getReleaseConfiguration();
-        releaseDescriptor.setCompletedPhase( "step3" );
+        ReleaseDescriptorBuilder builder = configStore.getReleaseConfiguration();
+        builder.setCompletedPhase( "step3" );
         
         ReleasePrepareRequest prepareRequest = new ReleasePrepareRequest();
-        prepareRequest.setReleaseDescriptor( releaseDescriptor );
+        prepareRequest.setReleaseDescriptorBuilder( builder );
         prepareRequest.setReleaseEnvironment( new DefaultReleaseEnvironment() );
+        prepareRequest.setUserProperties( new Properties() );
 
         releaseManager.prepare( prepareRequest );
 
@@ -182,12 +188,13 @@
     {
         ReleaseManager releaseManager = lookup( ReleaseManager.class, "test" );
 
-        ReleaseDescriptor releaseDescriptor = configStore.getReleaseConfiguration();
-        releaseDescriptor.setCompletedPhase( "foo" );
+        ReleaseDescriptorBuilder builder = configStore.getReleaseConfiguration();
+        builder.setCompletedPhase( "foo" );
 
         ReleasePrepareRequest prepareRequest = new ReleasePrepareRequest();
-        prepareRequest.setReleaseDescriptor( releaseDescriptor );
+        prepareRequest.setReleaseDescriptorBuilder( builder );
         prepareRequest.setReleaseEnvironment( new DefaultReleaseEnvironment() );
+        prepareRequest.setUserProperties( new Properties() );
         
         releaseManager.prepare( prepareRequest );
 
@@ -207,14 +214,15 @@
     {
         ReleaseManager releaseManager = lookup( ReleaseManager.class, "test" );
 
-        ReleaseDescriptor releaseDescriptor = configStore.getReleaseConfiguration();
-        releaseDescriptor.setCompletedPhase( null );
+        ReleaseDescriptorBuilder builder = configStore.getReleaseConfiguration();
+        builder.setCompletedPhase( null );
 
         ReleasePrepareRequest prepareRequest = new ReleasePrepareRequest();
-        prepareRequest.setReleaseDescriptor( releaseDescriptor );
+        prepareRequest.setReleaseDescriptorBuilder( builder );
         prepareRequest.setReleaseEnvironment( new DefaultReleaseEnvironment() );
         prepareRequest.setDryRun( true );
         prepareRequest.setResume( true );
+        prepareRequest.setUserProperties( new Properties() );
         
         releaseManager.prepare( prepareRequest );
 
@@ -234,14 +242,15 @@
     {
         ReleaseManager releaseManager = lookup( ReleaseManager.class, "test" );
 
-        ReleaseDescriptor releaseDescriptor = configStore.getReleaseConfiguration();
-        releaseDescriptor.setCompletedPhase( "step1" );
+        ReleaseDescriptorBuilder builder = configStore.getReleaseConfiguration();
+        builder.setCompletedPhase( "step1" );
 
         ReleasePrepareRequest prepareRequest = new ReleasePrepareRequest();
-        prepareRequest.setReleaseDescriptor( releaseDescriptor );
+        prepareRequest.setReleaseDescriptorBuilder( builder );
         prepareRequest.setReleaseEnvironment( new DefaultReleaseEnvironment() );
         prepareRequest.setDryRun( true );
         prepareRequest.setResume( true );
+        prepareRequest.setUserProperties( new Properties() );
         
         releaseManager.prepare( prepareRequest );
 
@@ -261,14 +270,15 @@
     {
         ReleaseManager releaseManager = lookup( ReleaseManager.class, "test" );
 
-        ReleaseDescriptor releaseDescriptor = configStore.getReleaseConfiguration();
-        releaseDescriptor.setCompletedPhase( "step3" );
+        ReleaseDescriptorBuilder builder = configStore.getReleaseConfiguration();
+        builder.setCompletedPhase( "step3" );
 
         ReleasePrepareRequest prepareRequest = new ReleasePrepareRequest();
-        prepareRequest.setReleaseDescriptor( releaseDescriptor );
+        prepareRequest.setReleaseDescriptorBuilder( builder );
         prepareRequest.setReleaseEnvironment( new DefaultReleaseEnvironment() );
         prepareRequest.setDryRun( true );
         prepareRequest.setResume( true );
+        prepareRequest.setUserProperties( new Properties() );
         
         releaseManager.prepare( prepareRequest );
 
@@ -288,14 +298,15 @@
     {
         ReleaseManager releaseManager = lookup( ReleaseManager.class, "test" );
 
-        ReleaseDescriptor releaseDescriptor = configStore.getReleaseConfiguration();
-        releaseDescriptor.setCompletedPhase( "foo" );
+        ReleaseDescriptorBuilder builder = configStore.getReleaseConfiguration();
+        builder.setCompletedPhase( "foo" );
 
         ReleasePrepareRequest prepareRequest = new ReleasePrepareRequest();
-        prepareRequest.setReleaseDescriptor( releaseDescriptor );
+        prepareRequest.setReleaseDescriptorBuilder( builder );
         prepareRequest.setReleaseEnvironment( new DefaultReleaseEnvironment() );
         prepareRequest.setDryRun( true );
         prepareRequest.setResume( true );
+        prepareRequest.setUserProperties( new Properties() );
         
         releaseManager.prepare( prepareRequest );
 
@@ -316,10 +327,11 @@
         ReleaseManager releaseManager = lookup( ReleaseManager.class, "bad-phase-configured" );
 
         ReleasePrepareRequest prepareRequest = new ReleasePrepareRequest();
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setReleaseStrategyId( "foo" );
-        prepareRequest.setReleaseDescriptor( releaseDescriptor );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setReleaseStrategyId( "foo" );
+        prepareRequest.setReleaseDescriptorBuilder( builder );
         prepareRequest.setReleaseEnvironment( new DefaultReleaseEnvironment() );
+        prepareRequest.setUserProperties( new Properties() );
         
         try
         {
@@ -336,20 +348,21 @@
         throws Exception
     {
         // prepare
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setScmSourceUrl( "scm-url" );
-        releaseDescriptor.setWorkingDirectory( getTestFile( "target/working-directory" ).getAbsolutePath() );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setScmSourceUrl( "scm-url" );
+        builder.setWorkingDirectory( getTestFile( "target/working-directory" ).getAbsolutePath() );
 
         DefaultReleaseManager releaseManager = (DefaultReleaseManager) lookup( ReleaseManager.class, "test" );
 
         ReleaseDescriptorStore configStoreMock = mock( ReleaseDescriptorStore.class );
-        when( configStoreMock.read( releaseDescriptor ) ).thenThrow( new ReleaseDescriptorStoreException( "message", new IOException( "ioExceptionMsg" ) ) );
+        when( configStoreMock.read( builder ) ).thenThrow( new ReleaseDescriptorStoreException( "message", new IOException( "ioExceptionMsg" ) ) );
 
         releaseManager.setConfigStore( configStoreMock );
         
         ReleasePrepareRequest prepareRequest = new ReleasePrepareRequest();
-        prepareRequest.setReleaseDescriptor( releaseDescriptor );
+        prepareRequest.setReleaseDescriptorBuilder( builder );
         prepareRequest.setReleaseEnvironment( new DefaultReleaseEnvironment() );
+        prepareRequest.setUserProperties( new Properties() );
 
         // execute
         try
@@ -364,7 +377,7 @@
         }
 
         // verify
-        verify( configStoreMock ).read( releaseDescriptor );
+        verify( configStoreMock ).read( builder );
         verifyNoMoreInteractions( configStoreMock );
     }
 
@@ -372,22 +385,24 @@
         throws Exception
     {
         // prepare
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setScmSourceUrl( "scm-url" );
-        releaseDescriptor.setWorkingDirectory( getTestFile( "target/working-directory" ).getAbsolutePath() );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setScmSourceUrl( "scm-url" );
+        builder.setWorkingDirectory( getTestFile( "target/working-directory" ).getAbsolutePath() );
 
         DefaultReleaseManager releaseManager = (DefaultReleaseManager) lookup( ReleaseManager.class, "test" );
 
         ReleaseDescriptorStore configStoreMock = mock( ReleaseDescriptorStore.class );
-        doThrow( new ReleaseDescriptorStoreException( "message", new IOException( "ioExceptionMsg" ) ) ).when( configStoreMock ).write( releaseDescriptor );
+        doThrow( new ReleaseDescriptorStoreException( "message", new IOException( "ioExceptionMsg" ) ) ).when( configStoreMock ).write( any( ReleaseDescriptor.class) );
 
         releaseManager.setConfigStore( configStoreMock );
         
         ReleasePrepareRequest prepareRequest = new ReleasePrepareRequest();
-        prepareRequest.setReleaseDescriptor( releaseDescriptor );
+        prepareRequest.setReleaseDescriptorBuilder( builder );
         prepareRequest.setReleaseEnvironment( new DefaultReleaseEnvironment() );
         prepareRequest.setDryRun( false );
         prepareRequest.setResume( false );
+        prepareRequest.setUserProperties( new Properties() );
+
 
         // execute
         try
@@ -402,7 +417,7 @@
         }
 
         // verify
-        verify( configStoreMock ).write( releaseDescriptor ) ;
+        verify( configStoreMock ).write( any( ReleaseDescriptor.class ) ) ;
         verifyNoMoreInteractions( configStoreMock );
     }
 
@@ -410,9 +425,9 @@
         throws Exception
     {
         // prepare
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setScmSourceUrl( "scm-url" );
-        releaseDescriptor.setWorkingDirectory( getTestFile( "target/working-directory" ).getAbsolutePath() );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setScmSourceUrl( "scm-url" );
+        builder.setWorkingDirectory( getTestFile( "target/working-directory" ).getAbsolutePath() );
 
         DefaultReleaseManager releaseManager = (DefaultReleaseManager) lookup( ReleaseManager.class, "test" );
 
@@ -421,7 +436,7 @@
         releaseManager.setConfigStore( configStoreMock );
 
         ReleaseCleanRequest cleanRequest = new ReleaseCleanRequest();
-        cleanRequest.setReleaseDescriptor( releaseDescriptor );
+        cleanRequest.setReleaseDescriptorBuilder( builder );
         
         // execute
         releaseManager.clean( cleanRequest );
@@ -439,7 +454,7 @@
         phase = (ReleasePhaseStub) lookup( ReleasePhase.class, "branch1" );
         assertTrue( "branch1 not cleaned", phase.isCleaned() );
 
-        verify( configStoreMock ).delete( releaseDescriptor );
+        verify( configStoreMock ).delete( any( ReleaseDescriptor.class ) );
         verifyNoMoreInteractions( configStoreMock );
     }
 
@@ -457,13 +472,13 @@
     {
         ReleaseManager releaseManager = lookup( ReleaseManager.class, "test" );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setScmSourceUrl( "scm-url" );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setScmSourceUrl( "scm-url" );
         File checkoutDirectory = getTestFile( "target/checkout-directory" );
-        releaseDescriptor.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
+        builder.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
         
         ReleasePerformRequest performRequest = new ReleasePerformRequest();
-        performRequest.setReleaseDescriptor( releaseDescriptor );
+        performRequest.setReleaseDescriptorBuilder( builder );
         performRequest.setReleaseEnvironment( new DefaultReleaseEnvironment() );
         performRequest.setReactorProjects( createReactorProjects() );
 
@@ -476,25 +491,25 @@
         throws Exception
     {
         // prepare
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setScmSourceUrl( "scm-url" );
-        releaseDescriptor.setWorkingDirectory( getTestFile( "target/working-directory" ).getAbsolutePath() );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setScmSourceUrl( "scm-url" );
+        builder.setWorkingDirectory( getTestFile( "target/working-directory" ).getAbsolutePath() );
 
         DefaultReleaseManager releaseManager = (DefaultReleaseManager) lookup( ReleaseManager.class, "test" );
 
         ReleaseDescriptorStore configStoreMock = mock( ReleaseDescriptorStore.class );
-        when( configStoreMock.read( releaseDescriptor ) ).thenThrow( new ReleaseDescriptorStoreException( "message", new IOException( "ioExceptionMsg" ) ) );
+        when( configStoreMock.read( builder ) ).thenThrow( new ReleaseDescriptorStoreException( "message", new IOException( "ioExceptionMsg" ) ) );
 
         releaseManager.setConfigStore( configStoreMock );
         
         ReleasePerformRequest performRequest = new ReleasePerformRequest();
-        performRequest.setReleaseDescriptor( releaseDescriptor );
+        performRequest.setReleaseDescriptorBuilder( builder );
         performRequest.setReleaseEnvironment( new DefaultReleaseEnvironment() );
 
         // execute
         try
         {
-            releaseDescriptor.setUseReleaseProfile( false );
+            builder.setUseReleaseProfile( false );
 
             releaseManager.perform( performRequest );
             fail( "Should have failed to read configuration" );
@@ -506,30 +521,30 @@
         }
 
         // verify
-        verify( configStoreMock ).read( releaseDescriptor );
+        verify( configStoreMock ).read( builder );
         verifyNoMoreInteractions( configStoreMock );
     }
 
     public void testReleasePerformWithIncompletePrepare()
         throws Exception
     {
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setScmSourceUrl( "scm-url" );
-        releaseDescriptor.setWorkingDirectory( getTestFile( "target/working-directory" ).getAbsolutePath() );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setScmSourceUrl( "scm-url" );
+        builder.setWorkingDirectory( getTestFile( "target/working-directory" ).getAbsolutePath() );
 
         DefaultReleaseManager releaseManager = (DefaultReleaseManager) lookup( ReleaseManager.class, "test" );
 
         ReleaseDescriptorStoreStub configStore = new ReleaseDescriptorStoreStub();
-        releaseDescriptor.setCompletedPhase( "scm-tag" );
+        builder.setCompletedPhase( "scm-tag" );
         releaseManager.setConfigStore( configStore );
 
         ReleasePerformRequest performRequest = new ReleasePerformRequest();
-        performRequest.setReleaseDescriptor( releaseDescriptor );
+        performRequest.setReleaseDescriptorBuilder( builder );
         performRequest.setReleaseEnvironment( new DefaultReleaseEnvironment() );
 
         try
         {
-            releaseDescriptor.setUseReleaseProfile( false );
+            builder.setUseReleaseProfile( false );
 
             releaseManager.perform( performRequest );
             fail( "Should have failed to perform" );
@@ -553,10 +568,10 @@
         ReleaseManagerListener managerListener = mock( ReleaseManagerListener.class );
         performRequest.setReleaseManagerListener( managerListener );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setScmSourceUrl( "scm-url" );
-        releaseDescriptor.setWorkingDirectory( getTestFile( "target/working-directory" ).getAbsolutePath() );
-        performRequest.setReleaseDescriptor( releaseDescriptor );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setScmSourceUrl( "scm-url" );
+        builder.setWorkingDirectory( getTestFile( "target/working-directory" ).getAbsolutePath() );
+        performRequest.setReleaseDescriptorBuilder( builder );
 
         ReleaseManager releaseManager = lookup( ReleaseManager.class, "test" );
 
@@ -581,18 +596,18 @@
     public void testNoScmUrlPerform()
         throws Exception
     {
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setWorkingDirectory( getTestFile( "target/test/checkout" ).getAbsolutePath() );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setWorkingDirectory( getTestFile( "target/test/checkout" ).getAbsolutePath() );
 
         ReleaseManager releaseManager = lookup( ReleaseManager.class, "test" );
 
         ReleasePerformRequest performRequest = new ReleasePerformRequest();
-        performRequest.setReleaseDescriptor( releaseDescriptor );
+        performRequest.setReleaseDescriptorBuilder( builder );
         performRequest.setReleaseEnvironment( new DefaultReleaseEnvironment() );
         
         try
         {
-            releaseDescriptor.setUseReleaseProfile( false );
+            builder.setUseReleaseProfile( false );
 
             releaseManager.perform( performRequest );
 
@@ -610,10 +625,10 @@
         // prepare
         ReleaseManager releaseManager = lookup( ReleaseManager.class, "test" );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setScmSourceUrl( "scm-url" );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setScmSourceUrl( "scm-url" );
         File checkoutDirectory = getTestFile( "target/checkout-directory" );
-        releaseDescriptor.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
+        builder.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
 
         ScmProvider scmProviderMock = mock( ScmProvider.class );
         when( scmProviderMock.checkOut( any( ScmRepository.class ),
@@ -626,7 +641,7 @@
         stub.setScmProvider( scmProviderMock );
 
         ReleasePerformRequest performRequest = new ReleasePerformRequest();
-        performRequest.setReleaseDescriptor( releaseDescriptor );
+        performRequest.setReleaseDescriptorBuilder( builder );
         performRequest.setReleaseEnvironment( new DefaultReleaseEnvironment() );
         performRequest.setReactorProjects( createReactorProjects() );
 
@@ -653,19 +668,19 @@
     {
         ReleaseManager releaseManager = lookup( ReleaseManager.class, "test" );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setScmSourceUrl( "scm-url" );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setScmSourceUrl( "scm-url" );
         File checkoutDirectory = getTestFile( "target/checkout-directory" );
-        releaseDescriptor.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
+        builder.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
 
         ScmManager scmManager = (ScmManager) lookup( ScmManager.class );
         ScmProviderStub providerStub =
-            (ScmProviderStub) scmManager.getProviderByUrl( releaseDescriptor.getScmSourceUrl() );
+            (ScmProviderStub) scmManager.getProviderByUrl( "scm-url" );
 
         providerStub.setCheckOutScmResult( new CheckOutScmResult( "", "", "", false ) );
         
         ReleasePerformRequest performRequest = new ReleasePerformRequest();
-        performRequest.setReleaseDescriptor( releaseDescriptor );
+        performRequest.setReleaseDescriptorBuilder( builder );
         performRequest.setReleaseEnvironment( new DefaultReleaseEnvironment() );
         performRequest.setReactorProjects( createReactorProjects() );
 
@@ -713,7 +728,7 @@
         ReleaseManager releaseManager = lookup( ReleaseManager.class, "test" );
         
         ReleaseRollbackRequest rollbackRequest = new ReleaseRollbackRequest();
-        rollbackRequest.setReleaseDescriptor( configStore.getReleaseConfiguration() );
+        rollbackRequest.setReleaseDescriptorBuilder( configStore.getReleaseConfiguration() );
 
         releaseManager.rollback( rollbackRequest );
 
@@ -730,7 +745,8 @@
         ReleaseManager releaseManager = lookup( ReleaseManager.class, "test" );
         
         ReleaseUpdateVersionsRequest updateVersionsRequest = new ReleaseUpdateVersionsRequest();
-        updateVersionsRequest.setReleaseDescriptor( configStore.getReleaseConfiguration() );
+        updateVersionsRequest.setReleaseDescriptorBuilder( configStore.getReleaseConfiguration() );
+        updateVersionsRequest.setUserProperties( new Properties() );
 
         releaseManager.updateVersions( updateVersionsRequest );
 
diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/config/PropertiesReleaseDescriptorStoreTest.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/config/PropertiesReleaseDescriptorStoreTest.java
index 0b93bbf..35903ce 100644
--- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/config/PropertiesReleaseDescriptorStoreTest.java
+++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/config/PropertiesReleaseDescriptorStoreTest.java
@@ -1,5 +1,7 @@
 package org.apache.maven.shared.release.config;
 
+import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder.BuilderReleaseDescriptor;
+
 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
@@ -45,7 +47,7 @@
     {
         super.setUp();
         store = (PropertiesReleaseDescriptorStore) lookup( ReleaseDescriptorStore.class, "properties" );
-        secDispatcher = (SecDispatcher) lookup( SecDispatcher.class, "mng-4384" );
+        secDispatcher = lookup( SecDispatcher.class, "mng-4384" );
     }
 
     public void testReadFromFile()
@@ -53,9 +55,9 @@
     {
         File file = getTestFile( "target/test-classes/release.properties" );
 
-        ReleaseDescriptor config = store.read( file );
+        ReleaseDescriptor config = store.read( file ).build();
 
-        ReleaseDescriptor expected = createExpectedReleaseConfiguration();
+        ReleaseDescriptor expected = createExpectedReleaseConfiguration().build();
 
         assertEquals( "check matches", expected, config );
     }
@@ -63,14 +65,14 @@
     public void testReadFromFileUsingWorkingDirectory()
         throws Exception
     {
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setWorkingDirectory( AbstractReleaseTestCase.getPath(  getTestFile( "target/test-classes" ) ) );
-        ReleaseDescriptor config = store.read( releaseDescriptor );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setWorkingDirectory( AbstractReleaseTestCase.getPath(  getTestFile( "target/test-classes" ) ) );
+        ReleaseDescriptor config = store.read( builder ).build();
 
-        ReleaseDescriptor expected = createExpectedReleaseConfiguration();
-        expected.setWorkingDirectory( releaseDescriptor.getWorkingDirectory() );
+        ReleaseDescriptorBuilder expected = createExpectedReleaseConfiguration();
+        expected.setWorkingDirectory( builder.build().getWorkingDirectory() );
 
-        assertEquals( "check matches", expected, config );
+        assertEquals( "check matches", expected.build(), config );
     }
 
     public void testReadFromEmptyFile()
@@ -78,7 +80,7 @@
     {
         File file = getTestFile( "target/test-classes/empty-release.properties" );
 
-        ReleaseDescriptor config = store.read( file );
+        BuilderReleaseDescriptor config = store.read( file ).build();
 
         assertDefaultReleaseConfiguration( config );
     }
@@ -88,7 +90,7 @@
     {
         File file = getTestFile( "target/test-classes/no-release.properties" );
 
-        ReleaseDescriptor config = store.read( file );
+        BuilderReleaseDescriptor config = store.read( file ).build();
 
         assertDefaultReleaseConfiguration( config );
     }
@@ -98,10 +100,10 @@
     {
         File file = getTestFile( "target/test-classes/empty-release.properties" );
 
-        ReleaseDescriptor mergeDescriptor = createMergeConfiguration();
-        ReleaseDescriptor config = store.read( mergeDescriptor, file );
+        ReleaseDescriptorBuilder mergeDescriptor = createMergeConfiguration();
+        ReleaseDescriptor config = store.read( mergeDescriptor, file ).build();
 
-        assertEquals( "Check configurations merged", mergeDescriptor, config );
+        assertEquals( "Check configurations merged", mergeDescriptor.build(), config );
     }
 
     public void testMergeFromMissingFile()
@@ -109,10 +111,10 @@
     {
         File file = getTestFile( "target/test-classes/no-release.properties" );
 
-        ReleaseDescriptor mergeDescriptor = createMergeConfiguration();
-        ReleaseDescriptor config = store.read( mergeDescriptor, file );
+        ReleaseDescriptorBuilder mergeDescriptor = createMergeConfiguration();
+        ReleaseDescriptor config = store.read( mergeDescriptor, file ).build();
 
-        assertEquals( "Check configurations merged", mergeDescriptor, config );
+        assertEquals( "Check configurations merged", mergeDescriptor.build(), config );
     }
 
     public void testWriteToNewFile()
@@ -122,16 +124,16 @@
         file.delete();
         assertFalse( "Check file doesn't exist", file.exists() );
 
-        ReleaseDescriptor config = createReleaseConfigurationForWriting();
+        ReleaseDescriptorBuilder config = createReleaseConfigurationForWriting();
 
-        store.write( config, file );
+        store.write( config.build(), file );
 
-        ReleaseDescriptor rereadDescriptor = store.read( file );
+        ReleaseDescriptor rereadDescriptor = store.read( file ).build();
 
         assertAndAdjustScmPassword( config, rereadDescriptor );
         assertAndAdjustScmPrivateKeyPassPhrase( config, rereadDescriptor );
 
-        assertEquals( "compare configuration", config, rereadDescriptor );
+        assertEquals( "compare configuration", config.build(), rereadDescriptor );
     }
 
     public void testWriteToWorkingDirectory()
@@ -142,18 +144,18 @@
         assertFalse( "Check file doesn't exist", file.exists() );
         file.getParentFile().mkdirs();
 
-        ReleaseDescriptor config = createReleaseConfigurationForWriting();
+        ReleaseDescriptorBuilder config = createReleaseConfigurationForWriting();
         config.setWorkingDirectory( AbstractReleaseTestCase.getPath( file.getParentFile() ) );
 
-        store.write( config );
+        store.write( config.build() );
 
-        ReleaseDescriptor rereadDescriptor = store.read( file );
-        rereadDescriptor.setWorkingDirectory( AbstractReleaseTestCase.getPath( file.getParentFile() ) );
+        ReleaseDescriptorBuilder rereadDescriptorBuilder = store.read( file );
+        rereadDescriptorBuilder.setWorkingDirectory( AbstractReleaseTestCase.getPath( file.getParentFile() ) );
 
-        assertAndAdjustScmPassword( config, rereadDescriptor );
-        assertAndAdjustScmPrivateKeyPassPhrase( config, rereadDescriptor );
+        assertAndAdjustScmPassword( config, rereadDescriptorBuilder.build() );
+        assertAndAdjustScmPrivateKeyPassPhrase( config, rereadDescriptorBuilder.build() );
 
-        assertEquals( "compare configuration", config, rereadDescriptor );
+        assertEquals( "compare configuration", config.build(), rereadDescriptorBuilder.build() );
     }
 
     public void testWriteToNewFileRequiredOnly()
@@ -163,15 +165,15 @@
         file.delete();
         assertFalse( "Check file doesn't exist", file.exists() );
 
-        ReleaseDescriptor config = new ReleaseDescriptor();
+        ReleaseDescriptorBuilder config = new ReleaseDescriptorBuilder();
         config.setCompletedPhase( "completed-phase-write" );
         config.setScmSourceUrl( "url-write" );
 
-        store.write( config, file );
+        store.write( config.build(), file );
 
-        ReleaseDescriptor rereadDescriptor = store.read( file );
+        ReleaseDescriptor rereadDescriptor = store.read( file ).build();
 
-        assertEquals( "compare configuration", config, rereadDescriptor );
+        assertEquals( "compare configuration", config.build(), rereadDescriptor );
     }
 
     public void testWriteToNewFileDottedIds()
@@ -181,12 +183,12 @@
         file.delete();
         assertFalse( "Check file doesn't exist", file.exists() );
 
-        ReleaseDescriptor config = new ReleaseDescriptor();
+        ReleaseDescriptorBuilder config = new ReleaseDescriptorBuilder();
         config.setCompletedPhase( "completed-phase-write" );
         config.setScmSourceUrl( "url-write" );
 
-        config.mapReleaseVersion( "group.id:artifact.id", "1.1" );
-        config.mapDevelopmentVersion( "group.id:artifact.id", "1.2-SNAPSHOT" );
+        config.addReleaseVersion( "group.id:artifact.id", "1.1" );
+        config.addDevelopmentVersion( "group.id:artifact.id", "1.2-SNAPSHOT" );
 
         IdentifiedScm scm = new IdentifiedScm();
         scm.setId( "id" );
@@ -194,13 +196,13 @@
         scm.setDeveloperConnection( "devConnection" );
         scm.setTag( "tag" );
         scm.setUrl( "url" );
-        config.mapOriginalScmInfo( "group.id:artifact.id", scm );
+        config.addOriginalScmInfo( "group.id:artifact.id", scm );
 
-        store.write( config, file );
+        store.write( config.build(), file );
 
-        ReleaseDescriptor rereadDescriptor = store.read( file );
+        ReleaseDescriptor rereadDescriptor = store.read( file ).build();
 
-        assertEquals( "compare configuration", config, rereadDescriptor );
+        assertEquals( "compare configuration", config.build(), rereadDescriptor );
     }
 
     public void testWriteToNewFileNullMappedScm()
@@ -210,23 +212,23 @@
         file.delete();
         assertFalse( "Check file doesn't exist", file.exists() );
 
-        ReleaseDescriptor config = new ReleaseDescriptor();
-        config.setCompletedPhase( "completed-phase-write" );
-        config.setScmSourceUrl( "url-write" );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setCompletedPhase( "completed-phase-write" );
+        builder.setScmSourceUrl( "url-write" );
 
-        config.mapReleaseVersion( "group.id:artifact.id", "1.1" );
-        config.mapDevelopmentVersion( "group.id:artifact.id", "1.2-SNAPSHOT" );
+        builder.addReleaseVersion( "group.id:artifact.id", "1.1" );
+        builder.addDevelopmentVersion( "group.id:artifact.id", "1.2-SNAPSHOT" );
 
-        config.mapOriginalScmInfo( "group.id:artifact.id", null );
+        builder.addOriginalScmInfo( "group.id:artifact.id", null );
 
-        store.write( config, file );
+        store.write( builder.build(), file );
 
-        ReleaseDescriptor rereadDescriptor = store.read( file );
+        ReleaseDescriptor rereadDescriptor = store.read( file ).build();
 
         assertNull( "check null scm is mapped correctly",
-                    rereadDescriptor.getOriginalScmInfo().get( "group.id:artifact.id" ) );
+                    rereadDescriptor.getOriginalScmInfo( "group.id:artifact.id" ) );
 
-        assertEquals( "compare configuration", config, rereadDescriptor );
+        assertEquals( "compare configuration", builder.build(), rereadDescriptor );
     }
 
     public void testOverwriteFile()
@@ -235,16 +237,16 @@
         File file = getTestFile( "target/test-classes/rewrite-release.properties" );
         assertTrue( "Check file already exists", file.exists() );
 
-        ReleaseDescriptor config = createReleaseConfigurationForWriting();
+        ReleaseDescriptorBuilder config = createReleaseConfigurationForWriting();
 
-        store.write( config, file );
+        store.write( config.build(), file );
 
-        ReleaseDescriptor rereadDescriptor = store.read( file );
+        ReleaseDescriptor rereadDescriptor = store.read( file ).build();
 
         assertAndAdjustScmPassword( config, rereadDescriptor );
         assertAndAdjustScmPrivateKeyPassPhrase( config, rereadDescriptor );
 
-        assertEquals( "compare configuration", config, rereadDescriptor );
+        assertEquals( "compare configuration", config.build(), rereadDescriptor );
     }
 
     public void testDeleteFile()
@@ -255,10 +257,10 @@
         file.createNewFile();
         assertTrue( "Check file already exists", file.exists() );
 
-        ReleaseDescriptor config = createReleaseConfigurationForWriting();
+        ReleaseDescriptorBuilder config = createReleaseConfigurationForWriting();
         config.setWorkingDirectory( AbstractReleaseTestCase.getPath( file.getParentFile() ) );
 
-        store.delete( config );
+        store.delete( config.build() );
 
         assertFalse( "Check file already exists", file.exists() );
     }
@@ -271,35 +273,35 @@
         file.delete();
         assertFalse( "Check file already exists", file.exists() );
 
-        ReleaseDescriptor config = createReleaseConfigurationForWriting();
+        ReleaseDescriptorBuilder config = createReleaseConfigurationForWriting();
         config.setWorkingDirectory( AbstractReleaseTestCase.getPath( file.getParentFile() ) );
 
-        store.delete( config );
+        store.delete( config.build() );
 
         assertFalse( "Check file already exists", file.exists() );
     }
 
-    private ReleaseDescriptor createReleaseConfigurationForWriting()
+    private ReleaseDescriptorBuilder createReleaseConfigurationForWriting()
     {
-        ReleaseDescriptor config = new ReleaseDescriptor();
-        config.setCompletedPhase( "completed-phase-write" );
-        config.setCommitByProject( true );
-        config.setScmSourceUrl( "url-write" );
-        config.setScmId( "id-write" );
-        config.setScmUsername( "username-write" );
-        config.setScmPassword( "password-write" );
-        config.setScmPrivateKey( "private-key-write" );
-        config.setScmPrivateKeyPassPhrase( "passphrase-write" );
-        config.setScmTagBase( "tag-base-write" );
-        config.setScmBranchBase( "branch-base-write" );
-        config.setScmReleaseLabel( "tag-write" );
-        config.setAdditionalArguments( "additional-args-write" );
-        config.setPreparationGoals( "preparation-goals-write" );
-        config.setCompletionGoals( "completion-goals-write" );
-        config.setPomFileName( "pom-file-name-write" );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setCompletedPhase( "completed-phase-write" );
+        builder.setCommitByProject( true );
+        builder.setScmSourceUrl( "url-write" );
+        builder.setScmId( "id-write" );
+        builder.setScmUsername( "username-write" );
+        builder.setScmPassword( "password-write" );
+        builder.setScmPrivateKey( "private-key-write" );
+        builder.setScmPrivateKeyPassPhrase( "passphrase-write" );
+        builder.setScmTagBase( "tag-base-write" );
+        builder.setScmBranchBase( "branch-base-write" );
+        builder.setScmReleaseLabel( "tag-write" );
+        builder.setAdditionalArguments( "additional-args-write" );
+        builder.setPreparationGoals( "preparation-goals-write" );
+        builder.setCompletionGoals( "completion-goals-write" );
+        builder.setPomFileName( "pom-file-name-write" );
 
-        config.mapReleaseVersion( "groupId:artifactId", "1.0" );
-        config.mapDevelopmentVersion( "groupId:artifactId", "1.1-SNAPSHOT" );
+        builder.addReleaseVersion( "groupId:artifactId", "1.0" );
+        builder.addDevelopmentVersion( "groupId:artifactId", "1.1-SNAPSHOT" );
 
         IdentifiedScm scm = new IdentifiedScm();
         scm.setId( "id-write" );
@@ -307,17 +309,17 @@
         scm.setDeveloperConnection( "developerConnection-write" );
         scm.setUrl( "url-write" );
         scm.setTag( "tag-write" );
-        config.mapOriginalScmInfo( "groupId:artifactId", scm );
+        builder.addOriginalScmInfo( "groupId:artifactId", scm );
 
         scm = new IdentifiedScm();
         scm.setConnection( "connection-write" );
         // omit optional elements
-        config.mapOriginalScmInfo( "groupId:subproject1", scm );
+        builder.addOriginalScmInfo( "groupId:subproject1", scm );
 
-        return config;
+        return builder;
     }
 
-    private static void assertDefaultReleaseConfiguration( ReleaseDescriptor config )
+    private static void assertDefaultReleaseConfiguration( BuilderReleaseDescriptor config )
     {
         assertNull( "Expected no completedPhase", config.getCompletedPhase() );
         assertFalse( "Expected no commitPerProject", config.isCommitByProject() );
@@ -340,16 +342,19 @@
         assertTrue( "Expected default interactive", config.isInteractive() );
         assertFalse( "Expected no addScema", config.isAddSchema() );
 
-        assertTrue( "Expected no release version mappings", config.getReleaseVersions().isEmpty() );
-        assertTrue( "Expected no dev version mappings", config.getDevelopmentVersions().isEmpty() );
+        for ( ReleaseStageVersions versions : config.getProjectVersions().values() )
+        {
+            assertNull( "Expected no release version mappings", versions.getRelease() );
+            assertNull( "Expected no dev version mappings", versions.getDevelopment() );
+        }
         assertTrue( "Expected no scm mappings", config.getOriginalScmInfo().isEmpty() );
         assertNotNull( "Expected resolved snapshot dependencies map", config.getResolvedSnapshotDependencies() );
     }
 
-    public ReleaseDescriptor createMergeConfiguration()
+    public ReleaseDescriptorBuilder createMergeConfiguration()
         throws IOException
     {
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
+        ReleaseDescriptorBuilder releaseDescriptor = new ReleaseDescriptorBuilder();
 
         releaseDescriptor.setScmSourceUrl( "scm-url" );
         releaseDescriptor.setScmUsername( "username" );
@@ -360,10 +365,10 @@
         return releaseDescriptor;
     }
 
-    private void assertAndAdjustScmPassword( ReleaseDescriptor expected, ReleaseDescriptor original )
+    private void assertAndAdjustScmPassword( ReleaseDescriptorBuilder expected, ReleaseDescriptor original )
         throws Exception
     {
-        String expectedPassword = expected.getScmPassword();
+        String expectedPassword = expected.build().getScmPassword();
         String originalPassword = original.getScmPassword();
 
         // encrypting the same password twice doesn't have to be the same result
@@ -373,13 +378,13 @@
 
             expected.setScmPassword( originalPassword );
         }
-        assertEquals( expected.getScmPassword(), original.getScmPassword() );
+        assertEquals( expected.build().getScmPassword(), original.getScmPassword() );
     }
 
-    private void assertAndAdjustScmPrivateKeyPassPhrase( ReleaseDescriptor expected, ReleaseDescriptor original )
+    private void assertAndAdjustScmPrivateKeyPassPhrase( ReleaseDescriptorBuilder expected, ReleaseDescriptor original )
         throws Exception
     {
-        String expectedPassPhrase = expected.getScmPrivateKeyPassPhrase();
+        String expectedPassPhrase = expected.build().getScmPrivateKeyPassPhrase();
         String originalPassPhrase = original.getScmPrivateKeyPassPhrase();
 
         // encrypting the same passphrase twice doesn't have to be the same result
@@ -389,54 +394,55 @@
 
             expected.setScmPrivateKeyPassPhrase( originalPassPhrase );
         }
-        assertEquals( expected.getScmPrivateKeyPassPhrase(), original.getScmPrivateKeyPassPhrase() );
+        assertEquals( expected.build().getScmPrivateKeyPassPhrase(), original.getScmPrivateKeyPassPhrase() );
     }
 
-    private ReleaseDescriptor createExpectedReleaseConfiguration()
+    private ReleaseDescriptorBuilder createExpectedReleaseConfiguration()
     {
-        ReleaseDescriptor expected = new ReleaseDescriptor();
-        expected.setCompletedPhase( "step1" );
-        expected.setCommitByProject( true );
-        expected.setScmId( "scm-id" );
-        expected.setScmSourceUrl( "scm-url" );
-        expected.setScmUsername( "username" );
-        expected.setScmPassword( "password" );
-        expected.setScmPrivateKey( "private-key" );
-        expected.setScmPrivateKeyPassPhrase( "passphrase" );
-        expected.setScmTagBase( "tagBase" );
-        expected.setScmTagNameFormat( "expectedTagNameFormat" );
-        expected.setScmBranchBase( "branchBase" );
-        expected.setScmReleaseLabel( "tag" );
-        expected.setAdditionalArguments( "additional-arguments" );
-        expected.setPreparationGoals( "preparation-goals" );
-        expected.setCompletionGoals( "completion-goals" );
-        expected.setPomFileName( "pom-file-name" );
-        expected.setWorkingDirectory( null );
-        expected.setGenerateReleasePoms( false );
-        expected.setScmUseEditMode( false );
-        expected.setInteractive( true );
-        expected.setAddSchema( false );
-        expected.mapReleaseVersion( "groupId:artifactId1", "2.0" );
-        expected.mapReleaseVersion( "groupId:artifactId2", "3.0" );
-        expected.mapDevelopmentVersion( "groupId:artifactId1", "2.1-SNAPSHOT" );
-        expected.mapDevelopmentVersion( "groupId:artifactId2", "3.0.1-SNAPSHOT" );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setCompletedPhase( "step1" );
+        builder.setCommitByProject( true );
+        builder.setScmId( "scm-id" );
+        builder.setScmSourceUrl( "scm-url" );
+        builder.setScmUsername( "username" );
+        builder.setScmPassword( "password" );
+        builder.setScmPrivateKey( "private-key" );
+        builder.setScmPrivateKeyPassPhrase( "passphrase" );
+        builder.setScmTagBase( "tagBase" );
+        builder.setScmTagNameFormat( "expectedTagNameFormat" );
+        builder.setScmBranchBase( "branchBase" );
+        builder.setScmReleaseLabel( "tag" );
+        builder.setAdditionalArguments( "additional-arguments" );
+        builder.setPreparationGoals( "preparation-goals" );
+        builder.setCompletionGoals( "completion-goals" );
+        builder.setPomFileName( "pom-file-name" );
+        builder.setWorkingDirectory( null );
+        builder.setGenerateReleasePoms( false );
+        builder.setScmUseEditMode( false );
+        builder.setInteractive( true );
+        builder.setAddSchema( false );
+        builder.addReleaseVersion( "groupId:artifactId1", "2.0" );
+        builder.addReleaseVersion( "groupId:artifactId2", "3.0" );
+        builder.addDevelopmentVersion( "groupId:artifactId1", "2.1-SNAPSHOT" );
+        builder.addDevelopmentVersion( "groupId:artifactId2", "3.0.1-SNAPSHOT" );
         IdentifiedScm scm = new IdentifiedScm();
         scm.setId( "id" );
         scm.setConnection( "connection" );
         scm.setDeveloperConnection( "developerConnection" );
         scm.setUrl( "url" );
         scm.setTag( "tag" );
-        expected.mapOriginalScmInfo( "groupId:artifactId1", scm );
+        builder.addOriginalScmInfo( "groupId:artifactId1", scm );
         scm = new IdentifiedScm();
         scm.setId( null );
         scm.setConnection( "connection2" );
         scm.setUrl( "url2" );
         scm.setTag( null );
         scm.setDeveloperConnection( null );
-        expected.mapOriginalScmInfo( "groupId:artifactId2", scm );
-        expected.mapResolvedSnapshotDependencies( "external:artifactId", "1.0", "1.1-SNAPSHOT" );
+        builder.addOriginalScmInfo( "groupId:artifactId2", scm );
+        builder.addDependencyReleaseVersion( "external:artifactId",  "1.0" );
+        builder.addDependencyDevelopmentVersion( "external:artifactId", "1.1-SNAPSHOT" );
 
-        return expected;
+        return builder;
     }
 
 }
diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/config/ReleaseDescriptorStoreStub.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/config/ReleaseDescriptorStoreStub.java
index 7470bd2..1352d28 100644
--- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/config/ReleaseDescriptorStoreStub.java
+++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/config/ReleaseDescriptorStoreStub.java
@@ -30,19 +30,17 @@
     /**
      * The release configuration to use.
      */
-    private ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
+    private ReleaseDescriptorBuilder releaseDescriptor = new ReleaseDescriptorBuilder();
 
     @Override
-    public ReleaseDescriptor read( ReleaseDescriptor mergeDescriptor )
+    public ReleaseDescriptorBuilder read( ReleaseDescriptorBuilder mergeDescriptor )
     {
-        ReleaseUtils.merge( releaseDescriptor, mergeDescriptor );
-        return releaseDescriptor;
+        return mergeDescriptor;
     }
 
     @Override
     public void write( ReleaseDescriptor config )
     {
-        this.releaseDescriptor = config;
     }
 
     @Override
@@ -50,7 +48,7 @@
     {
     }
 
-    public ReleaseDescriptor getReleaseConfiguration()
+    public ReleaseDescriptorBuilder getReleaseConfiguration()
     {
         return releaseDescriptor;
     }
diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/config/ReleaseUtilsTest.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/config/ReleaseUtilsTest.java
index ea85a18..4cff313 100644
--- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/config/ReleaseUtilsTest.java
+++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/config/ReleaseUtilsTest.java
@@ -23,11 +23,11 @@
 
 import org.apache.maven.artifact.ArtifactUtils;
 import org.apache.maven.model.Scm;
+import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder.BuilderReleaseDescriptor;
 import org.apache.maven.shared.release.phase.AbstractReleaseTestCase;
 
 import java.io.File;
 import java.io.IOException;
-import java.util.Map;
 import java.util.Properties;
 
 /**
@@ -38,220 +38,171 @@
 public class ReleaseUtilsTest
     extends TestCase
 {
-    public void testMergeConfigurationSourceEmpty()
-        throws IOException
-    {
-        ReleaseDescriptor mergeDescriptor = createReleaseDescriptor();
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        ReleaseDescriptor mergedReleaseDescriptor = ReleaseUtils.merge( releaseDescriptor, mergeDescriptor );
-        ReleaseDescriptor mergedMergeDescriptor = ReleaseUtils.merge( mergeDescriptor, releaseDescriptor );
-
-        assertEquals( "Check merge", mergedReleaseDescriptor, mergedMergeDescriptor );
-    }
-
-    public void testMergeEqualsWithUpdateWorkingCopyTrue()
-        throws IOException
-    {
-        ReleaseDescriptor mergeDescriptor = createReleaseDescriptor();
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-
-        ReleaseDescriptor mergedReleaseDescriptor = ReleaseUtils.merge( releaseDescriptor, mergeDescriptor );
-        ReleaseDescriptor mergedMergeDescriptor = ReleaseUtils.merge( mergeDescriptor, releaseDescriptor );
-
-        assertEquals( "Check merge", mergedReleaseDescriptor, mergedMergeDescriptor );
-    }
-
-    public void testMergeConfigurationDestEmpty()
-        throws IOException
-    {
-        ReleaseDescriptor releaseDescriptor = createReleaseDescriptor();
-        ReleaseDescriptor mergedReleaseDescriptor = ReleaseUtils.merge( releaseDescriptor, new ReleaseDescriptor() );
-        ReleaseDescriptor expectedDescriptor = copyReleaseDescriptor( mergedReleaseDescriptor );
-
-        assertEquals( "Check merge", expectedDescriptor, releaseDescriptor );
-    }
-
-    public void testMergeConfiguration()
-        throws IOException
-    {
-        File workingDirectory = new File( "." );
-
-        ReleaseDescriptor mergeDescriptor =
-            createMergeDescriptor( AbstractReleaseTestCase.getPath( workingDirectory ), "completed-phase-merge" );
-
-        ReleaseDescriptor releaseDescriptor = createReleaseDescriptor();
-        releaseDescriptor = ReleaseUtils.merge( releaseDescriptor, mergeDescriptor );
-
-        ReleaseDescriptor expected =
-            createMergeDescriptor( releaseDescriptor.getWorkingDirectory(), releaseDescriptor.getCompletedPhase() );
-        assertEquals( "Check merge", expected, releaseDescriptor );
-    }
-
     public void testEquals()
         throws IOException
     {
-        ReleaseDescriptor originalReleaseDescriptor = createReleaseDescriptor();
-        ReleaseDescriptor releaseDescriptor = copyReleaseDescriptor( originalReleaseDescriptor );
-        doEqualsAssertions( releaseDescriptor, originalReleaseDescriptor, "other", new File( "f" ) );
+        ReleaseDescriptorBuilder originalReleaseDescriptor = createReleaseDescriptor();
+        ReleaseDescriptorBuilder builder = copyReleaseDescriptor( originalReleaseDescriptor.build() );
+        doEqualsAssertions( builder, originalReleaseDescriptor, "other", new File( "f" ) );
         originalReleaseDescriptor = createReleaseDescriptor();
-        releaseDescriptor = copyReleaseDescriptor( originalReleaseDescriptor );
-        doEqualsAssertions( originalReleaseDescriptor, releaseDescriptor, "other", new File( "f" ) );
+        builder = copyReleaseDescriptor( originalReleaseDescriptor.build() );
+        doEqualsAssertions( originalReleaseDescriptor, builder, "other", new File( "f" ) );
 
         originalReleaseDescriptor = createReleaseDescriptor();
-        releaseDescriptor = copyReleaseDescriptor( originalReleaseDescriptor );
-        doEqualsAssertions( releaseDescriptor, originalReleaseDescriptor, null, null );
+        builder = copyReleaseDescriptor( originalReleaseDescriptor.build() );
+        doEqualsAssertions( builder, originalReleaseDescriptor, null, null );
         originalReleaseDescriptor = createReleaseDescriptor();
-        releaseDescriptor = copyReleaseDescriptor( originalReleaseDescriptor );
-        doEqualsAssertions( originalReleaseDescriptor, releaseDescriptor, null, null );
+        builder = copyReleaseDescriptor( originalReleaseDescriptor.build() );
+        doEqualsAssertions( originalReleaseDescriptor, builder, null, null );
 
-        assertEquals( "test ==", releaseDescriptor, releaseDescriptor );
+        assertEquals( "test ==", builder, builder );
         Object obj = this;
-        assertFalse( "test class instance", releaseDescriptor.equals( obj ) );
+        assertFalse( "test class instance", builder.equals( obj ) );
     }
 
-    private static void doEqualsAssertions( ReleaseDescriptor releaseDescriptor,
-                                            ReleaseDescriptor originalReleaseDescriptor, String other, File otherFile )
+    private static void doEqualsAssertions( ReleaseDescriptorBuilder releaseDescriptor,
+                                            ReleaseDescriptorBuilder originalReleaseDescriptor, String other, File otherFile )
         throws IOException
     {
-        ReleaseDescriptor origConfig = originalReleaseDescriptor;
-        ReleaseDescriptor config = releaseDescriptor;
-        assertEquals( "Check original comparison", config, origConfig );
+        BuilderReleaseDescriptor origConfig = originalReleaseDescriptor.build();
+        ReleaseDescriptorBuilder configBuilder = releaseDescriptor;
+        assertEquals( "Check original comparison", configBuilder.build(), origConfig );
 
-        config.setScmSourceUrl( other );
-        assertFalse( "Check original comparison", config.equals( origConfig ) );
-        config.setScmSourceUrl( origConfig.getScmSourceUrl() );
+        configBuilder.setScmSourceUrl( other );
+        assertFalse( "Check original comparison", configBuilder.build().equals( origConfig ) );
+        configBuilder.setScmSourceUrl( origConfig.getScmSourceUrl() );
 
-        config.setAdditionalArguments( other );
-        assertFalse( "Check original comparison", config.equals( origConfig ) );
-        config.setAdditionalArguments( origConfig.getAdditionalArguments() );
+        configBuilder.setAdditionalArguments( other );
+        assertFalse( "Check original comparison", configBuilder.build().equals( origConfig ) );
+        configBuilder.setAdditionalArguments( origConfig.getAdditionalArguments() );
 
-        config.setAddSchema( !origConfig.isAddSchema() );
-        assertFalse( "Check original comparison", config.equals( origConfig ) );
-        config.setAddSchema( origConfig.isAddSchema() );
+        configBuilder.setAddSchema( !origConfig.isAddSchema() );
+        assertFalse( "Check original comparison", configBuilder.build().equals( origConfig ) );
+        configBuilder.setAddSchema( origConfig.isAddSchema() );
 
-        config.setGenerateReleasePoms( !origConfig.isAddSchema() );
-        assertFalse( "Check original comparison", config.equals( origConfig ) );
-        config.setGenerateReleasePoms( origConfig.isGenerateReleasePoms() );
+        configBuilder.setGenerateReleasePoms( !origConfig.isAddSchema() );
+        assertFalse( "Check original comparison", configBuilder.build().equals( origConfig ) );
+        configBuilder.setGenerateReleasePoms( origConfig.isGenerateReleasePoms() );
 
-        config.setScmUseEditMode( !origConfig.isScmUseEditMode() );
-        assertFalse( "Check original comparison", config.equals( origConfig ) );
-        config.setScmUseEditMode( origConfig.isScmUseEditMode() );
+        configBuilder.setScmUseEditMode( !origConfig.isScmUseEditMode() );
+        assertFalse( "Check original comparison", configBuilder.build().equals( origConfig ) );
+        configBuilder.setScmUseEditMode( origConfig.isScmUseEditMode() );
 
-        config.setInteractive( !origConfig.isInteractive() );
-        assertFalse( "Check original comparison", config.equals( origConfig ) );
-        config.setInteractive( origConfig.isInteractive() );
+        configBuilder.setInteractive( !origConfig.isInteractive() );
+        assertFalse( "Check original comparison", configBuilder.build().equals( origConfig ) );
+        configBuilder.setInteractive( origConfig.isInteractive() );
 
-        config.setCommitByProject( !origConfig.isCommitByProject() );
-        assertFalse( "Check original comparison", config.equals( origConfig ) );
-        config.setCommitByProject( origConfig.isCommitByProject() );
+        configBuilder.setCommitByProject( !origConfig.isCommitByProject() );
+        assertFalse( "Check original comparison", configBuilder.build().equals( origConfig ) );
+        configBuilder.setCommitByProject( origConfig.isCommitByProject() );
 
-        config.setCompletedPhase( other );
-        assertFalse( "Check original comparison", config.equals( origConfig ) );
-        config.setCompletedPhase( origConfig.getCompletedPhase() );
+        configBuilder.setCompletedPhase( other );
+        assertFalse( "Check original comparison", configBuilder.build().equals( origConfig ) );
+        configBuilder.setCompletedPhase( origConfig.getCompletedPhase() );
 
-        config.setScmPrivateKeyPassPhrase( other );
-        assertFalse( "Check original comparison", config.equals( origConfig ) );
-        config.setScmPrivateKeyPassPhrase( origConfig.getScmPrivateKeyPassPhrase() );
+        configBuilder.setScmPrivateKeyPassPhrase( other );
+        assertFalse( "Check original comparison", configBuilder.build().equals( origConfig ) );
+        configBuilder.setScmPrivateKeyPassPhrase( origConfig.getScmPrivateKeyPassPhrase() );
 
-        config.setScmPassword( other );
-        assertFalse( "Check original comparison", config.equals( origConfig ) );
-        config.setScmPassword( origConfig.getScmPassword() );
+        configBuilder.setScmPassword( other );
+        assertFalse( "Check original comparison", configBuilder.build().equals( origConfig ) );
+        configBuilder.setScmPassword( origConfig.getScmPassword() );
 
-        config.setScmUsername( other );
-        assertFalse( "Check original comparison", config.equals( origConfig ) );
-        config.setScmUsername( origConfig.getScmUsername() );
+        configBuilder.setScmUsername( other );
+        assertFalse( "Check original comparison", configBuilder.build().equals( origConfig ) );
+        configBuilder.setScmUsername( origConfig.getScmUsername() );
 
-        config.setScmPrivateKey( other );
-        assertFalse( "Check original comparison", config.equals( origConfig ) );
-        config.setScmPrivateKey( origConfig.getScmPrivateKey() );
+        configBuilder.setScmPrivateKey( other );
+        assertFalse( "Check original comparison", configBuilder.build().equals( origConfig ) );
+        configBuilder.setScmPrivateKey( origConfig.getScmPrivateKey() );
 
-        config.setPomFileName( other );
-        assertFalse( "Check original comparison", config.equals( origConfig ) );
-        config.setPomFileName( origConfig.getPomFileName() );
+        configBuilder.setPomFileName( other );
+        assertFalse( "Check original comparison", configBuilder.build().equals( origConfig ) );
+        configBuilder.setPomFileName( origConfig.getPomFileName() );
 
-        config.setPreparationGoals( other );
-        assertFalse( "Check original comparison", config.equals( origConfig ) );
-        config.setPreparationGoals( origConfig.getPreparationGoals() );
+        configBuilder.setPreparationGoals( other );
+        assertFalse( "Check original comparison", configBuilder.build().equals( origConfig ) );
+        configBuilder.setPreparationGoals( origConfig.getPreparationGoals() );
 
-        config.setScmReleaseLabel( other );
-        assertFalse( "Check original comparison", config.equals( origConfig ) );
-        config.setScmReleaseLabel( origConfig.getScmReleaseLabel() );
+        configBuilder.setScmReleaseLabel( other );
+        assertFalse( "Check original comparison", configBuilder.build().equals( origConfig ) );
+        configBuilder.setScmReleaseLabel( origConfig.getScmReleaseLabel() );
 
-        config.setScmTagBase( other );
-        assertFalse( "Check original comparison", config.equals( origConfig ) );
-        config.setScmTagBase( origConfig.getScmTagBase() );
+        configBuilder.setScmTagBase( other );
+        assertFalse( "Check original comparison", configBuilder.build().equals( origConfig ) );
+        configBuilder.setScmTagBase( origConfig.getScmTagBase() );
 
         if ( otherFile != null )
         {
-            config.setWorkingDirectory( AbstractReleaseTestCase.getPath( otherFile ) );
-            assertFalse( "Check original comparison", config.equals( origConfig ) );
+            configBuilder.setWorkingDirectory( AbstractReleaseTestCase.getPath( otherFile ) );
+            assertFalse( "Check original comparison", configBuilder.build().equals( origConfig ) );
         }
 
-        config.setWorkingDirectory( origConfig.getWorkingDirectory() );
+        configBuilder.setWorkingDirectory( origConfig.getWorkingDirectory() );
 
         // sanity check the test was resetting correctly
-        assertEquals( "Check original comparison", config, origConfig );
+        assertEquals( "Check original comparison", configBuilder.build(), origConfig );
 
-        config.mapDevelopmentVersion( "groupId:artifactId", "1.0-SNAPSHOT" );
-        assertFalse( "Check original comparison", config.equals( origConfig ) );
-        config = copyReleaseDescriptor( origConfig );
+        configBuilder.addDevelopmentVersion( "groupId:artifactId", "1.0-SNAPSHOT" );
+        assertFalse( "Check original comparison", configBuilder.build().equals( origConfig ) );
+        configBuilder = copyReleaseDescriptor( origConfig );
 
-        config.mapReleaseVersion( "groupId:artifactId", "1.0" );
-        assertFalse( "Check original comparison", config.equals( origConfig ) );
-        config = copyReleaseDescriptor( origConfig );
+        configBuilder.addReleaseVersion( "groupId:artifactId", "1.0" );
+        assertFalse( "Check original comparison", configBuilder.build().equals( origConfig ) );
+        configBuilder = copyReleaseDescriptor( origConfig );
 
-        config.mapOriginalScmInfo( "groupId:artifactId", new Scm() );
-        assertFalse( "Check original comparison", config.equals( origConfig ) );
-        config = copyReleaseDescriptor( origConfig );
+        configBuilder.addOriginalScmInfo( "groupId:artifactId", new Scm() );
+        assertFalse( "Check original comparison", configBuilder.build().equals( origConfig ) );
+        configBuilder = copyReleaseDescriptor( origConfig );
 
-        config.mapOriginalScmInfo( "groupId:artifactId", new Scm() );
-        origConfig.mapOriginalScmInfo( "foo", new Scm() );
-        assertFalse( "Check original comparison", config.equals( origConfig ) );
-        origConfig = createReleaseDescriptor();
-        config = copyReleaseDescriptor( origConfig );
+        configBuilder.addOriginalScmInfo( "groupId:artifactId", new Scm() );
+        origConfig.addOriginalScmInfo( "foo", new Scm() );
+        assertFalse( "Check original comparison", configBuilder.build().equals( origConfig ) );
+        origConfig = createReleaseDescriptor().build();
+        configBuilder = copyReleaseDescriptor( origConfig );
 
-        config.mapOriginalScmInfo( "groupId:artifactId", new Scm() );
-        origConfig.mapOriginalScmInfo( "groupId:artifactId", new Scm() );
-        assertEquals( "Check original comparison", config, origConfig );
-        origConfig = createReleaseDescriptor();
-        config = copyReleaseDescriptor( origConfig );
+        configBuilder.addOriginalScmInfo( "groupId:artifactId", new Scm() );
+        origConfig.addOriginalScmInfo( "groupId:artifactId", new Scm() );
+        assertEquals( "Check original comparison", configBuilder.build(), origConfig );
+        origConfig = createReleaseDescriptor().build();
+        configBuilder = copyReleaseDescriptor( origConfig );
 
-        config.mapOriginalScmInfo( "groupId:artifactId", getScm( "conn", "dev", "url", "tag" ) );
-        origConfig.mapOriginalScmInfo( "groupId:artifactId", getScm( "conn", "dev", "url", "tag" ) );
-        assertEquals( "Check original comparison", config, origConfig );
-        origConfig = createReleaseDescriptor();
-        config = copyReleaseDescriptor( origConfig );
+        configBuilder.addOriginalScmInfo( "groupId:artifactId", getScm( "conn", "dev", "url", "tag" ) );
+        origConfig.addOriginalScmInfo( "groupId:artifactId", getScm( "conn", "dev", "url", "tag" ) );
+        assertEquals( "Check original comparison", configBuilder.build(), origConfig );
+        origConfig = createReleaseDescriptor().build();
+        configBuilder = copyReleaseDescriptor( origConfig );
 
-        config.mapOriginalScmInfo( "groupId:artifactId", getScm( "-", "dev", "url", "tag" ) );
-        origConfig.mapOriginalScmInfo( "groupId:artifactId", getScm( "conn", "dev", "url", "tag" ) );
-        assertFalse( "Check original comparison", config.equals( origConfig ) );
-        origConfig = createReleaseDescriptor();
-        config = copyReleaseDescriptor( origConfig );
+        configBuilder.addOriginalScmInfo( "groupId:artifactId", getScm( "-", "dev", "url", "tag" ) );
+        origConfig.addOriginalScmInfo( "groupId:artifactId", getScm( "conn", "dev", "url", "tag" ) );
+        assertFalse( "Check original comparison", configBuilder.build().equals( origConfig ) );
+        origConfig = createReleaseDescriptor().build();
+        configBuilder = copyReleaseDescriptor( origConfig );
 
-        config.mapOriginalScmInfo( "groupId:artifactId", getScm( "conn", "-", "url", "tag" ) );
-        origConfig.mapOriginalScmInfo( "groupId:artifactId", getScm( "conn", "dev", "url", "tag" ) );
-        assertFalse( "Check original comparison", config.equals( origConfig ) );
-        origConfig = createReleaseDescriptor();
-        config = copyReleaseDescriptor( origConfig );
+        configBuilder.addOriginalScmInfo( "groupId:artifactId", getScm( "conn", "-", "url", "tag" ) );
+        origConfig.addOriginalScmInfo( "groupId:artifactId", getScm( "conn", "dev", "url", "tag" ) );
+        assertFalse( "Check original comparison", configBuilder.build().equals( origConfig ) );
+        origConfig = createReleaseDescriptor().build();
+        configBuilder = copyReleaseDescriptor( origConfig );
 
-        config.mapOriginalScmInfo( "groupId:artifactId", getScm( "conn", "dev", "-", "tag" ) );
-        origConfig.mapOriginalScmInfo( "groupId:artifactId", getScm( "conn", "dev", "url", "tag" ) );
-        assertFalse( "Check original comparison", config.equals( origConfig ) );
-        origConfig = createReleaseDescriptor();
-        config = copyReleaseDescriptor( origConfig );
+        configBuilder.addOriginalScmInfo( "groupId:artifactId", getScm( "conn", "dev", "-", "tag" ) );
+        origConfig.addOriginalScmInfo( "groupId:artifactId", getScm( "conn", "dev", "url", "tag" ) );
+        assertFalse( "Check original comparison", configBuilder.build().equals( origConfig ) );
+        origConfig = createReleaseDescriptor().build();
+        configBuilder = copyReleaseDescriptor( origConfig );
 
-        config.mapOriginalScmInfo( "groupId:artifactId", getScm( "conn", "dev", "url", "-" ) );
-        origConfig.mapOriginalScmInfo( "groupId:artifactId", getScm( "conn", "dev", "url", "tag" ) );
-        assertFalse( "Check original comparison", config.equals( origConfig ) );
+        configBuilder.addOriginalScmInfo( "groupId:artifactId", getScm( "conn", "dev", "url", "-" ) );
+        origConfig.addOriginalScmInfo( "groupId:artifactId", getScm( "conn", "dev", "url", "tag" ) );
+        assertFalse( "Check original comparison", configBuilder.build().equals( origConfig ) );
     }
 
     public void testHashCode()
         throws IOException
     {
-        ReleaseDescriptor releaseDescriptor = createReleaseDescriptor();
+        ReleaseDescriptor releaseDescriptor = createReleaseDescriptor().build();
 
         assertEquals( "Check hash code", releaseDescriptor.hashCode(),
-                      createReleaseDescriptor( releaseDescriptor.getWorkingDirectory() ).hashCode() );
+                      createReleaseDescriptor( releaseDescriptor.getWorkingDirectory() ).build().hashCode() );
     }
 
     public void testLoadResolvedDependencies()
@@ -260,11 +211,13 @@
         String dependencyKey = ArtifactUtils.versionlessKey( "com.groupId", "artifactId" );
         properties.put( "dependency." + dependencyKey  + ".release", "1.3" );
         properties.put( "dependency." + dependencyKey + ".development", "1.3-SNAPSHOT" );
-        ReleaseDescriptor descriptor = ReleaseUtils.copyPropertiesToReleaseDescriptor( properties );
+        
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        ReleaseUtils.copyPropertiesToReleaseDescriptor( properties, builder );
+        ReleaseDescriptor descriptor = builder.build();
 
-        Map<String, String> versionMap = descriptor.getResolvedSnapshotDependencies().get( dependencyKey );
-        assertEquals( "1.3", versionMap.get( ReleaseDescriptor.RELEASE_KEY ) );
-        assertEquals( "1.3-SNAPSHOT", versionMap.get( ReleaseDescriptor.DEVELOPMENT_KEY) );
+        assertEquals( "1.3", descriptor.getDependencyReleaseVersion( dependencyKey ) );
+        assertEquals( "1.3-SNAPSHOT", descriptor.getDependencyDevelopmentVersion( dependencyKey ) );
     }
 
     // MRELEASE-750
@@ -275,13 +228,13 @@
         properties.put( "dependency." + relDependencyKey  + ".release", "1.3" );
         String devDependencyKey = ArtifactUtils.versionlessKey( "com.development.magic", "dependency" );
         properties.put( "dependency." + devDependencyKey + ".development", "1.3-SNAPSHOT" );
-        ReleaseDescriptor descriptor = ReleaseUtils.copyPropertiesToReleaseDescriptor( properties );
+        
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        ReleaseUtils.copyPropertiesToReleaseDescriptor( properties, builder );
+        ReleaseDescriptor descriptor = builder.build();
 
-        Map<String, String> versionMap = descriptor.getResolvedSnapshotDependencies().get( relDependencyKey );
-        assertEquals( "1.3", versionMap.get( ReleaseDescriptor.RELEASE_KEY ) );
-
-        versionMap = descriptor.getResolvedSnapshotDependencies().get( devDependencyKey );
-        assertEquals( "1.3-SNAPSHOT", versionMap.get( ReleaseDescriptor.DEVELOPMENT_KEY) );
+        assertEquals( "1.3", descriptor.getDependencyReleaseVersion( relDependencyKey ) );
+        assertEquals( "1.3-SNAPSHOT", descriptor.getDependencyDevelopmentVersion( devDependencyKey ) );
     }
 
     // MRELEASE-834
@@ -289,10 +242,10 @@
     {
         Properties properties = new Properties();
         properties.setProperty( "dependency.locations.enabled", "false" );
-        ReleaseUtils.copyPropertiesToReleaseDescriptor( properties );
+        ReleaseUtils.copyPropertiesToReleaseDescriptor( properties, new ReleaseDescriptorBuilder() );
     }
 
-    private static ReleaseDescriptor copyReleaseDescriptor( ReleaseDescriptor originalReleaseDescriptor )
+    private static ReleaseDescriptorBuilder copyReleaseDescriptor( ReleaseDescriptor originalReleaseDescriptor )
     {
         return createReleaseDescriptor( originalReleaseDescriptor.getWorkingDirectory() );
     }
@@ -307,25 +260,7 @@
         return scm;
     }
 
-    private static ReleaseDescriptor createMergeDescriptor( String workingDirectory, String completedPhase )
-    {
-        ReleaseDescriptor mergeDescriptor = new ReleaseDescriptor();
-        mergeDescriptor.setScmSourceUrl( "scm-url-merge" );
-        mergeDescriptor.setCompletedPhase( completedPhase );
-        mergeDescriptor.setScmPrivateKeyPassPhrase( "passphrase-merge" );
-        mergeDescriptor.setScmPassword( "password-merge" );
-        mergeDescriptor.setScmPrivateKey( "private-key-merge" );
-        mergeDescriptor.setScmTagBase( "tag-base-merge" );
-        mergeDescriptor.setScmReleaseLabel( "tag-merge" );
-        mergeDescriptor.setScmUsername( "username-merge" );
-        mergeDescriptor.setAdditionalArguments( "additional-arguments-merge" );
-        mergeDescriptor.setPomFileName( "pom-file-name-merge" );
-        mergeDescriptor.setPreparationGoals( "preparation-goals-merge" );
-        mergeDescriptor.setWorkingDirectory( workingDirectory );
-        return mergeDescriptor;
-    }
-
-    private static ReleaseDescriptor createReleaseDescriptor()
+    private static ReleaseDescriptorBuilder createReleaseDescriptor()
         throws IOException
     {
         File workingDirectory = new File( "." );
@@ -333,9 +268,9 @@
         return createReleaseDescriptor(AbstractReleaseTestCase.getPath( workingDirectory ) );
     }
 
-    private static ReleaseDescriptor createReleaseDescriptor( String workingDirectory )
+    private static ReleaseDescriptorBuilder createReleaseDescriptor( String workingDirectory )
     {
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
+        ReleaseDescriptorBuilder releaseDescriptor = new ReleaseDescriptorBuilder();
         releaseDescriptor.setScmSourceUrl( "scm-url" );
         releaseDescriptor.setCompletedPhase( "completed-phase" );
         releaseDescriptor.setScmPrivateKeyPassPhrase( "passphrase" );
diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/exec/ForkedMavenExecutorTest.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/exec/ForkedMavenExecutorTest.java
index 7ef8d6e..8b65593 100644
--- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/exec/ForkedMavenExecutorTest.java
+++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/exec/ForkedMavenExecutorTest.java
@@ -41,7 +41,6 @@
 import org.apache.maven.settings.io.xpp3.SettingsXpp3Writer;
 import org.apache.maven.shared.release.ReleaseResult;
 import org.apache.maven.shared.release.env.DefaultReleaseEnvironment;
-import org.apache.maven.shared.release.env.ReleaseEnvironment;
 import org.codehaus.plexus.PlexusTestCase;
 import org.codehaus.plexus.util.cli.Arg;
 import org.codehaus.plexus.util.cli.CommandLineException;
@@ -332,7 +331,7 @@
         proxy.setPassword( "proxy_password" );
         settings.addProxy( proxy );
 
-        ReleaseEnvironment releaseEnvironment = new DefaultReleaseEnvironment();
+        DefaultReleaseEnvironment releaseEnvironment = new DefaultReleaseEnvironment();
         releaseEnvironment.setSettings( settings );
 
         AbstractMavenExecutor executorSpy = spy( executor );
diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/exec/InvokerMavenExecutorTest.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/exec/InvokerMavenExecutorTest.java
index 3f4789d..57327e2 100644
--- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/exec/InvokerMavenExecutorTest.java
+++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/exec/InvokerMavenExecutorTest.java
@@ -36,7 +36,6 @@
 import org.apache.maven.shared.invoker.InvocationRequest;
 import org.apache.maven.shared.release.ReleaseResult;
 import org.apache.maven.shared.release.env.DefaultReleaseEnvironment;
-import org.apache.maven.shared.release.env.ReleaseEnvironment;
 import org.codehaus.plexus.PlexusTestCase;
 import org.codehaus.plexus.logging.Logger;
 import org.junit.Test;
@@ -156,7 +155,7 @@
         proxy.setPassword( "proxy_password" );
         settings.addProxy( proxy );
 
-        ReleaseEnvironment releaseEnvironment = new DefaultReleaseEnvironment();
+        DefaultReleaseEnvironment releaseEnvironment = new DefaultReleaseEnvironment();
         releaseEnvironment.setSettings( settings );
         releaseEnvironment.setMavenHome( new File( System.getProperty( "injectedMavenHome" ) ) );
 
diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/AbstractEditModeRewritingReleasePhaseTestCase.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/AbstractEditModeRewritingReleasePhaseTestCase.java
index 9d510cc..9bc40d8 100644
--- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/AbstractEditModeRewritingReleasePhaseTestCase.java
+++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/AbstractEditModeRewritingReleasePhaseTestCase.java
@@ -41,7 +41,8 @@
 import org.apache.maven.scm.repository.ScmRepository;
 import org.apache.maven.shared.release.ReleaseExecutionException;
 import org.apache.maven.shared.release.ReleaseFailureException;
-import org.apache.maven.shared.release.config.ReleaseDescriptor;
+import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder;
+import org.apache.maven.shared.release.config.ReleaseUtils;
 import org.apache.maven.shared.release.env.DefaultReleaseEnvironment;
 import org.apache.maven.shared.release.scm.DefaultScmRepositoryConfigurator;
 import org.apache.maven.shared.release.scm.ReleaseScmCommandException;
@@ -66,11 +67,11 @@
         throws Exception
     {
         List<MavenProject> reactorProjects = createReactorProjectsFromBasicPom();
-        ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects );
-        config.setScmUseEditMode( true );
-        mapNextVersion( config, "groupId:artifactId" );
+        ReleaseDescriptorBuilder builder = createDescriptorFromBasicPom( reactorProjects );
+        builder.setScmUseEditMode( true );
+        mapNextVersion( builder, "groupId:artifactId" );
 
-        phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         assertTrue( comparePomFiles( reactorProjects ) );
     }
@@ -80,21 +81,21 @@
         throws Exception
     {
         List<MavenProject> reactorProjects = createReactorProjectsFromBasicPom();
-        ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects );
-        config.setScmUseEditMode( true );
-        mapNextVersion( config, "groupId:artifactId" );
+        ReleaseDescriptorBuilder builder = createDescriptorFromBasicPom( reactorProjects );
+        builder.setScmUseEditMode( true );
+        mapNextVersion( builder, "groupId:artifactId" );
 
         ScmManagerStub scmManager = new ScmManagerStub();
         DefaultScmRepositoryConfigurator configurator =
             (DefaultScmRepositoryConfigurator) lookup( ScmRepositoryConfigurator.class, "default" );
         configurator.setScmManager( scmManager );
 
-        ScmProviderStub providerStub = (ScmProviderStub) scmManager.getProviderByUrl( config.getScmSourceUrl() );
+        ScmProviderStub providerStub = (ScmProviderStub) scmManager.getProviderByUrl( ReleaseUtils.buildReleaseDescriptor( builder ).getScmSourceUrl() );
         providerStub.setEditScmResult( new EditScmResult( "", "", "", false ) );
 
         try
         {
-            phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "Should have thrown an exception" );
         }
@@ -110,9 +111,9 @@
     {
         // prepare
         List<MavenProject> reactorProjects = createReactorProjectsFromBasicPom();
-        ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects );
-        config.setScmUseEditMode( true );
-        mapNextVersion( config, "groupId:artifactId" );
+        ReleaseDescriptorBuilder builder = createDescriptorFromBasicPom( reactorProjects );
+        builder.setScmUseEditMode( true );
+        mapNextVersion( builder, "groupId:artifactId" );
 
         ScmProvider scmProviderMock = mock( ScmProvider.class );
         when( scmProviderMock.edit( isA( ScmRepository.class ),
@@ -127,7 +128,7 @@
         // execute
         try
         {
-            phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "Should have thrown an exception" );
         }
@@ -145,9 +146,9 @@
         throws Exception
     {
         List<MavenProject> reactorProjects = createReactorProjects( "internal-snapshot-plugin-deps" );
-        ReleaseDescriptor config = createDefaultConfiguration( reactorProjects );
+        ReleaseDescriptorBuilder builder = createDefaultConfiguration( reactorProjects );
 
-        phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         assertTrue( comparePomFiles( reactorProjects ) );
     }
@@ -157,11 +158,11 @@
         throws Exception
     {
         List<MavenProject> reactorProjects = createReactorProjects( "internal-snapshot-plugin-deps" );
-        ReleaseDescriptor config = createUnmappedConfiguration( reactorProjects );
+        ReleaseDescriptorBuilder builder = createUnmappedConfiguration( reactorProjects );
 
         try
         {
-            phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "Should have thrown an exception" );
         }
@@ -176,9 +177,9 @@
         throws Exception
     {
         List<MavenProject> reactorProjects = createReactorProjects( "internal-snapshot-profile" );
-        ReleaseDescriptor config = createDefaultConfiguration( reactorProjects );
+        ReleaseDescriptorBuilder builder = createDefaultConfiguration( reactorProjects );
 
-        phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         assertTrue( comparePomFiles( reactorProjects ) );
     }
@@ -188,11 +189,11 @@
         throws Exception
     {
         List<MavenProject> reactorProjects = createReactorProjects( "internal-snapshot-profile" );
-        ReleaseDescriptor config = createUnmappedConfiguration( reactorProjects );
+        ReleaseDescriptorBuilder builder = createUnmappedConfiguration( reactorProjects );
 
         try
         {
-            phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "Should have thrown an exception" );
         }
diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/AbstractReleaseTestCase.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/AbstractReleaseTestCase.java
index 2deaf8b..96eadcd 100644
--- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/AbstractReleaseTestCase.java
+++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/AbstractReleaseTestCase.java
@@ -57,6 +57,7 @@
 import org.apache.maven.project.ProjectSorter;
 import org.apache.maven.repository.internal.MavenRepositorySystemSession;
 import org.apache.maven.shared.release.PlexusJUnit4TestCase;
+import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder;
 import org.apache.maven.shared.release.util.ReleaseUtil;
 import org.sonatype.aether.impl.internal.SimpleLocalRepositoryManager;
 import org.sonatype.aether.repository.WorkspaceReader;
@@ -102,6 +103,16 @@
     {
         return createReactorProjects( path, path, subpath );
     }
+    
+    protected ReleaseDescriptorBuilder createReleaseDescriptorBuilder( List<MavenProject> reactorProjects )
+    {
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        for ( MavenProject project : reactorProjects )
+        {
+            builder.putOriginalVersion( project.getGroupId() + ':' + project.getArtifactId(), project.getVersion() );
+        }
+        return builder;
+    }
 
     /**
      *
diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/AbstractRewritingReleasePhaseTestCase.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/AbstractRewritingReleasePhaseTestCase.java
index 903cf93..427371c 100644
--- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/AbstractRewritingReleasePhaseTestCase.java
+++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/AbstractRewritingReleasePhaseTestCase.java
@@ -40,7 +40,8 @@
 import org.apache.maven.scm.repository.ScmRepositoryException;
 import org.apache.maven.shared.release.ReleaseExecutionException;
 import org.apache.maven.shared.release.ReleaseFailureException;
-import org.apache.maven.shared.release.config.ReleaseDescriptor;
+import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder;
+import org.apache.maven.shared.release.config.ReleaseUtils;
 import org.apache.maven.shared.release.env.DefaultReleaseEnvironment;
 import org.apache.maven.shared.release.scm.DefaultScmRepositoryConfigurator;
 import org.apache.maven.shared.release.scm.ReleaseScmRepositoryException;
@@ -81,7 +82,7 @@
         throws Exception
     {
         super.setUp();
-        phase = (ReleasePhase) lookup( ReleasePhase.class, getRoleHint() );
+        phase = lookup( ReleasePhase.class, getRoleHint() );
 
         if( phase instanceof AbstractRewritePomsPhase)
         {
@@ -96,10 +97,10 @@
         throws Exception
     {
         List<MavenProject> reactorProjects = createReactorProjectsFromBasicPom();
-        ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects );
-        mapNextVersion( config, "groupId:artifactId" );
+        ReleaseDescriptorBuilder builder = createDescriptorFromBasicPom( reactorProjects );
+        mapNextVersion( builder, "groupId:artifactId" );
 
-        phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         assertTrue( comparePomFiles( reactorProjects ) );
     }
@@ -109,10 +110,10 @@
         throws Exception
     {
         List<MavenProject> reactorProjects = createReactorProjects( "basic-pom-entities" );
-        ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects );
-        mapNextVersion( config, "groupId:artifactId" );
+        ReleaseDescriptorBuilder builder = createDescriptorFromBasicPom( reactorProjects );
+        mapNextVersion( builder, "groupId:artifactId" );
 
-        phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         assertTrue( comparePomFiles( reactorProjects ) );
     }
@@ -122,10 +123,10 @@
         throws Exception
     {
         List<MavenProject> reactorProjects = createReactorProjects( "basic-pom-namespace" );
-        ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects );
-        mapNextVersion( config, "groupId:artifactId" );
+        ReleaseDescriptorBuilder builder = createDescriptorFromBasicPom( reactorProjects );
+        mapNextVersion( builder, "groupId:artifactId" );
 
-        phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         assertTrue( comparePomFiles( reactorProjects ) );
     }
@@ -135,10 +136,10 @@
         throws Exception
     {
         List<MavenProject> reactorProjects = createReactorProjects( "basic-pom-with-encoding" );
-        ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects );
-        mapNextVersion( config, "groupId:artifactId" );
+        ReleaseDescriptorBuilder builder = createDescriptorFromBasicPom( reactorProjects );
+        mapNextVersion( builder, "groupId:artifactId" );
 
-        phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         assertTrue( comparePomFiles( reactorProjects ) );
     }
@@ -148,9 +149,9 @@
         throws Exception
     {
         List<MavenProject> reactorProjects = createReactorProjects( "pom-with-parent" );
-        ReleaseDescriptor config = createConfigurationForPomWithParentAlternateNextVersion( reactorProjects );
+        ReleaseDescriptorBuilder builder = createConfigurationForPomWithParentAlternateNextVersion( reactorProjects );
 
-        phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         assertTrue( comparePomFiles( reactorProjects ) );
     }
@@ -161,17 +162,17 @@
     {
 
         List<MavenProject> reactorProjects = createReactorProjects( "pom-with-parent" );
-        ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
+        ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects );
 
         // Process the child first
         reactorProjects = new ArrayList<>( reactorProjects );
         Collections.reverse( reactorProjects );
 
-        mapAlternateNextVersion( config, "groupId:subproject1" );
+        mapAlternateNextVersion( builder, "groupId:subproject1" );
 
         try
         {
-            phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "Should have thrown an exception" );
         }
@@ -187,27 +188,27 @@
     {
 
         List<MavenProject> reactorProjects = createReactorProjects( "pom-with-released-parent" );
-        ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
+        ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects );
 
-        mapAlternateNextVersion( config, "groupId:subproject1" );
-        config.mapReleaseVersion( "groupId:artifactId", "1" );
-        config.mapDevelopmentVersion( "groupId:artifactId", "1" );
+        mapAlternateNextVersion( builder, "groupId:subproject1" );
+        builder.addReleaseVersion( "groupId:artifactId", "1" );
+        builder.addDevelopmentVersion( "groupId:artifactId", "1" );
 
-        phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         assertTrue( comparePomFiles( reactorProjects ) );
     }
 
-    protected abstract void mapAlternateNextVersion( ReleaseDescriptor config, String projectId );
+    protected abstract void mapAlternateNextVersion( ReleaseDescriptorBuilder config, String projectId );
 
     @Test
     public void testRewritePomWithInheritedVersion()
         throws Exception
     {
         List<MavenProject> reactorProjects = createReactorProjects( "pom-with-inherited-version" );
-        ReleaseDescriptor config = createConfigurationForWithParentNextVersion( reactorProjects );
+        ReleaseDescriptorBuilder builder = createConfigurationForWithParentNextVersion( reactorProjects );
 
-        phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         assertTrue( comparePomFiles( reactorProjects ) );
     }
@@ -217,15 +218,15 @@
         throws Exception
     {
         List<MavenProject> reactorProjects = createReactorProjects( "pom-with-inherited-version" );
-        ReleaseDescriptor config = createConfigurationForPomWithParentAlternateNextVersion( reactorProjects );
+        ReleaseDescriptorBuilder builder = createConfigurationForPomWithParentAlternateNextVersion( reactorProjects );
 
-        phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         MavenProject project = getProjectsAsMap( reactorProjects ).get( "groupId:subproject1" );
         comparePomFiles( project, "-version-changed" );
     }
 
-    protected abstract ReleaseDescriptor createConfigurationForPomWithParentAlternateNextVersion( List<MavenProject> reactorProjects )
+    protected abstract ReleaseDescriptorBuilder createConfigurationForPomWithParentAlternateNextVersion( List<MavenProject> reactorProjects )
         throws Exception;
 
     @Test
@@ -233,10 +234,10 @@
         throws Exception
     {
         List<MavenProject> reactorProjects = createReactorProjects( "internal-snapshot-dependencies" );
-        ReleaseDescriptor config = createDefaultConfiguration( reactorProjects );
-        mapNextVersion( config, "groupId:subsubproject" );
+        ReleaseDescriptorBuilder builder = createDefaultConfiguration( reactorProjects );
+        mapNextVersion( builder, "groupId:subsubproject" );
 
-        phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         assertTrue( comparePomFiles( reactorProjects ) );
     }
@@ -246,11 +247,11 @@
         throws Exception
     {
         List<MavenProject> reactorProjects = createReactorProjects( "internal-snapshot-dependencies" );
-        ReleaseDescriptor config = createUnmappedConfiguration( reactorProjects );
+        ReleaseDescriptorBuilder builder = createUnmappedConfiguration( reactorProjects );
 
         try
         {
-            phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "Should have thrown an exception" );
         }
@@ -265,9 +266,9 @@
         throws Exception
     {
         List<MavenProject> reactorProjects = createReactorProjects( "internal-differing-snapshot-dependencies" );
-        ReleaseDescriptor config = createDifferingVersionConfiguration( reactorProjects );
+        ReleaseDescriptorBuilder builder = createDifferingVersionConfiguration( reactorProjects );
 
-        phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         assertTrue( comparePomFiles( reactorProjects ) );
     }
@@ -277,9 +278,9 @@
         throws Exception
     {
         List<MavenProject> reactorProjects = createReactorProjects( "internal-managed-snapshot-dependency" );
-        ReleaseDescriptor config = createMappedConfiguration( reactorProjects );
+        ReleaseDescriptorBuilder builder = createMappedConfiguration( reactorProjects );
 
-        phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         assertTrue( comparePomFiles( reactorProjects ) );
     }
@@ -289,11 +290,11 @@
         throws Exception
     {
         List<MavenProject> reactorProjects = createReactorProjects( "internal-managed-snapshot-dependency" );
-        ReleaseDescriptor config = createUnmappedConfiguration( reactorProjects );
+        ReleaseDescriptorBuilder builder = createUnmappedConfiguration( reactorProjects );
 
         try
         {
-            phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "Should have thrown an exception" );
         }
@@ -308,9 +309,9 @@
         throws Exception
     {
         List<MavenProject> reactorProjects = createReactorProjects( "internal-snapshot-plugins" );
-        ReleaseDescriptor config = createDefaultConfiguration( reactorProjects );
+        ReleaseDescriptorBuilder builder = createDefaultConfiguration( reactorProjects );
 
-        phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         assertTrue( comparePomFiles( reactorProjects ) );
     }
@@ -320,11 +321,11 @@
         throws Exception
     {
         List<MavenProject> reactorProjects = createReactorProjects( "internal-snapshot-plugins" );
-        ReleaseDescriptor config = createUnmappedConfiguration( reactorProjects );
+        ReleaseDescriptorBuilder builder = createUnmappedConfiguration( reactorProjects );
 
         try
         {
-            phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "Should have thrown an exception" );
         }
@@ -339,9 +340,9 @@
         throws Exception
     {
         List<MavenProject> reactorProjects = createReactorProjects( "internal-differing-snapshot-plugins" );
-        ReleaseDescriptor config = createDifferingVersionConfiguration( reactorProjects );
+        ReleaseDescriptorBuilder builder = createDifferingVersionConfiguration( reactorProjects );
 
-        phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         assertTrue( comparePomFiles( reactorProjects ) );
     }
@@ -351,9 +352,9 @@
         throws Exception
     {
         List<MavenProject> reactorProjects = createReactorProjects( "internal-managed-snapshot-plugin" );
-        ReleaseDescriptor config = createMappedConfiguration( reactorProjects );
+        ReleaseDescriptorBuilder builder = createMappedConfiguration( reactorProjects );
 
-        phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         assertTrue( comparePomFiles( reactorProjects ) );
     }
@@ -363,11 +364,11 @@
         throws Exception
     {
         List<MavenProject> reactorProjects = createReactorProjects( "internal-managed-snapshot-plugin" );
-        ReleaseDescriptor config = createUnmappedConfiguration( reactorProjects );
+        ReleaseDescriptorBuilder builder = createUnmappedConfiguration( reactorProjects );
 
         try
         {
-            phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "Should have thrown an exception" );
         }
@@ -382,9 +383,9 @@
         throws Exception
     {
         List<MavenProject> reactorProjects = createReactorProjects( "internal-snapshot-report-plugins" );
-        ReleaseDescriptor config = createDefaultConfiguration( reactorProjects );
+        ReleaseDescriptorBuilder builder = createDefaultConfiguration( reactorProjects );
 
-        phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         assertTrue( comparePomFiles( reactorProjects ) );
     }
@@ -394,11 +395,11 @@
         throws Exception
     {
         List<MavenProject> reactorProjects = createReactorProjects( "internal-snapshot-report-plugins" );
-        ReleaseDescriptor config = createUnmappedConfiguration( reactorProjects );
+        ReleaseDescriptorBuilder builder = createUnmappedConfiguration( reactorProjects );
 
         try
         {
-            phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "Should have thrown an exception" );
         }
@@ -413,9 +414,9 @@
         throws Exception
     {
         List<MavenProject> reactorProjects = createReactorProjects( "internal-differing-snapshot-report-plugins" );
-        ReleaseDescriptor config = createDifferingVersionConfiguration( reactorProjects );
+        ReleaseDescriptorBuilder builder = createDifferingVersionConfiguration( reactorProjects );
 
-        phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         assertTrue( comparePomFiles( reactorProjects ) );
     }
@@ -426,9 +427,9 @@
         throws Exception
     {
         List<MavenProject> reactorProjects = createReactorProjects( "internal-snapshot-extension" );
-        ReleaseDescriptor config = createDefaultConfiguration( reactorProjects );
+        ReleaseDescriptorBuilder builder = createDefaultConfiguration( reactorProjects );
 
-        phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         assertTrue( comparePomFiles( reactorProjects ) );
     }
@@ -439,11 +440,11 @@
         throws Exception
     {
         List<MavenProject> reactorProjects = createReactorProjects( "internal-snapshot-extension" );
-        ReleaseDescriptor config = createUnmappedConfiguration( reactorProjects );
+        ReleaseDescriptorBuilder builder = createUnmappedConfiguration( reactorProjects );
 
         try
         {
-            phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "Should have thrown an exception" );
         }
@@ -459,9 +460,9 @@
         throws Exception
     {
         List<MavenProject> reactorProjects = createReactorProjects( "internal-differing-snapshot-extension" );
-        ReleaseDescriptor config = createDifferingVersionConfiguration( reactorProjects );
+        ReleaseDescriptorBuilder builder = createDifferingVersionConfiguration( reactorProjects );
 
-        phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         assertTrue( comparePomFiles( reactorProjects ) );
     }
@@ -472,9 +473,9 @@
         throws Exception
     {
         List<MavenProject> reactorProjects = createReactorProjects( "pom-without-extension-version" );
-        ReleaseDescriptor config = createDefaultConfiguration( reactorProjects );
+        ReleaseDescriptorBuilder builder = createDefaultConfiguration( reactorProjects );
 
-        phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         assertTrue( comparePomFiles( reactorProjects ) );
     }
@@ -490,11 +491,11 @@
         {
             String path = "basic-pom";
             List<MavenProject> reactorProjects = prepareReactorProjects( path, copyFiles );
-            ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects );
-            mapNextVersion( config, "groupId:artifactId" );
-            config.setAddSchema( true );
+            ReleaseDescriptorBuilder builder = createDescriptorFromBasicPom( reactorProjects );
+            mapNextVersion( builder, "groupId:artifactId" );
+            builder.setAddSchema( true );
 
-            phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             comparePomFiles( reactorProjects, "-with-schema" );
 
@@ -510,9 +511,9 @@
     {
         // prepare
         List<MavenProject> reactorProjects = createReactorProjectsFromBasicPom();
-        ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects );
-        config.setScmUseEditMode( true );
-        mapNextVersion( config, "groupId:artifactId" );
+        ReleaseDescriptorBuilder builder = createDescriptorFromBasicPom( reactorProjects );
+        builder.setScmUseEditMode( true );
+        mapNextVersion( builder, "groupId:artifactId" );
 
         ScmProvider scmProviderMock = mock( ScmProvider.class );
 
@@ -523,7 +524,7 @@
         scmManager.setScmProvider( scmProviderMock );
 
         // execute
-        phase.simulate( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
         verifyNoMoreInteractions( scmProviderMock );
@@ -534,11 +535,11 @@
         throws Exception
     {
         List<MavenProject> reactorProjects = createReactorProjectsFromBasicPom();
-        ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects );
+        ReleaseDescriptorBuilder builder = createDescriptorFromBasicPom( reactorProjects );
 
         try
         {
-            phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "Should have thrown an exception" );
         }
@@ -554,12 +555,12 @@
     {
         // prepare
         List<MavenProject> reactorProjects = createReactorProjectsFromBasicPom();
-        ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects );
-        config.setScmUseEditMode( true );
-        config.setScmSourceUrl( "scm:svn:fail" );
-        mapNextVersion( config, "groupId:artifactId" );
+        ReleaseDescriptorBuilder builder = createDescriptorFromBasicPom( reactorProjects );
+        builder.setScmUseEditMode( true );
+        builder.setScmSourceUrl( "scm:svn:fail" );
+        mapNextVersion( builder, "groupId:artifactId" );
 
-        ScmManager scmManager = (ScmManager) lookup( ScmManager.class );
+        ScmManager scmManager = lookup( ScmManager.class );
         if ( scmManager instanceof ScmManagerStub )
         {
             ((ScmManagerStub) scmManager ).setException( new ScmRepositoryException( "..." ) );
@@ -567,7 +568,7 @@
 
         try
         {
-            phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "Should have thrown an exception" );
         }
@@ -583,10 +584,10 @@
     {
         // prepare
         List<MavenProject> reactorProjects = createReactorProjectsFromBasicPom();
-        ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects );
-        config.setScmUseEditMode( true );
-        config.setScmSourceUrl( "scm:fail:path" );
-        mapNextVersion( config, "groupId:artifactId" );
+        ReleaseDescriptorBuilder builder = createDescriptorFromBasicPom( reactorProjects );
+        builder.setScmUseEditMode( true );
+        builder.setScmSourceUrl( "scm:fail:path" );
+        mapNextVersion( builder, "groupId:artifactId" );
 
         ScmManager scmManager = (ScmManager) lookup( ScmManager.class );
         if ( scmManager instanceof ScmManagerStub )
@@ -597,7 +598,7 @@
         // execute
         try
         {
-            phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "Should have thrown an exception" );
         }
@@ -613,10 +614,10 @@
         throws Exception
     {
         List<MavenProject> reactorProjects = createReactorProjects( "whitespace-around-values" );
-        ReleaseDescriptor config = createConfigurationForPomWithParentAlternateNextVersion( reactorProjects );
-        mapNextVersion( config, "groupId:subproject2" );
+        ReleaseDescriptorBuilder builder = createConfigurationForPomWithParentAlternateNextVersion( reactorProjects );
+        mapNextVersion( builder, "groupId:subproject2" );
 
-        phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         assertTrue( comparePomFiles( reactorProjects ) );
     }
@@ -626,10 +627,10 @@
         throws Exception
     {
         List<MavenProject> reactorProjects = createReactorProjects( "comments-around-values" );
-        ReleaseDescriptor config = createConfigurationForPomWithParentAlternateNextVersion( reactorProjects );
-        mapNextVersion( config, "groupId:subproject2" );
+        ReleaseDescriptorBuilder builder = createConfigurationForPomWithParentAlternateNextVersion( reactorProjects );
+        mapNextVersion( builder, "groupId:subproject2" );
 
-        phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         assertTrue( comparePomFiles( reactorProjects ) );
     }
@@ -639,10 +640,10 @@
         throws Exception
     {
         List<MavenProject> reactorProjects = createReactorProjects( "cdata-around-values" );
-        ReleaseDescriptor config = createConfigurationForPomWithParentAlternateNextVersion( reactorProjects );
-        mapNextVersion( config, "groupId:subproject2" );
+        ReleaseDescriptorBuilder builder = createConfigurationForPomWithParentAlternateNextVersion( reactorProjects );
+        mapNextVersion( builder, "groupId:subproject2" );
 
-        phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         assertTrue( comparePomFiles( reactorProjects ) );
     }
@@ -652,25 +653,19 @@
         throws Exception
     {
         // This occurs when it is release:perform run standalone. Just check there are no errors.
-        ReleaseDescriptor config = new ReleaseDescriptor();
-        config.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo" );
-        config.setWorkingDirectory( getTestFile( "target/test/checkout" ).getAbsolutePath() );
-
         phase.clean( Collections.<MavenProject>emptyList() );
-
-        assertTrue( true );
     }
 
-    protected ReleaseDescriptor createUnmappedConfiguration( List<MavenProject> reactorProjects )
+    protected ReleaseDescriptorBuilder createUnmappedConfiguration( List<MavenProject> reactorProjects )
         throws Exception
     {
-        ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
+        ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects );
 
-        unmapNextVersion( config, "groupId:subproject1" );
-        mapNextVersion( config, "groupId:subproject2" );
-        mapNextVersion( config, "groupId:subproject3" );
-        mapNextVersion( config, "groupId:artifactId" );
-        return config;
+        unmapNextVersion( builder, "groupId:subproject1" );
+        mapNextVersion( builder, "groupId:subproject2" );
+        mapNextVersion( builder, "groupId:subproject3" );
+        mapNextVersion( builder, "groupId:artifactId" );
+        return builder;
     }
 
     protected List<MavenProject> createReactorProjects( String path )
@@ -679,31 +674,31 @@
         return prepareReactorProjects( path, true );
     }
 
-    protected ReleaseDescriptor createDefaultConfiguration( List<MavenProject> reactorProjects )
+    protected ReleaseDescriptorBuilder createDefaultConfiguration( List<MavenProject> reactorProjects )
         throws Exception
     {
-        ReleaseDescriptor config = createMappedConfiguration( reactorProjects );
+        ReleaseDescriptorBuilder builder = createMappedConfiguration( reactorProjects );
 
-        mapNextVersion( config, "groupId:subproject4" );
-        return config;
+        mapNextVersion( builder, "groupId:subproject4" );
+        return builder;
     }
 
-    protected ReleaseDescriptor createMappedConfiguration( List<MavenProject> reactorProjects )
+    protected ReleaseDescriptorBuilder createMappedConfiguration( List<MavenProject> reactorProjects )
         throws Exception
     {
-        ReleaseDescriptor config = createDifferingVersionConfiguration( reactorProjects );
+        ReleaseDescriptorBuilder builder = createDifferingVersionConfiguration( reactorProjects );
 
-        mapNextVersion( config, "groupId:subproject3" );
-        return config;
+        mapNextVersion( builder, "groupId:subproject3" );
+        return builder;
     }
 
-    private ReleaseDescriptor createDifferingVersionConfiguration( List<MavenProject> reactorProjects )
+    private ReleaseDescriptorBuilder createDifferingVersionConfiguration( List<MavenProject> reactorProjects )
         throws Exception
     {
-        ReleaseDescriptor config = createConfigurationForWithParentNextVersion( reactorProjects );
+        ReleaseDescriptorBuilder builder = createConfigurationForWithParentNextVersion( reactorProjects );
 
-        mapNextVersion( config, "groupId:subproject2" );
-        return config;
+        mapNextVersion( builder, "groupId:subproject2" );
+        return builder;
     }
 
     protected List<MavenProject> createReactorProjectsFromBasicPom()
@@ -712,14 +707,14 @@
         return createReactorProjects( "basic-pom" );
     }
 
-    protected abstract ReleaseDescriptor createConfigurationForWithParentNextVersion( List<MavenProject> reactorProjects )
+    protected abstract ReleaseDescriptorBuilder createConfigurationForWithParentNextVersion( List<MavenProject> reactorProjects )
         throws Exception;
 
-    protected abstract void unmapNextVersion( ReleaseDescriptor config, String projectId );
+    protected abstract void unmapNextVersion( ReleaseDescriptorBuilder config, String projectId );
 
-    protected abstract void mapNextVersion( ReleaseDescriptor config, String projectId );
+    protected abstract void mapNextVersion( ReleaseDescriptorBuilder config, String projectId );
 
-    protected ReleaseDescriptor createDescriptorFromBasicPom( List<MavenProject> reactorProjects )
+    protected ReleaseDescriptorBuilder createDescriptorFromBasicPom( List<MavenProject> reactorProjects )
         throws Exception
     {
         return createDescriptorFromProjects( reactorProjects );
@@ -733,9 +728,9 @@
         throws Exception
     {
         List<MavenProject> reactorProjects = createReactorProjects( "pom-with-namespace" );
-        ReleaseDescriptor config = createDefaultConfiguration( reactorProjects );
+        ReleaseDescriptorBuilder builder = createDefaultConfiguration( reactorProjects );
 
-        phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         assertTrue( comparePomFiles( reactorProjects ) );
     }
@@ -748,21 +743,33 @@
     {
     }
 
-    protected ReleaseDescriptor createDescriptorFromProjects( List<MavenProject> reactorProjects )
+    protected ReleaseDescriptorBuilder createDescriptorFromProjects( List<MavenProject> reactorProjects )
     {
-        ReleaseDescriptor descriptor = new ReleaseDescriptor();
+      return createDescriptorFromProjects( new ReleaseDescriptorBuilder(), reactorProjects );
+    }
+    
+    protected ReleaseDescriptorBuilder createDescriptorFromProjects( ReleaseDescriptorBuilder builder, List<MavenProject> reactorProjects )
+    {
         MavenProject rootProject = ReleaseUtil.getRootProject( reactorProjects );
+        
+        for ( MavenProject project : reactorProjects )
+        {
+            String key = project.getGroupId() + ':' + project.getArtifactId();
+            builder.putOriginalVersion( key, project.getVersion() );
+            builder.addOriginalScmInfo( key, project.getScm() );
+        }
+        
         if ( rootProject.getScm() == null )
         {
-            descriptor.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo/trunk" );
+            builder.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo/trunk" );
         }
         else
         {
-            descriptor.setScmSourceUrl( rootProject.getScm().getConnection() );
+            builder.setScmSourceUrl( rootProject.getScm().getConnection() );
         }
 
-        descriptor.setWorkingDirectory( getTestFile( "target/test/checkout" ).getAbsolutePath() );
+        builder.setWorkingDirectory( getTestFile( "target/test/checkout" ).getAbsolutePath() );
 
-        return descriptor;
+        return builder;
     }
 }
diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/AbstractScmCommitPhaseTest.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/AbstractScmCommitPhaseTest.java
index 087ea96..3a6bbae 100644
--- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/AbstractScmCommitPhaseTest.java
+++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/AbstractScmCommitPhaseTest.java
@@ -27,7 +27,8 @@
 
 import org.apache.maven.model.Model;
 import org.apache.maven.project.MavenProject;
-import org.apache.maven.shared.release.config.ReleaseDescriptor;
+import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder;
+import org.apache.maven.shared.release.config.ReleaseUtils;
 import org.junit.Test;
 
 public class AbstractScmCommitPhaseTest
@@ -37,8 +38,9 @@
         throws Exception
     {
         List<File> files =
-            AbstractScmCommitPhase.createPomFiles(  new ReleaseDescriptor(),
-                                                   createProject( "artifactId", "1.0-SNAPSHOT", new File( "pom.xml" ) ) );
+            AbstractScmCommitPhase.createPomFiles( ReleaseUtils.buildReleaseDescriptor( new ReleaseDescriptorBuilder() ),
+                                                   createProject( "artifactId", "1.0-SNAPSHOT",
+                                                                  new File( "pom.xml" ) ) );
         assertEquals( "Number of created files", files.size(), 1 );
         assertTrue( files.contains( new File( "pom.xml" ) ) );
     }
@@ -48,10 +50,10 @@
     public void testCreatePomFilesSuppressCommitBeforeTag()
         throws Exception
     {
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setSuppressCommitBeforeTagOrBranch( true );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setSuppressCommitBeforeTagOrBranch( true );
         List<File> files =
-            AbstractScmCommitPhase.createPomFiles(  releaseDescriptor,
+            AbstractScmCommitPhase.createPomFiles(  ReleaseUtils.buildReleaseDescriptor( builder ),
                                                    createProject( "artifactId", "1.0-SNAPSHOT", new File( "pom.xml" ) ) );
         assertEquals( "Number of created files", files.size(), 1 );
         assertTrue( files.contains( new File( "pom.xml" ) ) );
@@ -61,10 +63,10 @@
     public void testCreatePomFilesWithReleasePom()
         throws Exception
     {
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setGenerateReleasePoms( true );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setGenerateReleasePoms( true );
         List<File> files =
-            AbstractScmCommitPhase.createPomFiles( releaseDescriptor,
+            AbstractScmCommitPhase.createPomFiles( ReleaseUtils.buildReleaseDescriptor( builder ),
                                                    createProject( "artifactId", "1.0-SNAPSHOT", new File( "pom.xml" ) ) );
         assertEquals( "Number of created files", files.size(), 2 );
         assertTrue( files.contains( new File( "pom.xml" ) ) );
@@ -75,11 +77,11 @@
     public void testCreatePomFilesWithReleasePomAndSuppressCommitBeforeTag()
         throws Exception
     {
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setGenerateReleasePoms( true );
-        releaseDescriptor.setSuppressCommitBeforeTagOrBranch( true );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setGenerateReleasePoms( true );
+        builder.setSuppressCommitBeforeTagOrBranch( true );
         List<File> files =
-            AbstractScmCommitPhase.createPomFiles( releaseDescriptor,
+            AbstractScmCommitPhase.createPomFiles( ReleaseUtils.buildReleaseDescriptor( builder ),
                                                    createProject( "artifactId", "1.0-SNAPSHOT", new File( "pom.xml" ) ) );
         assertEquals( "Number of created files", files.size(), 1 );
         assertTrue( files.contains( new File( "pom.xml" ) ) );
diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/BranchInputVariablesPhaseTest.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/BranchInputVariablesPhaseTest.java
index d0e69f8..1ff575f 100644
--- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/BranchInputVariablesPhaseTest.java
+++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/BranchInputVariablesPhaseTest.java
@@ -36,7 +36,8 @@
 import org.apache.maven.project.MavenProject;
 import org.apache.maven.shared.release.PlexusJUnit4TestCase;
 import org.apache.maven.shared.release.ReleaseExecutionException;
-import org.apache.maven.shared.release.config.ReleaseDescriptor;
+import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder;
+import org.apache.maven.shared.release.config.ReleaseUtils;
 import org.apache.maven.shared.release.env.DefaultReleaseEnvironment;
 import org.codehaus.plexus.components.interactivity.Prompter;
 import org.codehaus.plexus.components.interactivity.PrompterException;
@@ -71,26 +72,26 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.0" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.mapReleaseVersion( "groupId:artifactId", "1.0" );
-        releaseDescriptor.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo" );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.addReleaseVersion( "groupId:artifactId", "1.0" );
+        builder.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo" );
 
         // execute
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertEquals( "Check tag", "tag-value", releaseDescriptor.getScmReleaseLabel() );
+        assertEquals( "Check tag", "tag-value", ReleaseUtils.buildReleaseDescriptor( builder ).getScmReleaseLabel() );
 
         // prepare
-        releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.mapReleaseVersion( "groupId:artifactId", "1.0" );
-        releaseDescriptor.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo" );
+        builder = new ReleaseDescriptorBuilder();
+        builder.addReleaseVersion( "groupId:artifactId", "1.0" );
+        builder.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo" );
 
         // execute
-        phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertEquals( "Check tag", "simulated-tag-value", releaseDescriptor.getScmReleaseLabel() );
+        assertEquals( "Check tag", "simulated-tag-value", ReleaseUtils.buildReleaseDescriptor( builder ).getScmReleaseLabel() );
 
         verify( mockPrompter, times( 2 ) ).prompt( isA( String.class ) );
         verifyNoMoreInteractions( mockPrompter );
@@ -102,11 +103,11 @@
     {
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.0" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
 
         try
         {
-            phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "Expected an exception" );
         }
@@ -115,11 +116,11 @@
             assertNull( "check no cause", e.getCause() );
         }
 
-        releaseDescriptor = new ReleaseDescriptor();
+        builder = new ReleaseDescriptorBuilder();
 
         try
         {
-            phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "Expected an exception" );
         }
@@ -139,26 +140,26 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.0" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setInteractive( false );
-        releaseDescriptor.setScmReleaseLabel( "tag-value" );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setInteractive( false );
+        builder.setScmReleaseLabel( "tag-value" );
 
         // execute
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertEquals( "Check tag", "tag-value", releaseDescriptor.getScmReleaseLabel() );
+        assertEquals( "Check tag", "tag-value", ReleaseUtils.buildReleaseDescriptor( builder ).getScmReleaseLabel() );
 
         // prepare
-        releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setInteractive( false );
-        releaseDescriptor.setScmReleaseLabel( "simulated-tag-value" );
+        builder = new ReleaseDescriptorBuilder();
+        builder.setInteractive( false );
+        builder.setScmReleaseLabel( "simulated-tag-value" );
 
         // execute
-        phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertEquals( "Check tag", "simulated-tag-value", releaseDescriptor.getScmReleaseLabel() );
+        assertEquals( "Check tag", "simulated-tag-value", ReleaseUtils.buildReleaseDescriptor( builder ).getScmReleaseLabel() );
 
         // never use prompter
         verifyNoMoreInteractions( mockPrompter );
@@ -174,24 +175,24 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.0" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setScmReleaseLabel( "tag-value" );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setScmReleaseLabel( "tag-value" );
 
         // execute
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertEquals( "Check tag", "tag-value", releaseDescriptor.getScmReleaseLabel() );
+        assertEquals( "Check tag", "tag-value", ReleaseUtils.buildReleaseDescriptor( builder ).getScmReleaseLabel() );
 
         // prepare
-        releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setScmReleaseLabel( "simulated-tag-value" );
+        builder = new ReleaseDescriptorBuilder();
+        builder.setScmReleaseLabel( "simulated-tag-value" );
 
         // execute
-        phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertEquals( "Check tag", "simulated-tag-value", releaseDescriptor.getScmReleaseLabel() );
+        assertEquals( "Check tag", "simulated-tag-value", ReleaseUtils.buildReleaseDescriptor( builder ).getScmReleaseLabel() );
 
         // never use prompter
         verifyNoMoreInteractions( mockPrompter );
@@ -209,14 +210,14 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.0" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.mapReleaseVersion( "groupId:artifactId", "1.0" );
-        releaseDescriptor.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo" );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.addReleaseVersion( "groupId:artifactId", "1.0" );
+        builder.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo" );
 
         // execute
         try
         {
-            phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "Expected an exception" );
         }
@@ -226,14 +227,14 @@
         }
 
         // prepare
-        releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.mapReleaseVersion( "groupId:artifactId", "1.0" );
-        releaseDescriptor.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo" );
+        builder = new ReleaseDescriptorBuilder();
+        builder.addReleaseVersion( "groupId:artifactId", "1.0" );
+        builder.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo" );
 
         // execute
         try
         {
-            phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "Expected an exception" );
         }
@@ -264,16 +265,16 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.0" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setInteractive( false );
-        releaseDescriptor.setScmReleaseLabel( null );
-        releaseDescriptor.mapReleaseVersion( "groupId:artifactId", "1.0" );
-        releaseDescriptor.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo" );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setInteractive( false );
+        builder.setScmReleaseLabel( null );
+        builder.addReleaseVersion( "groupId:artifactId", "1.0" );
+        builder.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo" );
 
         // execute
         try
         {
-            phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "Expected an exception" );
         }
@@ -283,16 +284,16 @@
         }
 
         // prepare
-        releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setInteractive( false );
-        releaseDescriptor.setScmReleaseLabel( null );
-        releaseDescriptor.mapReleaseVersion( "groupId:artifactId", "1.0" );
-        releaseDescriptor.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo" );
+        builder = new ReleaseDescriptorBuilder();
+        builder.setInteractive( false );
+        builder.setScmReleaseLabel( null );
+        builder.addReleaseVersion( "groupId:artifactId", "1.0" );
+        builder.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo" );
 
         // execute
         try
         {
-            phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "Expected an exception" );
         }
@@ -308,17 +309,17 @@
     @Test
     public void testNamingPolicy() throws Exception
     {
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.mapReleaseVersion( "groupId:artifactId", "1.0" );
-        releaseDescriptor.setInteractive( false );
-        releaseDescriptor.setProjectNamingPolicyId( "stub" );
-        releaseDescriptor.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo" );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.addReleaseVersion( "groupId:artifactId", "1.0" );
+        builder.setInteractive( false );
+        builder.setProjectNamingPolicyId( "stub" );
+        builder.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo" );
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.0" ) );
 
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
-        assertEquals( "STUB", releaseDescriptor.getScmReleaseLabel() );
+        assertEquals( "STUB", ReleaseUtils.buildReleaseDescriptor( builder ).getScmReleaseLabel() );
     }
 
     private static MavenProject createProject( String artifactId, String version )
diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/CheckDependencySnapshotsPhaseTest.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/CheckDependencySnapshotsPhaseTest.java
index 81466d8..2b0edf6 100644
--- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/CheckDependencySnapshotsPhaseTest.java
+++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/CheckDependencySnapshotsPhaseTest.java
@@ -31,13 +31,14 @@
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
-import java.util.Map;
 import java.util.Objects;
 
 import org.apache.maven.project.MavenProject;
 import org.apache.maven.shared.release.ReleaseExecutionException;
 import org.apache.maven.shared.release.ReleaseFailureException;
 import org.apache.maven.shared.release.config.ReleaseDescriptor;
+import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder;
+import org.apache.maven.shared.release.config.ReleaseUtils;
 import org.apache.maven.shared.release.env.DefaultReleaseEnvironment;
 import org.codehaus.plexus.components.interactivity.Prompter;
 import org.codehaus.plexus.components.interactivity.PrompterException;
@@ -67,19 +68,19 @@
     {
         super.setUp();
 
-        phase = (ReleasePhase) lookup( ReleasePhase.class, "check-dependency-snapshots" );
+        phase = lookup( ReleasePhase.class, "check-dependency-snapshots" );
     }
 
     @Test
     public void testNoSnapshotDependencies()
         throws Exception
     {
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();;
         List<MavenProject> reactorProjects = createDescriptorFromProjects( "no-snapshot-dependencies" );
 
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
-        phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // successful execution is verification enough
         assertTrue( true );
@@ -92,16 +93,16 @@
         CheckDependencySnapshotsPhase phase =
             (CheckDependencySnapshotsPhase) lookup( ReleasePhase.class, "check-dependency-snapshots" );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
         List<MavenProject> reactorProjects = createDescriptorFromProjects( "no-snapshot-range-dependencies" );
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( reactorProjects );
 
         phase.setPrompter( createMockPrompter( YES, DEFAULT_CHOICE, new VersionPair( "1.1", "1.2-SNAPSHOT" ) ) );
 
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         phase.setPrompter( createMockPrompter( YES, DEFAULT_CHOICE, new VersionPair( "1.1", "1.2-SNAPSHOT" ) ) );
 
-        phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // successful execution is verification enough
         assertTrue( true );
@@ -111,12 +112,12 @@
     public void testSnapshotDependenciesInProjectOnly()
         throws Exception
     {
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
         List<MavenProject> reactorProjects = createDescriptorFromProjects( "internal-snapshot-dependencies" );
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( reactorProjects );
 
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
-        phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // successful execution is verification enough
         assertTrue( true );
@@ -126,13 +127,13 @@
     public void testSnapshotReleasePluginNonInteractive()
         throws Exception
     {
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
         List<MavenProject> reactorProjects = createDescriptorFromProjects( "snapshot-release-plugin" );
-        releaseDescriptor.setInteractive( false );
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( reactorProjects );
+        builder.setInteractive( false );
 
         try
         {
-            phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "Should have failed execution" );
         }
@@ -143,7 +144,7 @@
 
         try
         {
-            phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "Should have failed execution" );
         }
@@ -160,14 +161,14 @@
         CheckDependencySnapshotsPhase phase =
             (CheckDependencySnapshotsPhase) lookup( ReleasePhase.class, "check-dependency-snapshots" );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
         List<MavenProject> reactorProjects = createDescriptorFromProjects( "snapshot-release-plugin" );
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( reactorProjects );
 
         phase.setPrompter( createMockPrompterWithSnapshotReleasePlugin( NO, NO ) );
 
         try
         {
-            phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "Should have failed execution" );
         }
@@ -180,7 +181,7 @@
 
         try
         {
-            phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "Should have failed execution" );
         }
@@ -197,12 +198,12 @@
         CheckDependencySnapshotsPhase phase =
             (CheckDependencySnapshotsPhase) lookup( ReleasePhase.class, "check-dependency-snapshots" );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
         List<MavenProject> reactorProjects = createDescriptorFromProjects( "snapshot-release-plugin" );
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( reactorProjects );
 
         phase.setPrompter( createYesMockPrompter() );
 
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         assertTrue( true );
     }
@@ -214,12 +215,12 @@
         CheckDependencySnapshotsPhase phase =
             (CheckDependencySnapshotsPhase) lookup( ReleasePhase.class, "check-dependency-snapshots" );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
         List<MavenProject> reactorProjects = createDescriptorFromProjects( "snapshot-release-plugin" );
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( reactorProjects );
 
         phase.setPrompter( createYesMockPrompter() );
 
-        phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         assertTrue( true );
     }
@@ -231,14 +232,14 @@
         CheckDependencySnapshotsPhase phase =
             (CheckDependencySnapshotsPhase) lookup( ReleasePhase.class, "check-dependency-snapshots" );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
         List<MavenProject> reactorProjects = createDescriptorFromProjects( "snapshot-release-plugin" );
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( reactorProjects );
 
         phase.setPrompter( createMockPrompterWithSnapshotReleasePlugin( "donkey", NO ) );
 
         try
         {
-            phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "Should have failed execution" );
         }
@@ -251,7 +252,7 @@
 
         try
         {
-            phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "Should have failed execution" );
         }
@@ -268,8 +269,8 @@
         CheckDependencySnapshotsPhase phase =
             (CheckDependencySnapshotsPhase) lookup( ReleasePhase.class, "check-dependency-snapshots" );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
         List<MavenProject> reactorProjects = createDescriptorFromProjects( "snapshot-release-plugin" );
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( reactorProjects );
 
         Prompter mockPrompter = mock( Prompter.class );
         when( mockPrompter.prompt( anyString(), eq( YES_NO_ARRAY ),
@@ -278,7 +279,7 @@
 
         try
         {
-            phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "Should have failed execution" );
         }
@@ -293,7 +294,7 @@
 
         try
         {
-            phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "Should have failed execution" );
         }
@@ -310,14 +311,14 @@
         CheckDependencySnapshotsPhase phase =
             (CheckDependencySnapshotsPhase) lookup( ReleasePhase.class, "check-dependency-snapshots" );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
         List<MavenProject> reactorProjects = createDescriptorFromProjects( "internal-differing-snapshot-dependencies" );
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( reactorProjects );
 
         phase.setPrompter( createNoMockPrompter() );
 
         try
         {
-            phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "Should have failed execution" );
         }
@@ -330,7 +331,7 @@
 
         try
         {
-            phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "Should have failed execution" );
         }
@@ -344,12 +345,12 @@
     public void testSnapshotManagedDependenciesInProjectOnly()
         throws Exception
     {
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
         List<MavenProject> reactorProjects = createDescriptorFromProjects( "internal-managed-snapshot-dependency" );
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( reactorProjects );
 
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
-        phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // successful execution is verification enough
         assertTrue( true );
@@ -359,13 +360,13 @@
     public void testSnapshotUnusedInternalManagedDependency()
         throws Exception
     {
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
         List<MavenProject> reactorProjects =
             createDescriptorFromProjects( "unused-internal-managed-snapshot-dependency" );
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( reactorProjects );
 
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
-        phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // successful execution is verification enough
         assertTrue( true );
@@ -375,13 +376,13 @@
     public void testSnapshotUnusedExternalManagedDependency()
         throws Exception
     {
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
         List<MavenProject> reactorProjects =
             createDescriptorFromProjects( "unused-external-managed-snapshot-dependency" );
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( reactorProjects );
 
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
-        phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // successful execution is verification enough
         assertTrue( true );
@@ -391,14 +392,14 @@
     public void testSnapshotExternalManagedDependency()
         throws Exception
     {
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
         List<MavenProject> reactorProjects = createDescriptorFromProjects( "external-managed-snapshot-dependency" );
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( reactorProjects );
 
-        releaseDescriptor.setInteractive( false );
+        builder.setInteractive( false );
 
         try
         {
-            phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "Should have failed execution" );
         }
@@ -409,7 +410,7 @@
 
         try
         {
-            phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "Should have failed execution" );
         }
@@ -423,14 +424,14 @@
     public void testSnapshotDependenciesOutsideProjectOnlyNonInteractive()
         throws Exception
     {
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
         List<MavenProject> reactorProjects = createDescriptorFromProjects( "external-snapshot-dependencies" );
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( reactorProjects );
 
-        releaseDescriptor.setInteractive( false );
+        builder.setInteractive( false );
 
         try
         {
-            phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "Should have failed execution" );
         }
@@ -441,7 +442,7 @@
 
         try
         {
-            phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "Should have failed execution" );
         }
@@ -455,14 +456,14 @@
     public void testRangeSnapshotDependenciesOutsideProjectOnlyNonInteractive()
         throws Exception
     {
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
         List<MavenProject> reactorProjects = createDescriptorFromProjects( "external-range-snapshot-dependencies" );
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( reactorProjects );
 
-        releaseDescriptor.setInteractive( false );
+        builder.setInteractive( false );
 
         try
         {
-            phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "Should have failed execution" );
         }
@@ -473,7 +474,7 @@
 
         try
         {
-            phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "Should have failed execution" );
         }
@@ -490,26 +491,25 @@
         CheckDependencySnapshotsPhase phase =
             (CheckDependencySnapshotsPhase) lookup( ReleasePhase.class, "check-dependency-snapshots" );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
         List<MavenProject> reactorProjects = createDescriptorFromProjects( "external-snapshot-dependencies" );
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( reactorProjects );
 
         phase.setPrompter( createMockPrompter( YES, DEFAULT_CHOICE, new VersionPair( "1.0", "1.1-SNAPSHOT" ),
                                                new VersionPair( "1.0", "1.0" ) ) );
 
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
  
         // validate
-        Map<String, String> versionsMap = releaseDescriptor.getResolvedSnapshotDependencies().get( "external:artifactId" );
+        ReleaseDescriptor descriptor = ReleaseUtils.buildReleaseDescriptor( builder );
+        
+        assertEquals( "1.0", descriptor.getDependencyReleaseVersion( "external:artifactId" ) );
+        assertEquals( "1.1-SNAPSHOT", descriptor.getDependencyDevelopmentVersion( "external:artifactId" ) );
 
-        assertNotNull( versionsMap );
-        assertEquals( "1.1-SNAPSHOT", versionsMap.get( ReleaseDescriptor.DEVELOPMENT_KEY ) );
-        assertEquals( "1.0", versionsMap.get( ReleaseDescriptor.RELEASE_KEY ) );
-
-        releaseDescriptor = new ReleaseDescriptor();
+        builder = createReleaseDescriptorBuilder( reactorProjects );
 
         phase.setPrompter( createMockPrompter( YES, DEFAULT_CHOICE, new VersionPair( "1.0", "1.1-SNAPSHOT" ) ) );
 
-        phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
     }
 
     @Test
@@ -519,20 +519,19 @@
         CheckDependencySnapshotsPhase phase =
             (CheckDependencySnapshotsPhase) lookup( ReleasePhase.class, "check-dependency-snapshots" );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
         List<MavenProject> reactorProjects = createDescriptorFromProjects( "external-snapshot-dependencies" );
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( reactorProjects );
 
         phase.setPrompter( createMockPrompter( YES, DEFAULT_CHOICE, new VersionPair( "0.9", "1.0-SNAPSHOT" ),
                                                new VersionPair( "1.0", "1.0-SNAPSHOT" ) ) );
 
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // validate
-        Map<String, String> versionsMap = releaseDescriptor.getResolvedSnapshotDependencies().get( "external:artifactId" );
+        ReleaseDescriptor descriptor = ReleaseUtils.buildReleaseDescriptor( builder );
 
-        assertNotNull( versionsMap );
-        assertEquals( "1.0-SNAPSHOT", versionsMap.get( ReleaseDescriptor.DEVELOPMENT_KEY ) );
-        assertEquals( "0.9", versionsMap.get( ReleaseDescriptor.RELEASE_KEY ) );
+        assertEquals( "0.9", descriptor.getDependencyReleaseVersion( "external:artifactId" ) );
+        assertEquals( "1.0-SNAPSHOT", descriptor.getDependencyDevelopmentVersion( "external:artifactId" )  );
     }
 
     @Test
@@ -542,19 +541,18 @@
         CheckDependencySnapshotsPhase phase =
             (CheckDependencySnapshotsPhase) lookup( ReleasePhase.class, "check-dependency-snapshots" );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
         List<MavenProject> reactorProjects = createDescriptorFromProjects( "external-snapshot-dependencies" );
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( reactorProjects );
 
         phase.setPrompter( createMockPrompter( YES, DEFAULT_CHOICE, new VersionPair( "1.0", "1.0" ) ) );
 
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // validate
-        Map<String, String> versionsMap = releaseDescriptor.getResolvedSnapshotDependencies().get( "external:artifactId" );
+        ReleaseDescriptor descriptor = ReleaseUtils.buildReleaseDescriptor( builder );
 
-        assertNotNull( versionsMap );
-        assertEquals( "1.0", versionsMap.get( ReleaseDescriptor.DEVELOPMENT_KEY ) );
-        assertEquals( "1.0", versionsMap.get( ReleaseDescriptor.RELEASE_KEY ) );
+        assertEquals( "1.0", descriptor.getDependencyReleaseVersion( "external:artifactId" ) );
+        assertEquals( "1.0", descriptor.getDependencyDevelopmentVersion( "external:artifactId" )  );
     }
 
     @Test
@@ -564,19 +562,18 @@
         CheckDependencySnapshotsPhase phase =
             (CheckDependencySnapshotsPhase) lookup( ReleasePhase.class, "check-dependency-snapshots" );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
         List<MavenProject> reactorProjects = createDescriptorFromProjects( "external-snapshot-dependencies" );
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( reactorProjects );
 
         phase.setPrompter( createMockPrompter( YES, "0", new VersionPair( "1.0", "1.0" ) ) );
 
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // validate
-        Map<String, String> versionsMap = releaseDescriptor.getResolvedSnapshotDependencies().get( "external:artifactId" );
+        ReleaseDescriptor descriptor = ReleaseUtils.buildReleaseDescriptor( builder );
 
-        assertNotNull( versionsMap );
-        assertEquals( "1.0", versionsMap.get( ReleaseDescriptor.DEVELOPMENT_KEY ) );
-        assertEquals( "1.0", versionsMap.get( ReleaseDescriptor.RELEASE_KEY ) );
+        assertEquals( "1.0", descriptor.getDependencyReleaseVersion( "external:artifactId" ) );
+        assertEquals( "1.0", descriptor.getDependencyDevelopmentVersion( "external:artifactId" )  );
     }
 
     @Test
@@ -586,8 +583,8 @@
         CheckDependencySnapshotsPhase phase =
             (CheckDependencySnapshotsPhase) lookup( ReleasePhase.class, "check-dependency-snapshots" );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
         List<MavenProject> reactorProjects = createDescriptorFromProjects( "external-snapshot-all" );
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( reactorProjects );
 
         Prompter mockPrompter =
             createMockPrompter( YES, "0",
@@ -595,14 +592,13 @@
                                                new VersionPair( "1.2", "1.2" ), new VersionPair( "1.3", "1.3" ) ) );
         phase.setPrompter( mockPrompter );
 
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // validate
-        Map<String, String> versionsMap = releaseDescriptor.getResolvedSnapshotDependencies().get( "external:artifactId" );
+        ReleaseDescriptor descriptor = ReleaseUtils.buildReleaseDescriptor( builder );
 
-        assertNotNull( versionsMap );
-        assertEquals( "1.0", versionsMap.get( ReleaseDescriptor.DEVELOPMENT_KEY ) );
-        assertEquals( "1.0", versionsMap.get( ReleaseDescriptor.RELEASE_KEY ) );
+        assertEquals( "1.0", descriptor.getDependencyReleaseVersion( "external:artifactId" ) );
+        assertEquals( "1.0", descriptor.getDependencyDevelopmentVersion( "external:artifactId" )  );
     }
 
     // MRELEASE-589
@@ -613,9 +609,9 @@
         CheckDependencySnapshotsPhase phase =
             (CheckDependencySnapshotsPhase) lookup( ReleasePhase.class, "check-dependency-snapshots" );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
         List<MavenProject> reactorProjects =
             createDescriptorFromProjects( "multimodule-external-snapshot-dependencies" );
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( reactorProjects );
 
         VersionPair pair = new VersionPair( "1.0", "1.1-SNAPSHOT" );
         VersionPair defaultPair = new VersionPair( "1.0", "1.0" );
@@ -623,27 +619,15 @@
             createMockPrompter( "yes", "1", Arrays.asList( pair, pair ), Arrays.asList( defaultPair, defaultPair ) );
         phase.setPrompter( mockPrompter );
 
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
-        Map<String, Map<String, String>> resolvedDependencies = releaseDescriptor.getResolvedSnapshotDependencies();
+        ReleaseDescriptor descriptor = ReleaseUtils.buildReleaseDescriptor( builder );
 
-        assertNotNull( resolvedDependencies );
-        assertEquals( 2, resolvedDependencies.size() );
+        assertEquals( "1.0", descriptor.getDependencyReleaseVersion( "external:artifactId" ) );
+        assertEquals( "1.1-SNAPSHOT", descriptor.getDependencyDevelopmentVersion( "external:artifactId" ) );
 
-        assertTrue( resolvedDependencies.containsKey( "external:artifactId" ) );
-        assertTrue( resolvedDependencies.containsKey( "external:artifactId2" ) );
-
-        Map<String, String> versionsMap = releaseDescriptor.getResolvedSnapshotDependencies().get( "external:artifactId" );
-
-        assertNotNull( versionsMap );
-        assertEquals( "1.1-SNAPSHOT", versionsMap.get( ReleaseDescriptor.DEVELOPMENT_KEY ) );
-        assertEquals( "1.0", versionsMap.get( ReleaseDescriptor.RELEASE_KEY ) );
-
-        versionsMap = releaseDescriptor.getResolvedSnapshotDependencies().get( "external:artifactId2" );
-
-        assertNotNull( versionsMap );
-        assertEquals( "1.1-SNAPSHOT", versionsMap.get( ReleaseDescriptor.DEVELOPMENT_KEY ) );
-        assertEquals( "1.0", versionsMap.get( ReleaseDescriptor.RELEASE_KEY ) );
+        assertEquals( "1.0", descriptor.getDependencyReleaseVersion( "external:artifactId2" ) );
+        assertEquals( "1.1-SNAPSHOT", descriptor.getDependencyDevelopmentVersion( "external:artifactId2" ) );
     }
 
     @Test
@@ -653,15 +637,15 @@
         CheckDependencySnapshotsPhase phase =
             (CheckDependencySnapshotsPhase) lookup( ReleasePhase.class, "check-dependency-snapshots" );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
         List<MavenProject> reactorProjects =
             createDescriptorFromProjects( "internal-and-external-snapshot-dependencies" );
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( reactorProjects );
 
         phase.setPrompter( createNoMockPrompter() );
 
         try
         {
-            phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "Should have failed execution" );
         }
@@ -674,7 +658,7 @@
 
         try
         {
-            phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "Should have failed execution" );
         }
@@ -688,12 +672,12 @@
     public void testNoSnapshotReportPlugins()
         throws Exception
     {
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();;
         List<MavenProject> reactorProjects = createDescriptorFromProjects( "no-snapshot-report-plugins" );
 
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
-        phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // successful execution is verification enough
         assertTrue( true );
@@ -703,12 +687,12 @@
     public void testSnapshotReportPluginsInProjectOnly()
         throws Exception
     {
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
         List<MavenProject> reactorProjects = createDescriptorFromProjects( "internal-snapshot-report-plugins" );
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( reactorProjects );
 
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
-        phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // successful execution is verification enough
         assertTrue( true );
@@ -721,14 +705,14 @@
         CheckDependencySnapshotsPhase phase =
             (CheckDependencySnapshotsPhase) lookup( ReleasePhase.class, "check-dependency-snapshots" );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
         List<MavenProject> reactorProjects = createDescriptorFromProjects( "external-snapshot-report-plugins" );
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( reactorProjects );
 
         phase.setPrompter( createNoMockPrompter() );
 
         try
         {
-            phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "Should have failed execution" );
         }
@@ -741,7 +725,7 @@
 
         try
         {
-            phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "Should have failed execution" );
         }
@@ -758,15 +742,15 @@
         CheckDependencySnapshotsPhase phase =
             (CheckDependencySnapshotsPhase) lookup( ReleasePhase.class, "check-dependency-snapshots" );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
         List<MavenProject> reactorProjects =
             createDescriptorFromProjects( "internal-and-external-snapshot-report-plugins" );
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( reactorProjects );
 
         phase.setPrompter( createNoMockPrompter() );
 
         try
         {
-            phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "Should have failed execution" );
         }
@@ -779,7 +763,7 @@
 
         try
         {
-            phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "Should have failed execution" );
         }
@@ -793,12 +777,12 @@
     public void testNoSnapshotPlugins()
         throws Exception
     {
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();;
         List<MavenProject> reactorProjects = createDescriptorFromProjects( "no-snapshot-plugins" );
 
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
-        phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // successful execution is verification enough
         assertTrue( true );
@@ -808,12 +792,12 @@
     public void testSnapshotPluginsInProjectOnly()
         throws Exception
     {
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
         List<MavenProject> reactorProjects = createDescriptorFromProjects( "internal-snapshot-plugins" );
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( reactorProjects );
 
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
-        phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // successful execution is verification enough
         assertTrue( true );
@@ -823,12 +807,12 @@
     public void testSnapshotManagedPluginInProjectOnly()
         throws Exception
     {
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
         List<MavenProject> reactorProjects = createDescriptorFromProjects( "internal-managed-snapshot-plugin" );
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( reactorProjects );
 
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
-        phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // successful execution is verification enough
         assertTrue( true );
@@ -838,12 +822,12 @@
     public void testSnapshotUnusedInternalManagedPlugin()
         throws Exception
     {
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
         List<MavenProject> reactorProjects = createDescriptorFromProjects( "unused-internal-managed-snapshot-plugin" );
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( reactorProjects );
 
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
-        phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // successful execution is verification enough
         assertTrue( true );
@@ -853,12 +837,12 @@
     public void testSnapshotUnusedExternalManagedPlugin()
         throws Exception
     {
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
         List<MavenProject> reactorProjects = createDescriptorFromProjects( "unused-external-managed-snapshot-plugin" );
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( reactorProjects );
 
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
-        phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // successful execution is verification enough
         assertTrue( true );
@@ -871,14 +855,14 @@
         CheckDependencySnapshotsPhase phase =
             (CheckDependencySnapshotsPhase) lookup( ReleasePhase.class, "check-dependency-snapshots" );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
         List<MavenProject> reactorProjects = createDescriptorFromProjects( "external-managed-snapshot-plugin" );
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( reactorProjects );
 
         phase.setPrompter( createNoMockPrompter() );
 
         try
         {
-            phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "Should have failed execution" );
         }
@@ -891,7 +875,7 @@
 
         try
         {
-            phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "Should have failed execution" );
         }
@@ -908,14 +892,14 @@
         CheckDependencySnapshotsPhase phase =
             (CheckDependencySnapshotsPhase) lookup( ReleasePhase.class, "check-dependency-snapshots" );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
         List<MavenProject> reactorProjects = createDescriptorFromProjects( "external-snapshot-plugins" );
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( reactorProjects );
 
         phase.setPrompter( createNoMockPrompter() );
 
         try
         {
-            phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "Should have failed execution" );
         }
@@ -928,7 +912,7 @@
 
         try
         {
-            phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "Should have failed execution" );
         }
@@ -945,14 +929,14 @@
         CheckDependencySnapshotsPhase phase =
             (CheckDependencySnapshotsPhase) lookup( ReleasePhase.class, "check-dependency-snapshots" );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
         List<MavenProject> reactorProjects = createDescriptorFromProjects( "internal-and-external-snapshot-plugins" );
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( reactorProjects );
 
         phase.setPrompter( createNoMockPrompter() );
 
         try
         {
-            phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "Should have failed execution" );
         }
@@ -965,7 +949,7 @@
 
         try
         {
-            phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "Should have failed execution" );
         }
@@ -982,14 +966,14 @@
         CheckDependencySnapshotsPhase phase =
             (CheckDependencySnapshotsPhase) lookup( ReleasePhase.class, "check-dependency-snapshots" );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
         List<MavenProject> reactorProjects = createDescriptorFromProjects( "external-snapshot-parent/child" );
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( reactorProjects );
 
         phase.setPrompter( createNoMockPrompter() );
 
         try
         {
-            phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "Should have failed execution" );
         }
@@ -1002,7 +986,7 @@
 
         try
         {
-            phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "Should have failed execution" );
         }
@@ -1019,33 +1003,32 @@
         CheckDependencySnapshotsPhase phase =
             (CheckDependencySnapshotsPhase) lookup( ReleasePhase.class, "check-dependency-snapshots" );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
         List<MavenProject> reactorProjects = createDescriptorFromProjects( "external-snapshot-parent/child" );
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( reactorProjects );
 
         Prompter mockPrompter = createMockPrompter( YES, DEFAULT_CHOICE, new VersionPair( "1.0-test", "1.0-test" ),
                                                     new VersionPair( "1.0", "1.0-test" ) );
         phase.setPrompter( mockPrompter );
 
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // validate
-        Map<String, String> versionsMap = releaseDescriptor.getResolvedSnapshotDependencies().get( "groupId:parent-external" );
+        ReleaseDescriptor descriptor = ReleaseUtils.buildReleaseDescriptor( builder );
 
-        assertNotNull( versionsMap );
-        assertEquals( "1.0-test", versionsMap.get( ReleaseDescriptor.DEVELOPMENT_KEY ) );
-        assertEquals( "1.0-test", versionsMap.get( ReleaseDescriptor.RELEASE_KEY ) );
+        assertEquals( "1.0-test", descriptor.getDependencyReleaseVersion( "groupId:parent-external" ) );
+        assertEquals( "1.0-test", descriptor.getDependencyDevelopmentVersion( "groupId:parent-external" )  );
     }
 
     @Test
     public void testReleaseExternalParent()
         throws Exception
     {
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();;
         List<MavenProject> reactorProjects = createDescriptorFromProjects( "external-parent/child" );
 
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
-        phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // successful execution is verification enough
         assertTrue( true );
@@ -1058,14 +1041,14 @@
         CheckDependencySnapshotsPhase phase =
             (CheckDependencySnapshotsPhase) lookup( ReleasePhase.class, "check-dependency-snapshots" );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
         List<MavenProject> reactorProjects = createDescriptorFromProjects( "external-snapshot-extension" );
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( reactorProjects );
 
         phase.setPrompter( createNoMockPrompter() );
 
         try
         {
-            phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "Should have failed execution" );
         }
@@ -1078,7 +1061,7 @@
 
         try
         {
-            phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "Should have failed execution" );
         }
@@ -1092,12 +1075,12 @@
     public void testSnapshotInternalExtension()
         throws Exception
     {
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
         List<MavenProject> reactorProjects = createDescriptorFromProjects( "internal-snapshot-extension" );
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( reactorProjects );
 
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
-        phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // successful execution is verification enough
         assertTrue( true );
@@ -1107,12 +1090,12 @@
     public void testReleaseExternalExtension()
         throws Exception
     {
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();;
         List<MavenProject> reactorProjects = createDescriptorFromProjects( "external-extension" );
 
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
-        phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // successful execution is verification enough
         assertTrue( true );
@@ -1122,16 +1105,16 @@
     public void testAllowTimestampedSnapshots()
         throws Exception
     {
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
         List<MavenProject> reactorProjects =
             createDescriptorFromProjects( "external-timestamped-snapshot-dependencies" );
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( reactorProjects );
 
-        releaseDescriptor.setInteractive( false );
+        builder.setInteractive( false );
 
         // confirm POM fails without allowTimestampedSnapshots
         try
         {
-            phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "Should have failed execution" );
         }
@@ -1141,11 +1124,11 @@
         }
 
         // check whether flag allows
-        releaseDescriptor.setAllowTimestampedSnapshots( true );
+        builder.setAllowTimestampedSnapshots( true );
 
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
-        phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // successful execution is verification enough
         assertTrue( true );
diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/CheckPomPhaseTest.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/CheckPomPhaseTest.java
index 3e3eac4..84e78d7 100644
--- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/CheckPomPhaseTest.java
+++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/CheckPomPhaseTest.java
@@ -23,7 +23,8 @@
 import org.apache.maven.model.Scm;
 import org.apache.maven.project.MavenProject;
 import org.apache.maven.shared.release.ReleaseFailureException;
-import org.apache.maven.shared.release.config.ReleaseDescriptor;
+import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder;
+import org.apache.maven.shared.release.config.ReleaseUtils;
 import org.apache.maven.shared.release.env.DefaultReleaseEnvironment;
 import org.apache.maven.shared.release.scm.ReleaseScmRepositoryException;
 import org.codehaus.plexus.PlexusTestCase;
@@ -52,12 +53,12 @@
     public void testCorrectlyConfigured()
         throws Exception
     {
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setScmSourceUrl( "scm-url" );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setScmSourceUrl( "scm:svn:file://localhost/tmp/repo" );
 
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), Collections.singletonList( createProject( "1.0-SNAPSHOT" ) ) );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), Collections.singletonList( createProject( "1.0-SNAPSHOT" ) ) );
 
-        phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), Collections.singletonList( createProject( "1.0-SNAPSHOT" ) ) );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), Collections.singletonList( createProject( "1.0-SNAPSHOT" ) ) );
 
         // successful execution is verification enough
         assertTrue( true );
@@ -66,73 +67,66 @@
     public void testGetUrlFromProjectConnection()
         throws Exception
     {
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setScmSourceUrl( "scm:svn:file://localhost/tmp/repo" );
+
         MavenProject project = createProject( "1.0-SNAPSHOT" );
-        Scm scm = new Scm();
-        scm.setConnection( "scm:svn:file://localhost/tmp/repo" );
-        project.setScm( scm );
 
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), Collections.singletonList( project ) );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), Collections.singletonList( project ) );
 
-        assertEquals( "Check URL", "scm:svn:file://localhost/tmp/repo", releaseDescriptor.getScmSourceUrl() );
+        assertEquals( "Check URL", "scm:svn:file://localhost/tmp/repo", ReleaseUtils.buildReleaseDescriptor( builder ).getScmSourceUrl() );
     }
 
     public void testGetUrlFromProjectConnectionSimulate()
         throws Exception
     {
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setScmSourceUrl( "scm:svn:file://localhost/tmp/repo" );
+
         MavenProject project = createProject( "1.0-SNAPSHOT" );
-        Scm scm = new Scm();
-        scm.setConnection( "scm:svn:file://localhost/tmp/repo" );
-        project.setScm( scm );
 
-        phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), Collections.singletonList( project ) );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), Collections.singletonList( project ) );
 
-        assertEquals( "Check URL", "scm:svn:file://localhost/tmp/repo", releaseDescriptor.getScmSourceUrl() );
+        assertEquals( "Check URL", "scm:svn:file://localhost/tmp/repo", ReleaseUtils.buildReleaseDescriptor( builder ).getScmSourceUrl() );
     }
 
     public void testGetUrlFromProjectDevConnection()
         throws Exception
     {
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setScmSourceUrl( "scm:svn:https://localhost/tmp/repo" );
+        
         MavenProject project = createProject( "1.0-SNAPSHOT" );
-        Scm scm = new Scm();
-        scm.setConnection( "scm:svn:file://localhost/tmp/repo" );
-        scm.setDeveloperConnection( "scm:svn:https://localhost/tmp/repo" );
-        project.setScm( scm );
 
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), Collections.singletonList( project ) );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), Collections.singletonList( project ) );
 
-        assertEquals( "Check URL", "scm:svn:https://localhost/tmp/repo", releaseDescriptor.getScmSourceUrl() );
+        assertEquals( "Check URL", "scm:svn:https://localhost/tmp/repo", ReleaseUtils.buildReleaseDescriptor( builder ).getScmSourceUrl() );
     }
 
     public void testGetUrlFromProjectDevConnectionSimulate()
         throws Exception
     {
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setScmSourceUrl( "scm:svn:https://localhost/tmp/repo" );
+
         MavenProject project = createProject( "1.0-SNAPSHOT" );
-        Scm scm = new Scm();
-        scm.setConnection( "scm:svn:file://localhost/tmp/repo" );
-        scm.setDeveloperConnection( "scm:svn:https://localhost/tmp/repo" );
-        project.setScm( scm );
 
-        phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), Collections.singletonList( project ) );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), Collections.singletonList( project ) );
 
-        assertEquals( "Check URL", "scm:svn:https://localhost/tmp/repo", releaseDescriptor.getScmSourceUrl() );
+        assertEquals( "Check URL", "scm:svn:https://localhost/tmp/repo", ReleaseUtils.buildReleaseDescriptor( builder ).getScmSourceUrl() );
     }
 
     public void testGetInvalidUrl()
         throws Exception
     {
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setScmSourceUrl( "scm:cvs:" );
+
         MavenProject project = createProject( "1.0-SNAPSHOT" );
-        Scm scm = new Scm();
-        scm.setConnection( "scm:cvs:" );
-        project.setScm( scm );
 
         try
         {
-            phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), Collections.singletonList( project ) );
+            phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), Collections.singletonList( project ) );
 
             fail( "Should have thrown an exception" );
         }
@@ -145,7 +139,7 @@
     public void testGetInvalidProvider()
         throws Exception
     {
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
         MavenProject project = createProject( "1.0-SNAPSHOT" );
         Scm scm = new Scm();
         scm.setConnection( "scm:foo:" );
@@ -153,7 +147,7 @@
 
         try
         {
-            phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), Collections.singletonList( project ) );
+            phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), Collections.singletonList( project ) );
 
             fail( "Should have thrown an exception" );
         }
@@ -166,11 +160,11 @@
     public void testMissingUrl()
         throws Exception
     {
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
 
         try
         {
-            phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), Collections.singletonList( createProject( "1.0-SNAPSHOT" ) ) );
+            phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), Collections.singletonList( createProject( "1.0-SNAPSHOT" ) ) );
 
             fail( "Should have failed to execute" );
         }
@@ -181,7 +175,7 @@
 
         try
         {
-            phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), Collections.singletonList( createProject( "1.0-SNAPSHOT" ) ) );
+            phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), Collections.singletonList( createProject( "1.0-SNAPSHOT" ) ) );
 
             fail( "Should have failed to simulate" );
         }
@@ -194,12 +188,12 @@
     public void testReleasingNonSnapshot()
         throws Exception
     {
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setScmSourceUrl( "scm-url" );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setScmSourceUrl( "scm:svn:file://localhost/tmp/repo" );
 
         try
         {
-            phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), Collections.singletonList( createProject( "1.0" ) ) );
+            phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), Collections.singletonList( createProject( "1.0" ) ) );
 
             fail( "Should have failed to execute" );
         }
@@ -210,7 +204,7 @@
 
         try
         {
-            phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), Collections.singletonList( createProject( "1.0" ) ) );
+            phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), Collections.singletonList( createProject( "1.0" ) ) );
 
             fail( "Should have failed to simulate" );
         }
diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/CheckoutProjectFromScmTest.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/CheckoutProjectFromScmTest.java
index 8f714aa..defcb17 100644
--- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/CheckoutProjectFromScmTest.java
+++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/CheckoutProjectFromScmTest.java
@@ -45,7 +45,8 @@
 import org.apache.maven.scm.repository.ScmRepository;
 import org.apache.maven.scm.repository.ScmRepositoryException;
 import org.apache.maven.shared.release.ReleaseExecutionException;
-import org.apache.maven.shared.release.config.ReleaseDescriptor;
+import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder;
+import org.apache.maven.shared.release.config.ReleaseUtils;
 import org.apache.maven.shared.release.env.DefaultReleaseEnvironment;
 import org.apache.maven.shared.release.scm.ReleaseScmRepositoryException;
 import org.apache.maven.shared.release.stubs.ScmManagerStub;
@@ -73,13 +74,13 @@
         throws Exception
     {
         // prepare
-        ReleaseDescriptor descriptor = new ReleaseDescriptor();
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
         File checkoutDirectory = getTestFile( "target/checkout-test/standard" );
-        descriptor.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
-        descriptor.setScmReleaseLabel( "release-label" );
+        builder.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
+        builder.setScmReleaseLabel( "release-label" );
         String sourceUrl = "file://localhost/tmp/scm-repo/trunk";
         String scmUrl = "scm:svn:" + sourceUrl;
-        descriptor.setScmSourceUrl( scmUrl );
+        builder.setScmSourceUrl( scmUrl );
 
         ScmProvider scmProviderMock = mock( ScmProvider.class );
         SvnScmProviderRepository scmProviderRepository = new SvnScmProviderRepository( sourceUrl );
@@ -98,10 +99,10 @@
         List<MavenProject> reactorProjects = createReactorProjects( dir, dir, null );
 
         // execute
-        phase.execute( descriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // prepare
-        assertEquals( "", descriptor.getScmRelativePathProjectDirectory() );
+        assertEquals( "", ReleaseUtils.buildReleaseDescriptor( builder ).getScmRelativePathProjectDirectory() );
 
         verify( scmProviderMock ).checkOut( eq( repository ),
                                             argThat( new IsScmFileSetEquals( new ScmFileSet( checkoutDirectory ) ) ),
@@ -115,13 +116,13 @@
         throws Exception
     {
         // prepare
-        ReleaseDescriptor descriptor = new ReleaseDescriptor();
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
         File checkoutDirectory = getTestFile( "target/checkout-test/multimodule-with-deep-subprojects" );
-        descriptor.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
-        descriptor.setScmReleaseLabel( "release-label" );
+        builder.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
+        builder.setScmReleaseLabel( "release-label" );
         String sourceUrl = "file://localhost/tmp/scm-repo/trunk";
         String scmUrl = "scm:svn:" + sourceUrl;
-        descriptor.setScmSourceUrl( scmUrl );
+        builder.setScmSourceUrl( scmUrl );
 
         ScmProvider scmProviderMock = mock( ScmProvider.class );
         SvnScmProviderRepository scmProviderRepository = new SvnScmProviderRepository( sourceUrl );
@@ -141,10 +142,10 @@
             createReactorProjects( dir, dir, null );
 
         // execute
-        phase.execute( descriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertEquals( "", descriptor.getScmRelativePathProjectDirectory() );
+        assertEquals( "", ReleaseUtils.buildReleaseDescriptor( builder ).getScmRelativePathProjectDirectory() );
 
         verify( scmProviderMock ).checkOut( eq( repository ),
                                             argThat( new IsScmFileSetEquals( new ScmFileSet( checkoutDirectory ) ) ),
@@ -158,13 +159,13 @@
         throws Exception
     {
         // prepare
-        ReleaseDescriptor descriptor = new ReleaseDescriptor();
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
         File checkoutDirectory = getTestFile( "target/checkout-test/flat-multi-module" );
-        descriptor.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
-        descriptor.setScmReleaseLabel( "release-label" );
+        builder.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
+        builder.setScmReleaseLabel( "release-label" );
         String sourceUrl = "file://localhost/tmp/scm-repo/trunk/root-project";
         String scmUrl = "scm:svn:" + sourceUrl;
-        descriptor.setScmSourceUrl( scmUrl );
+        builder.setScmSourceUrl( scmUrl );
 
         ScmProvider scmProviderMock = mock( ScmProvider.class );
         SvnScmProviderRepository scmProviderRepository = new SvnScmProviderRepository( sourceUrl );
@@ -183,11 +184,11 @@
             createReactorProjects( "rewrite-for-release/pom-with-parent-flat", "root-project" );
 
         // execute
-        phase.execute( descriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertEquals( "not found root-project but " + descriptor.getScmRelativePathProjectDirectory(), "root-project",
-                      descriptor.getScmRelativePathProjectDirectory() );
+        assertEquals( "not found root-project but " + ReleaseUtils.buildReleaseDescriptor( builder ).getScmRelativePathProjectDirectory(), "root-project",
+                      ReleaseUtils.buildReleaseDescriptor( builder ).getScmRelativePathProjectDirectory() );
 
         verify( scmProviderMock ).checkOut( eq( repository ),
                                             argThat( new IsScmFileSetEquals( new ScmFileSet( checkoutDirectory ) ) ),
@@ -201,9 +202,9 @@
                     throws Exception
     {
         // prepare
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setScmSourceUrl( "scm-url" );
-        releaseDescriptor.setWorkingDirectory( getTestFile( "target/test/checkout" ).getAbsolutePath() );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setScmSourceUrl( "scm-url" );
+        builder.setWorkingDirectory( getTestFile( "target/test/checkout" ).getAbsolutePath() );
 
         ScmManagerStub scmManagerStub = (ScmManagerStub) lookup( ScmManager.class );
         scmManagerStub.setException( new NoSuchScmProviderException( "..." )  );
@@ -214,9 +215,9 @@
         // execute
         try
         {
-            releaseDescriptor.setUseReleaseProfile( false );
+            builder.setUseReleaseProfile( false );
 
-            phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "commit should have failed" );
         }
@@ -231,9 +232,9 @@
         throws Exception
     {
         // prepare
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setScmSourceUrl( "scm-url" );
-        releaseDescriptor.setWorkingDirectory( getTestFile( "target/test/checkout" ).getAbsolutePath() );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setScmSourceUrl( "scm-url" );
+        builder.setWorkingDirectory( getTestFile( "target/test/checkout" ).getAbsolutePath() );
 
         ScmManagerStub scmManagerStub = (ScmManagerStub) lookup( ScmManager.class );
         scmManagerStub.setException( new ScmRepositoryException( "..." )  );
@@ -244,9 +245,9 @@
         // execute
         try
         {
-            releaseDescriptor.setUseReleaseProfile( false );
+            builder.setUseReleaseProfile( false );
 
-            phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "commit should have failed" );
         }
diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/EndReleasePhaseTest.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/EndReleasePhaseTest.java
index 1c17c64..990bd41 100644
--- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/EndReleasePhaseTest.java
+++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/EndReleasePhaseTest.java
@@ -25,7 +25,8 @@
 import org.apache.maven.shared.release.ReleaseExecutionException;
 import org.apache.maven.shared.release.ReleaseFailureException;
 import org.apache.maven.shared.release.ReleaseResult;
-import org.apache.maven.shared.release.config.ReleaseDescriptor;
+import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder;
+import org.apache.maven.shared.release.config.ReleaseUtils;
 import org.apache.maven.shared.release.env.DefaultReleaseEnvironment;
 import org.junit.Test;
 
@@ -45,14 +46,14 @@
     {
         super.setUp();
 
-        phase = (ReleasePhase) lookup( ReleasePhase.class, "end-release" );
+        phase = lookup( ReleasePhase.class, "end-release" );
     }
 
     @Test
     public void testExecute()
         throws ReleaseExecutionException, ReleaseFailureException
     {
-        ReleaseResult result = phase.execute( new ReleaseDescriptor(), new DefaultReleaseEnvironment(), null );
+        ReleaseResult result = phase.execute( ReleaseUtils.buildReleaseDescriptor( new ReleaseDescriptorBuilder() ), new DefaultReleaseEnvironment(), null );
 
         assertEquals( ReleaseResult.SUCCESS, result.getResultCode() );
     }
@@ -61,7 +62,7 @@
     public void testSimulate()
         throws ReleaseExecutionException, ReleaseFailureException
     {
-        ReleaseResult result = phase.simulate( new ReleaseDescriptor(), new DefaultReleaseEnvironment(), null );
+        ReleaseResult result = phase.simulate( ReleaseUtils.buildReleaseDescriptor( new ReleaseDescriptorBuilder() ), new DefaultReleaseEnvironment(), null );
 
         assertEquals( ReleaseResult.SUCCESS, result.getResultCode() );
     }
diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/GenerateReleasePomsPhaseTest.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/GenerateReleasePomsPhaseTest.java
index d261323..744e143 100644
--- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/GenerateReleasePomsPhaseTest.java
+++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/GenerateReleasePomsPhaseTest.java
@@ -45,7 +45,8 @@
 import org.apache.maven.scm.manager.ScmManagerStub;
 import org.apache.maven.scm.provider.ScmProvider;
 import org.apache.maven.scm.repository.ScmRepository;
-import org.apache.maven.shared.release.config.ReleaseDescriptor;
+import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder;
+import org.apache.maven.shared.release.config.ReleaseUtils;
 import org.apache.maven.shared.release.env.DefaultReleaseEnvironment;
 import org.apache.maven.shared.release.util.ReleaseUtil;
 import org.junit.Test;
@@ -100,9 +101,9 @@
         throws Exception
     {
         List<MavenProject> reactorProjects = createReactorProjects( "external-range-dependency" );
-        ReleaseDescriptor config = createMappedConfiguration( reactorProjects );
+        ReleaseDescriptorBuilder builder = createMappedConfiguration( reactorProjects );
 
-        phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         comparePomFiles( reactorProjects );
     }
@@ -113,13 +114,13 @@
         throws Exception
     {
         List<MavenProject> reactorProjects = createReactorProjects( "basic-pom" );
-        ReleaseDescriptor config = new ReleaseDescriptor();
-        config.setGenerateReleasePoms( true );
-        config.setSuppressCommitBeforeTagOrBranch( true );
-        config.setRemoteTagging( false );
-        mapNextVersion( config, "groupId:artifactId" );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setGenerateReleasePoms( true );
+        builder.setSuppressCommitBeforeTagOrBranch( true );
+        builder.setRemoteTagging( false );
+        mapNextVersion( builder, "groupId:artifactId" );
 
-        phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         verify( scmProviderMock ).add( isA( ScmRepository.class ), isA( ScmFileSet.class ) );
 
@@ -131,13 +132,13 @@
         throws Exception
     {
         List<MavenProject> reactorProjects = createReactorProjects( "basic-pom" );
-        ReleaseDescriptor config = new ReleaseDescriptor();
-        config.setGenerateReleasePoms( true );
-        config.setSuppressCommitBeforeTagOrBranch( true );
-        config.setRemoteTagging( true );
-        mapNextVersion( config, "groupId:artifactId" );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setGenerateReleasePoms( true );
+        builder.setSuppressCommitBeforeTagOrBranch( true );
+        builder.setRemoteTagging( true );
+        mapNextVersion( builder, "groupId:artifactId" );
 
-        phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         verify( scmProviderMock ).add( isA( ScmRepository.class ), isA( ScmFileSet.class ) );
 
@@ -150,10 +151,10 @@
         throws Exception
     {
         List<MavenProject> reactorProjects = createReactorProjects( "pom-with-finalname" );
-        ReleaseDescriptor config = createConfigurationForWithParentNextVersion( reactorProjects );
-        config.setGenerateReleasePoms( true );
+        ReleaseDescriptorBuilder builder = createConfigurationForWithParentNextVersion( reactorProjects );
+        builder.setGenerateReleasePoms( true );
 
-        phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         assertTrue( comparePomFiles( reactorProjects ) );
     }
@@ -164,12 +165,12 @@
      * util.List)
      */
     @Override
-    protected ReleaseDescriptor createDescriptorFromProjects( List<MavenProject> reactorProjects )
+    protected ReleaseDescriptorBuilder createDescriptorFromProjects( List<MavenProject> reactorProjects )
     {
-        ReleaseDescriptor descriptor = super.createDescriptorFromProjects( reactorProjects );
-        descriptor.setScmReleaseLabel( "release-label" );
-        descriptor.setGenerateReleasePoms( true );
-        return descriptor;
+        ReleaseDescriptorBuilder builder = super.createDescriptorFromProjects( reactorProjects );
+        builder.setScmReleaseLabel( "release-label" );
+        builder.setGenerateReleasePoms( true );
+        return builder;
     }
 
     /*
@@ -230,14 +231,10 @@
         verifyNoMoreInteractions( scmProviderMock );
     }
 
-    /*
-     * @see org.apache.maven.shared.release.phase.AbstractRewritingReleasePhaseTestCase#mapNextVersion(org.apache.maven.
-     * shared.release.config.ReleaseDescriptor, java.lang.String)
-     */
     @Override
-    protected void mapNextVersion( ReleaseDescriptor config, String projectId )
+    protected void mapNextVersion( ReleaseDescriptorBuilder config, String projectId )
     {
-        config.mapReleaseVersion( projectId, NEXT_VERSION );
+        config.addReleaseVersion( projectId, NEXT_VERSION );
     }
 
     /*
@@ -246,9 +243,9 @@
      * maven.shared.release.config.ReleaseDescriptor, java.lang.String)
      */
     @Override
-    protected void mapAlternateNextVersion( ReleaseDescriptor config, String projectId )
+    protected void mapAlternateNextVersion( ReleaseDescriptorBuilder config, String projectId )
     {
-        config.mapReleaseVersion( projectId, ALTERNATIVE_NEXT_VERSION );
+        config.addReleaseVersion( projectId, ALTERNATIVE_NEXT_VERSION );
     }
 
     /*
@@ -257,7 +254,7 @@
      * shared.release.config.ReleaseDescriptor, java.lang.String)
      */
     @Override
-    protected void unmapNextVersion( ReleaseDescriptor config, String projectId )
+    protected void unmapNextVersion( ReleaseDescriptorBuilder config, String projectId )
     {
         // nothing to do
     }
@@ -267,15 +264,15 @@
      * createConfigurationForPomWithParentAlternateNextVersion(java.util.List)
      */
     @Override
-    protected ReleaseDescriptor createConfigurationForPomWithParentAlternateNextVersion( List<MavenProject> reactorProjects )
+    protected ReleaseDescriptorBuilder createConfigurationForPomWithParentAlternateNextVersion( List<MavenProject> reactorProjects )
         throws Exception
     {
-        ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
+        ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects );
 
-        config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION );
-        config.mapReleaseVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION );
+        builder.addReleaseVersion( "groupId:artifactId", NEXT_VERSION );
+        builder.addReleaseVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION );
 
-        return config;
+        return builder;
     }
 
     /*
@@ -283,15 +280,15 @@
      * createConfigurationForWithParentNextVersion(java.util.List)
      */
     @Override
-    protected ReleaseDescriptor createConfigurationForWithParentNextVersion( List<MavenProject> reactorProjects )
+    protected ReleaseDescriptorBuilder createConfigurationForWithParentNextVersion( List<MavenProject> reactorProjects )
         throws Exception
     {
-        ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
+        ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects );
 
-        config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION );
-        config.mapReleaseVersion( "groupId:subproject1", NEXT_VERSION );
+        builder.addReleaseVersion( "groupId:artifactId", NEXT_VERSION );
+        builder.addReleaseVersion( "groupId:subproject1", NEXT_VERSION );
 
-        return config;
+        return builder;
     }
 
     /*
diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/InputVariablesPhaseTest.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/InputVariablesPhaseTest.java
index 8342fbd..6476f04 100644
--- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/InputVariablesPhaseTest.java
+++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/InputVariablesPhaseTest.java
@@ -18,8 +18,10 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.fail;
 import static org.mockito.Matchers.eq;
 import static org.mockito.Matchers.isA;
 import static org.mockito.Mockito.mock;
@@ -35,7 +37,8 @@
 import org.apache.maven.project.MavenProject;
 import org.apache.maven.shared.release.PlexusJUnit4TestCase;
 import org.apache.maven.shared.release.ReleaseExecutionException;
-import org.apache.maven.shared.release.config.ReleaseDescriptor;
+import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder;
+import org.apache.maven.shared.release.config.ReleaseUtils;
 import org.apache.maven.shared.release.env.DefaultReleaseEnvironment;
 import org.codehaus.plexus.components.interactivity.Prompter;
 import org.codehaus.plexus.components.interactivity.PrompterException;
@@ -71,26 +74,26 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.0" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.mapReleaseVersion( "groupId:artifactId", "1.0" );
-        releaseDescriptor.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo" );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.addReleaseVersion( "groupId:artifactId", "1.0" );
+        builder.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo" );
 
         // execute
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertEquals( "Check tag", "tag-value", releaseDescriptor.getScmReleaseLabel() );
+        assertEquals( "Check tag", "tag-value", ReleaseUtils.buildReleaseDescriptor( builder ).getScmReleaseLabel() );
 
         // prepare
-        releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.mapReleaseVersion( "groupId:artifactId", "1.0" );
-        releaseDescriptor.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo" );
+        builder = new ReleaseDescriptorBuilder();
+        builder.addReleaseVersion( "groupId:artifactId", "1.0" );
+        builder.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo" );
 
         // execute
-        phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertEquals( "Check tag", "simulated-tag-value", releaseDescriptor.getScmReleaseLabel() );
+        assertEquals( "Check tag", "simulated-tag-value", ReleaseUtils.buildReleaseDescriptor( builder ).getScmReleaseLabel() );
 
         verify( mockPrompter, times( 2 ) ).prompt( isA( String.class ), eq( "artifactId-1.0" ) );
         verifyNoMoreInteractions( mockPrompter );
@@ -102,11 +105,11 @@
     {
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.0" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
 
         try
         {
-            phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "Expected an exception" );
         }
@@ -115,11 +118,11 @@
             assertNull( "check no cause", e.getCause() );
         }
 
-        releaseDescriptor = new ReleaseDescriptor();
+        builder = new ReleaseDescriptorBuilder();
 
         try
         {
-            phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "Expected an exception" );
         }
@@ -139,28 +142,28 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.0" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setInteractive( false );
-        releaseDescriptor.mapReleaseVersion( "groupId:artifactId", "1.0" );
-        releaseDescriptor.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo" );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setInteractive( false );
+        builder.addReleaseVersion( "groupId:artifactId", "1.0" );
+        builder.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo" );
 
         // execute
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertEquals( "Check tag", "artifactId-1.0", releaseDescriptor.getScmReleaseLabel() );
+        assertEquals( "Check tag", "artifactId-1.0", ReleaseUtils.buildReleaseDescriptor( builder ).getScmReleaseLabel() );
 
         // prepare
-        releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setInteractive( false );
-        releaseDescriptor.mapReleaseVersion( "groupId:artifactId", "1.0" );
-        releaseDescriptor.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo" );
+        builder = new ReleaseDescriptorBuilder();
+        builder.setInteractive( false );
+        builder.addReleaseVersion( "groupId:artifactId", "1.0" );
+        builder.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo" );
 
         // execute
-        phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertEquals( "Check tag", "artifactId-1.0", releaseDescriptor.getScmReleaseLabel() );
+        assertEquals( "Check tag", "artifactId-1.0", ReleaseUtils.buildReleaseDescriptor( builder ).getScmReleaseLabel() );
 
         // never use prompter
         verifyNoMoreInteractions( mockPrompter );
@@ -176,26 +179,26 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.0" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setInteractive( false );
-        releaseDescriptor.setScmReleaseLabel( "tag-value" );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setInteractive( false );
+        builder.setScmReleaseLabel( "tag-value" );
 
         // execute
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertEquals( "Check tag", "tag-value", releaseDescriptor.getScmReleaseLabel() );
+        assertEquals( "Check tag", "tag-value", ReleaseUtils.buildReleaseDescriptor( builder ).getScmReleaseLabel() );
 
         // prepare
-        releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setInteractive( false );
-        releaseDescriptor.setScmReleaseLabel( "simulated-tag-value" );
+        builder = new ReleaseDescriptorBuilder();
+        builder.setInteractive( false );
+        builder.setScmReleaseLabel( "simulated-tag-value" );
 
         // execute
-        phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertEquals( "Check tag", "simulated-tag-value", releaseDescriptor.getScmReleaseLabel() );
+        assertEquals( "Check tag", "simulated-tag-value", ReleaseUtils.buildReleaseDescriptor( builder ).getScmReleaseLabel() );
 
         // never use prompter
         verifyNoMoreInteractions( mockPrompter );
@@ -211,24 +214,24 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.0" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setScmReleaseLabel( "tag-value" );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setScmReleaseLabel( "tag-value" );
 
         // execute
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertEquals( "Check tag", "tag-value", releaseDescriptor.getScmReleaseLabel() );
+        assertEquals( "Check tag", "tag-value", ReleaseUtils.buildReleaseDescriptor( builder ).getScmReleaseLabel() );
 
         // prepare
-        releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setScmReleaseLabel( "simulated-tag-value" );
+        builder = new ReleaseDescriptorBuilder();
+        builder.setScmReleaseLabel( "simulated-tag-value" );
 
         // execute
-        phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertEquals( "Check tag", "simulated-tag-value", releaseDescriptor.getScmReleaseLabel() );
+        assertEquals( "Check tag", "simulated-tag-value", ReleaseUtils.buildReleaseDescriptor( builder ).getScmReleaseLabel() );
 
         // never use prompter
         verifyNoMoreInteractions( mockPrompter );
@@ -246,14 +249,14 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.0" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.mapReleaseVersion( "groupId:artifactId", "1.0" );
-        releaseDescriptor.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo" );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.addReleaseVersion( "groupId:artifactId", "1.0" );
+        builder.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo" );
 
         // execute
         try
         {
-            phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "Expected an exception" );
         }
@@ -263,14 +266,14 @@
         }
 
         // prepare
-        releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.mapReleaseVersion( "groupId:artifactId", "1.0" );
-        releaseDescriptor.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo" );
+        builder = new ReleaseDescriptorBuilder();
+        builder.addReleaseVersion( "groupId:artifactId", "1.0" );
+        builder.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo" );
 
         // execute
         try
         {
-            phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "Expected an exception" );
         }
@@ -295,28 +298,28 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.0" ) );
 
-        ReleaseDescriptor releaseConfiguration = new ReleaseDescriptor();
-        releaseConfiguration.setInteractive( false );
-        releaseConfiguration.mapReleaseVersion( "groupId:artifactId", "1.0" );
-        releaseConfiguration.setScmSourceUrl( "scm:cvs:pserver:anoncvs@localhost:/tmp/scm-repo:module" );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setInteractive( false );
+        builder.addReleaseVersion( "groupId:artifactId", "1.0" );
+        builder.setScmSourceUrl( "scm:cvs:pserver:anoncvs@localhost:/tmp/scm-repo:module" );
 
         // execute
-        phase.execute( releaseConfiguration, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertEquals( "Check tag", "artifactId-1_0", releaseConfiguration.getScmReleaseLabel() );
+        assertEquals( "Check tag", "artifactId-1_0", ReleaseUtils.buildReleaseDescriptor( builder ).getScmReleaseLabel() );
 
         // prepare
-        releaseConfiguration = new ReleaseDescriptor();
-        releaseConfiguration.setInteractive( false );
-        releaseConfiguration.mapReleaseVersion( "groupId:artifactId", "1.0" );
-        releaseConfiguration.setScmSourceUrl( "scm:cvs:pserver:anoncvs@localhost:/tmp/scm-repo:module" );
+        builder = new ReleaseDescriptorBuilder();
+        builder.setInteractive( false );
+        builder.addReleaseVersion( "groupId:artifactId", "1.0" );
+        builder.setScmSourceUrl( "scm:cvs:pserver:anoncvs@localhost:/tmp/scm-repo:module" );
 
         // execute
-        phase.simulate( releaseConfiguration, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertEquals( "Check tag", "artifactId-1_0", releaseConfiguration.getScmReleaseLabel() );
+        assertEquals( "Check tag", "artifactId-1_0", ReleaseUtils.buildReleaseDescriptor( builder ).getScmReleaseLabel() );
 
         // never use prompter
         verifyNoMoreInteractions( mockPrompter );
@@ -332,29 +335,29 @@
         phase.setPrompter( mockPrompter );
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.0" ) );
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setInteractive( false );
-        releaseDescriptor.mapReleaseVersion( "groupId:artifactId", "1.0" );
-        releaseDescriptor.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo" );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setInteractive( false );
+        builder.addReleaseVersion( "groupId:artifactId", "1.0" );
+        builder.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo" );
 
         // execute
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertEquals( "Check tag", "artifactId-1.0", releaseDescriptor.getScmReleaseLabel() );
+        assertEquals( "Check tag", "artifactId-1.0", ReleaseUtils.buildReleaseDescriptor( builder ).getScmReleaseLabel() );
 
         // prepare
-        releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setInteractive( false );
-        releaseDescriptor.mapReleaseVersion( "groupId:artifactId", "1.0" );
-        releaseDescriptor.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo" );
-        releaseDescriptor.setScmTagNameFormat( "simulated-@{artifactId}-@{version}" );
+        builder = new ReleaseDescriptorBuilder();
+        builder.setInteractive( false );
+        builder.addReleaseVersion( "groupId:artifactId", "1.0" );
+        builder.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo" );
+        builder.setScmTagNameFormat( "simulated-@{artifactId}-@{version}" );
 
         // execute
-        phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertEquals( "Check tag", "simulated-artifactId-1.0", releaseDescriptor.getScmReleaseLabel() );
+        assertEquals( "Check tag", "simulated-artifactId-1.0", ReleaseUtils.buildReleaseDescriptor( builder ).getScmReleaseLabel() );
 
         // never use prompter
         verifyNoMoreInteractions( mockPrompter );
diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/MapDevelopmentVersionPhaseIT.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/MapDevelopmentVersionPhaseIT.java
index 9f03a92..bbd5520 100644
--- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/MapDevelopmentVersionPhaseIT.java
+++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/MapDevelopmentVersionPhaseIT.java
@@ -24,7 +24,8 @@
 
 import org.apache.maven.model.Model;
 import org.apache.maven.project.MavenProject;
-import org.apache.maven.shared.release.config.ReleaseDescriptor;
+import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder;
+import org.apache.maven.shared.release.config.ReleaseUtils;
 import org.apache.maven.shared.release.env.DefaultReleaseEnvironment;
 import org.codehaus.plexus.PlexusTestCase;
 
@@ -38,7 +39,7 @@
         throws Exception
     {
         super.setUp();
-        mapVersionsPhase = (MapVersionsPhase) lookup( ReleasePhase.class.getName(), "map-development-versions" );
+        mapVersionsPhase = (MapVersionsPhase) lookup( ReleasePhase.class, "map-development-versions" );
     }
 
     private static MavenProject createProject( String artifactId, String version )
@@ -52,13 +53,13 @@
 
     public void testNoUpdateWorkingCopyVersions() throws Exception
     {
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setInteractive( false );
-        releaseDescriptor.setUpdateWorkingCopyVersions( false );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setInteractive( false );
+        builder.setUpdateWorkingCopyVersions( false );
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.0" ) );
-        mapVersionsPhase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        mapVersionsPhase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
-        assertEquals( "1.0", releaseDescriptor.getDevelopmentVersions().get( "groupId:artifactId" ) );
+        assertEquals( "1.0", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion( "groupId:artifactId" ) );
     }
 }
diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/MapVersionsPhaseTest.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/MapVersionsPhaseTest.java
index 8feb4aa..36e98bb 100644
--- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/MapVersionsPhaseTest.java
+++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/MapVersionsPhaseTest.java
@@ -32,15 +32,14 @@
 
 import java.util.ArrayList;
 import java.util.Collections;
-import java.util.HashMap;
 import java.util.List;
-import java.util.Map;
 
 import org.apache.maven.model.Model;
 import org.apache.maven.project.MavenProject;
 import org.apache.maven.shared.release.PlexusJUnit4TestCase;
 import org.apache.maven.shared.release.ReleaseExecutionException;
-import org.apache.maven.shared.release.config.ReleaseDescriptor;
+import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder;
+import org.apache.maven.shared.release.config.ReleaseUtils;
 import org.apache.maven.shared.release.env.DefaultReleaseEnvironment;
 import org.apache.maven.shared.release.policy.PolicyException;
 import org.apache.maven.shared.release.versions.VersionParseException;
@@ -103,14 +102,14 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( project );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
 
         // execute
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "2.0" ),
-                      releaseDescriptor.getReleaseVersions() );
+        assertEquals( "Check mapped versions", "2.0",
+                      ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion( "groupId:artifactId" ) );
 
         verify( mockPrompter ).prompt( startsWith( "What is the release version for \"" + project.getName() + "\"?" ),
                                        eq( "1.0" ) );
@@ -130,14 +129,14 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( project );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
 
         // execute
-        phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "2.0" ),
-                      releaseDescriptor.getReleaseVersions() );
+        assertEquals( "Check mapped versions", "2.0",
+                      ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion( "groupId:artifactId" ) );
         verify( mockPrompter ).prompt( startsWith( "What is the release version for \"" + project.getName() + "\"?" ),
                                        eq( "1.0" ) );
     }
@@ -157,24 +156,24 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( project );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
 
         // execute
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "1.0.0" ),
-                      releaseDescriptor.getReleaseVersions() );
+        assertEquals( "Check mapped versions", "1.0.0",
+                      ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion( "groupId:artifactId" ) );
 
         // prepare
-        releaseDescriptor = new ReleaseDescriptor();
+        builder = new ReleaseDescriptorBuilder();
 
         // execute
-        phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "1.0.0" ),
-                      releaseDescriptor.getReleaseVersions() );
+        assertEquals( "Check mapped versions", "1.0.0",
+                      ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion( "groupId:artifactId" ) );
         verify( mockPrompter,
                 times( 2 ) ).prompt( startsWith( "What is the release version for \"" + project.getName() + "\"?" ),
                                      eq( "1.0" ) );
@@ -197,24 +196,24 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( project );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
 
         // execute
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "2.0" ),
-                      releaseDescriptor.getReleaseVersions() );
+        assertEquals( "Check mapped versions", "2.0",
+                      ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion( "groupId:artifactId" ) );
 
         // prepare
-        releaseDescriptor = new ReleaseDescriptor();
+        builder = new ReleaseDescriptorBuilder();
 
         // execute
-        phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "2.0" ),
-                      releaseDescriptor.getReleaseVersions() );
+        assertEquals( "Check mapped versions", "2.0",
+                      ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId") );
 
         verify( mockPrompter,
                 times( 2 ) ).prompt( startsWith( "What is the release version for \"" + project.getName() + "\"?" ),
@@ -233,28 +232,28 @@
 
         MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.class, TEST_MAP_RELEASE_VERSIONS );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.addReleaseVersion( "groupId:artifactId", "2.0" );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.addReleaseVersion( "groupId:artifactId", "2.0" );
 
         phase.setPrompter( mockPrompter );
 
         // execute
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "2.0" ),
-                      releaseDescriptor.getReleaseVersions() );
+        assertEquals( "Check mapped versions", "2.0",
+                      ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId") );
 
         // prepare
-        releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.addReleaseVersion( "groupId:artifactId", "2.0" );
+        builder = new ReleaseDescriptorBuilder();
+        builder.addReleaseVersion( "groupId:artifactId", "2.0" );
 
         // execute
-        phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "2.0" ),
-                      releaseDescriptor.getReleaseVersions() );
+        assertEquals( "Check mapped versions", "2.0",
+                      ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId") );
     }
 
     @Test
@@ -266,15 +265,15 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.0-SNAPSHOT" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setInteractive( false );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setInteractive( false );
 
         // execute
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "1.0" ),
-                      releaseDescriptor.getReleaseVersions() );
+        assertEquals( "Check mapped versions", "1.0" ,
+                      ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId") );
     }
 
     @Test
@@ -286,15 +285,15 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.0-SNAPSHOT" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setInteractive( false );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setInteractive( false );
 
         // execute
-        phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "1.0" ),
-                      releaseDescriptor.getReleaseVersions() );
+        assertEquals( "Check mapped versions", "1.0" ,
+                      ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId") );
     }
 
     @Test
@@ -311,24 +310,24 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( project );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
 
         // execute
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "2.0-SNAPSHOT" ),
-                      releaseDescriptor.getDevelopmentVersions() );
+        assertEquals( "Check mapped versions", "2.0-SNAPSHOT",
+                      ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") );
 
         // prepare
-        releaseDescriptor = new ReleaseDescriptor();
+        builder = new ReleaseDescriptorBuilder();
 
         // execute
-        phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "2.0-SNAPSHOT" ),
-                      releaseDescriptor.getDevelopmentVersions() );
+        assertEquals( "Check mapped versions", "2.0-SNAPSHOT",
+                      ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") );
 
         verify( mockPrompter, times( 2 ) ).prompt( startsWith( "What is the new development version for \""
             + project.getName() + "\"?" ), eq( "1.1-SNAPSHOT" ) );
@@ -349,26 +348,26 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( project );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setUpdateWorkingCopyVersions( false );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setUpdateWorkingCopyVersions( false );
 
         // execute
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "1.0" ),
-                      releaseDescriptor.getDevelopmentVersions() );
+        assertEquals( "Check mapped versions", "1.0",
+                      ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") );
 
         // prepare
-        releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setUpdateWorkingCopyVersions( false );
+        builder = new ReleaseDescriptorBuilder();
+        builder.setUpdateWorkingCopyVersions( false );
 
         // execute
-        phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "1.0" ),
-                      releaseDescriptor.getDevelopmentVersions() );
+        assertEquals( "Check mapped versions", "1.0" ,
+                      ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") );
     }
 
     @Test
@@ -382,26 +381,26 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.0" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setInteractive( false );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setInteractive( false );
 
         // execute
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "1.1-SNAPSHOT" ),
-                      releaseDescriptor.getDevelopmentVersions() );
+        assertEquals( "Check mapped versions", "1.1-SNAPSHOT",
+                      ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") );
 
         // prepare
-        releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setInteractive( false );
+        builder = new ReleaseDescriptorBuilder();
+        builder.setInteractive( false );
 
         // execute
-        phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "1.1-SNAPSHOT" ),
-                      releaseDescriptor.getDevelopmentVersions() );
+        assertEquals( "Check mapped versions", "1.1-SNAPSHOT",
+                      ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") );
     }
 
     /**
@@ -417,28 +416,28 @@
 
         phase.setPrompter( mockPrompter );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setInteractive( false );
-        releaseDescriptor.addDevelopmentVersion( "groupId:artifactId", "2-SNAPSHOT" );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setInteractive( false );
+        builder.addDevelopmentVersion( "groupId:artifactId", "2-SNAPSHOT" );
 
         // execute
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "2-SNAPSHOT" ),
-                      releaseDescriptor.getDevelopmentVersions() );
+        assertEquals( "Check mapped versions", "2-SNAPSHOT",
+                      ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") );
 
         // prepare
-        releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setInteractive( false );
-        releaseDescriptor.addDevelopmentVersion( "groupId:artifactId", "2-SNAPSHOT" );
+        builder = new ReleaseDescriptorBuilder();
+        builder.setInteractive( false );
+        builder.addDevelopmentVersion( "groupId:artifactId", "2-SNAPSHOT" );
 
         // execute
-        phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "2-SNAPSHOT" ),
-                      releaseDescriptor.getDevelopmentVersions() );
+        assertEquals( "Check mapped versions", "2-SNAPSHOT",
+                      ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") );
     }
 
     @Test
@@ -454,12 +453,12 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.0" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
 
         // execute
         try
         {
-            phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "Expected an exception" );
         }
@@ -469,12 +468,12 @@
         }
 
         // prepare
-        releaseDescriptor = new ReleaseDescriptor();
+        builder = new ReleaseDescriptorBuilder();
 
         // execute
         try
         {
-            phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "Expected an exception" );
         }
@@ -501,24 +500,24 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( project );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
 
         // execute
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "2.0-SNAPSHOT" ),
-                      releaseDescriptor.getDevelopmentVersions() );
+        assertEquals( "Check mapped versions", "2.0-SNAPSHOT",
+                      ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") );
 
         // prepare
-        releaseDescriptor = new ReleaseDescriptor();
+        builder = new ReleaseDescriptorBuilder();
 
         // execute
-        phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "2.0-SNAPSHOT" ),
-                      releaseDescriptor.getDevelopmentVersions() );
+        assertEquals( "Check mapped versions", "2.0-SNAPSHOT" ,
+                      ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") );
 
         verify( mockPrompter, times( 2 ) ).prompt( startsWith( "What is the new development version for \""
             + project.getName() + "\"?" ), eq( "1.1-SNAPSHOT" ) );
@@ -532,12 +531,12 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "foo" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setInteractive( false );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setInteractive( false );
 
         try
         {
-            phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "Expected an exception" );
         }
@@ -546,12 +545,12 @@
             assertEquals( "check cause", VersionParseException.class, e.getCause().getClass() );
         }
 
-        releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setInteractive( false );
+        builder = new ReleaseDescriptorBuilder();
+        builder.setInteractive( false );
 
         try
         {
-            phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "Expected an exception" );
         }
@@ -570,17 +569,17 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setBranchCreation( true );
-        releaseDescriptor.setDefaultDevelopmentVersion( "1.1.1-SNAPSHOT" );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setBranchCreation( true );
+        builder.setDefaultDevelopmentVersion( "1.1.1-SNAPSHOT" );
 
         // test
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) );
-        assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.1.1-SNAPSHOT" ),
-                      releaseDescriptor.getDevelopmentVersions() );
+        assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId" ) );
+        assertEquals( "Check development versions", "1.1.1-SNAPSHOT" ,
+                      ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") );
     }
 
     @Test
@@ -592,17 +591,17 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setBranchCreation( true );
-        releaseDescriptor.setDefaultDevelopmentVersion( "1.1.1-SNAPSHOT" );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setBranchCreation( true );
+        builder.setDefaultDevelopmentVersion( "1.1.1-SNAPSHOT" );
 
         // test
-        phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) );
-        assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.1.1-SNAPSHOT" ),
-                      releaseDescriptor.getDevelopmentVersions() );
+        assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId" ) );
+        assertEquals( "Check development versions", "1.1.1-SNAPSHOT" ,
+                      ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") );
     }
 
     @Test
@@ -614,18 +613,18 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setBranchCreation( true );
-        releaseDescriptor.setDefaultDevelopmentVersion( "1.1.1-SNAPSHOT" );
-        releaseDescriptor.setInteractive( false );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setBranchCreation( true );
+        builder.setDefaultDevelopmentVersion( "1.1.1-SNAPSHOT" );
+        builder.setInteractive( false );
 
         // test
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) );
-        assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.1.1-SNAPSHOT" ),
-                      releaseDescriptor.getDevelopmentVersions() );
+        assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId" ) );
+        assertEquals( "Check development versions", "1.1.1-SNAPSHOT" ,
+                      ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") );
     }
 
     @Test
@@ -637,18 +636,18 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setBranchCreation( true );
-        releaseDescriptor.setDefaultDevelopmentVersion( "1.1.1-SNAPSHOT" );
-        releaseDescriptor.setInteractive( false );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setBranchCreation( true );
+        builder.setDefaultDevelopmentVersion( "1.1.1-SNAPSHOT" );
+        builder.setInteractive( false );
 
         // test
-        phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) );
-        assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.1.1-SNAPSHOT" ),
-                      releaseDescriptor.getDevelopmentVersions() );
+        assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId" ) );
+        assertEquals( "Check development versions", "1.1.1-SNAPSHOT" ,
+                      ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") );
     }
 
     @Test
@@ -660,17 +659,17 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setBranchCreation( true );
-        releaseDescriptor.setInteractive( false );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setBranchCreation( true );
+        builder.setInteractive( false );
 
         // test
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) );
-        assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.3-SNAPSHOT" ),
-                      releaseDescriptor.getDevelopmentVersions() );
+        assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId" ) );
+        assertEquals( "Check development versions", "1.3-SNAPSHOT" ,
+                      ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") );
     }
 
     @Test
@@ -682,17 +681,17 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setBranchCreation( true );
-        releaseDescriptor.setInteractive( false );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setBranchCreation( true );
+        builder.setInteractive( false );
 
         // test
-        phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) );
-        assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.3-SNAPSHOT" ),
-                      releaseDescriptor.getDevelopmentVersions() );
+        assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion( "groupId:artifactId" ) );
+        assertEquals( "Check development versions", "1.3-SNAPSHOT" ,
+                      ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") );
     }
 
     @Test
@@ -704,16 +703,16 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setDefaultDevelopmentVersion( "1.1.1-SNAPSHOT" );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setDefaultDevelopmentVersion( "1.1.1-SNAPSHOT" );
 
         // test
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) );
-        assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.1.1-SNAPSHOT" ),
-                      releaseDescriptor.getDevelopmentVersions() );
+        assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion( "groupId:artifactId" ) );
+        assertEquals( "Check development versions", "1.1.1-SNAPSHOT" ,
+                      ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") );
     }
 
     @Test
@@ -725,16 +724,16 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setDefaultDevelopmentVersion( "1.1.1-SNAPSHOT" );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setDefaultDevelopmentVersion( "1.1.1-SNAPSHOT" );
 
         // test
-        phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) );
-        assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.1.1-SNAPSHOT" ),
-                      releaseDescriptor.getDevelopmentVersions() );
+        assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId" ) );
+        assertEquals( "Check development versions", "1.1.1-SNAPSHOT" ,
+                      ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") );
     }
 
     @Test
@@ -746,17 +745,17 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setDefaultDevelopmentVersion( "1.1.1-SNAPSHOT" );
-        releaseDescriptor.setInteractive( false );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setDefaultDevelopmentVersion( "1.1.1-SNAPSHOT" );
+        builder.setInteractive( false );
 
         // test
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) );
-        assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.1.1-SNAPSHOT" ),
-                      releaseDescriptor.getDevelopmentVersions() );
+        assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId" ) );
+        assertEquals( "Check development versions", "1.1.1-SNAPSHOT" ,
+                      ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") );
     }
 
     @Test
@@ -768,17 +767,17 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setDefaultDevelopmentVersion( "1.1.1-SNAPSHOT" );
-        releaseDescriptor.setInteractive( false );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setDefaultDevelopmentVersion( "1.1.1-SNAPSHOT" );
+        builder.setInteractive( false );
 
         // test
-        phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) );
-        assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.1.1-SNAPSHOT" ),
-                      releaseDescriptor.getDevelopmentVersions() );
+        assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion( "groupId:artifactId" ) );
+        assertEquals( "Check development versions", "1.1.1-SNAPSHOT" ,
+                      ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") );
     }
 
     @Test
@@ -790,16 +789,16 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setInteractive( false );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setInteractive( false );
 
         // test
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) );
-        assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.3-SNAPSHOT" ),
-                      releaseDescriptor.getDevelopmentVersions() );
+        assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId" ) );
+        assertEquals( "Check development versions", "1.3-SNAPSHOT" ,
+                      ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") );
     }
 
     @Test
@@ -811,16 +810,16 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setInteractive( false );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setInteractive( false );
 
         // test
-        phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) );
-        assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.3-SNAPSHOT" ),
-                      releaseDescriptor.getDevelopmentVersions() );
+        assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion( "groupId:artifactId" ) );
+        assertEquals( "Check development versions", "1.3-SNAPSHOT",
+                      ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") );
     }
 
     @Test
@@ -832,17 +831,17 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setAutoVersionSubmodules( true );
-        releaseDescriptor.setInteractive( false );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setAutoVersionSubmodules( true );
+        builder.setInteractive( false );
 
         // test
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.3-SNAPSHOT" ),
-                      releaseDescriptor.getDevelopmentVersions() );
-        assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) );
+        assertEquals( "Check development versions", "1.3-SNAPSHOT",
+                      ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") );
+        assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion( "groupId:artifactId" ) );
     }
 
     @Test
@@ -854,17 +853,17 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setAutoVersionSubmodules( true );
-        releaseDescriptor.setInteractive( false );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setAutoVersionSubmodules( true );
+        builder.setInteractive( false );
 
         // test
-        phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.3-SNAPSHOT" ),
-                      releaseDescriptor.getDevelopmentVersions() );
-        assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) );
+        assertEquals( "Check development versions", "1.3-SNAPSHOT",
+                      ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") );
+        assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId" ) );
     }
 
     @Test
@@ -876,17 +875,17 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setAutoVersionSubmodules( true );
-        releaseDescriptor.setInteractive( false );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setAutoVersionSubmodules( true );
+        builder.setInteractive( false );
 
         // test
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.3-SNAPSHOT" ),
-                      releaseDescriptor.getDevelopmentVersions() );
-        assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) );
+        assertEquals( "Check development versions",  "1.3-SNAPSHOT",
+                      ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") );
+        assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion( "groupId:artifactId" ) );
     }
 
     @Test
@@ -898,17 +897,17 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setAutoVersionSubmodules( true );
-        releaseDescriptor.setInteractive( false );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setAutoVersionSubmodules( true );
+        builder.setInteractive( false );
 
         // test
-        phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.3-SNAPSHOT" ),
-                      releaseDescriptor.getDevelopmentVersions() );
-        assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) );
+        assertEquals( "Check development versions", "1.3-SNAPSHOT",
+                      ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") );
+        assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion( "groupId:artifactId" ) );
     }
 
     @Test
@@ -920,18 +919,18 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setAutoVersionSubmodules( true );
-        releaseDescriptor.setInteractive( false );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setAutoVersionSubmodules( true );
+        builder.setInteractive( false );
 
         // test
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertEquals( "Check release versions", Collections.singletonMap( "groupId:artifactId", "1.2" ),
-                      releaseDescriptor.getReleaseVersions() );
+        assertEquals( "Check release versions", "1.2",
+                      ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId") );
         assertNull( "Check development versions",
-                    releaseDescriptor.getDevelopmentVersions().get( "groupId:artifactId" ) );
+                    ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId" ) );
     }
 
     @Test
@@ -943,18 +942,18 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setAutoVersionSubmodules( true );
-        releaseDescriptor.setInteractive( false );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setAutoVersionSubmodules( true );
+        builder.setInteractive( false );
 
         // test
-        phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertEquals( "Check release versions", Collections.singletonMap( "groupId:artifactId", "1.2" ),
-                      releaseDescriptor.getReleaseVersions() );
+        assertEquals( "Check release versions",  "1.2" ,
+                      ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId") );
         assertNull( "Check development versions",
-                    releaseDescriptor.getDevelopmentVersions().get( "groupId:artifactId" ) );
+                    ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId" ) );
     }
 
     @Test
@@ -966,18 +965,18 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setAutoVersionSubmodules( true );
-        releaseDescriptor.setInteractive( false );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setAutoVersionSubmodules( true );
+        builder.setInteractive( false );
 
         // test
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertEquals( "Check release versions", Collections.singletonMap( "groupId:artifactId", "1.2" ),
-                      releaseDescriptor.getReleaseVersions() );
+        assertEquals( "Check release versions", "1.2",
+                      ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId") );
         assertNull( "Check development versions",
-                    releaseDescriptor.getDevelopmentVersions().get( "groupId:artifactId" ) );
+                    ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId" ) );
     }
 
     @Test
@@ -989,18 +988,18 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setAutoVersionSubmodules( true );
-        releaseDescriptor.setInteractive( false );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setAutoVersionSubmodules( true );
+        builder.setInteractive( false );
 
         // test
-        phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertEquals( "Check release versions", Collections.singletonMap( "groupId:artifactId", "1.2" ),
-                      releaseDescriptor.getReleaseVersions() );
+        assertEquals( "Check release versions", "1.2",
+                      ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId") );
         assertNull( "Check development versions",
-                    releaseDescriptor.getDevelopmentVersions().get( "groupId:artifactId" ) );
+                    ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId" ) );
     }
 
     @Test
@@ -1012,18 +1011,18 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setAutoVersionSubmodules( true );
-        releaseDescriptor.setBranchCreation( true );
-        releaseDescriptor.setInteractive( false );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setAutoVersionSubmodules( true );
+        builder.setBranchCreation( true );
+        builder.setInteractive( false );
 
         // test
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.3-SNAPSHOT" ),
-                      releaseDescriptor.getDevelopmentVersions() );
-        assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) );
+        assertEquals( "Check development versions", "1.3-SNAPSHOT",
+                      ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") );
+        assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion( "groupId:artifactId" ) );
     }
 
     @Test
@@ -1035,18 +1034,18 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setAutoVersionSubmodules( true );
-        releaseDescriptor.setBranchCreation( true );
-        releaseDescriptor.setInteractive( false );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setAutoVersionSubmodules( true );
+        builder.setBranchCreation( true );
+        builder.setInteractive( false );
 
         // test
-        phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.3-SNAPSHOT" ),
-                      releaseDescriptor.getDevelopmentVersions() );
-        assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) );
+        assertEquals( "Check development versions", "1.3-SNAPSHOT",
+                      ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") );
+        assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion( "groupId:artifactId" ) );
     }
 
     @Test
@@ -1058,18 +1057,18 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setAutoVersionSubmodules( true );
-        releaseDescriptor.setBranchCreation( true );
-        releaseDescriptor.setInteractive( false );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setAutoVersionSubmodules( true );
+        builder.setBranchCreation( true );
+        builder.setInteractive( false );
 
         // test
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.2" ),
-                      releaseDescriptor.getDevelopmentVersions() );
-        assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) );
+        assertEquals( "Check development versions", "1.2",
+                      ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") );
+        assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId" ) );
     }
 
     @Test
@@ -1081,18 +1080,18 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setAutoVersionSubmodules( true );
-        releaseDescriptor.setBranchCreation( true );
-        releaseDescriptor.setInteractive( false );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setAutoVersionSubmodules( true );
+        builder.setBranchCreation( true );
+        builder.setInteractive( false );
 
         // test
-        phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.2" ),
-                      releaseDescriptor.getDevelopmentVersions() );
-        assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) );
+        assertEquals( "Check development versions", "1.2",
+                      ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") );
+        assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion( "groupId:artifactId" ) );
     }
 
     @Test
@@ -1104,19 +1103,19 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setAutoVersionSubmodules( true );
-        releaseDescriptor.setBranchCreation( true );
-        releaseDescriptor.setInteractive( false );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setAutoVersionSubmodules( true );
+        builder.setBranchCreation( true );
+        builder.setInteractive( false );
 
         // test
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertEquals( "Check release versions", Collections.singletonMap( "groupId:artifactId", "1.2-SNAPSHOT" ),
-                      releaseDescriptor.getReleaseVersions() );
+        assertEquals( "Check release versions", "1.2-SNAPSHOT",
+                      ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId") );
         assertNull( "Check development versions",
-                    releaseDescriptor.getDevelopmentVersions().get( "groupId:artifactId" ) );
+                    ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId" ) );
     }
 
     @Test
@@ -1128,19 +1127,19 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setAutoVersionSubmodules( true );
-        releaseDescriptor.setBranchCreation( true );
-        releaseDescriptor.setInteractive( false );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setAutoVersionSubmodules( true );
+        builder.setBranchCreation( true );
+        builder.setInteractive( false );
 
         // test
-        phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertEquals( "Check release versions", Collections.singletonMap( "groupId:artifactId", "1.2-SNAPSHOT" ),
-                      releaseDescriptor.getReleaseVersions() );
+        assertEquals( "Check release versions", "1.2-SNAPSHOT",
+                      ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId") );
         assertNull( "Check development versions",
-                    releaseDescriptor.getDevelopmentVersions().get( "groupId:artifactId" ) );
+                    ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId" ) );
     }
 
     @Test
@@ -1152,13 +1151,13 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setAutoVersionSubmodules( true );
-        releaseDescriptor.setBranchCreation( true );
-        releaseDescriptor.setInteractive( false );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setAutoVersionSubmodules( true );
+        builder.setBranchCreation( true );
+        builder.setInteractive( false );
 
         // test
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
         /*
@@ -1166,10 +1165,10 @@
          * This is true for trunk, but when branching from a tag I would expect the next SNAPSHOT version. For now keep
          * '1.2' instead of '1.3-SNAPSHOT' until further investigation.
          */
-        assertEquals( "Check release versions", Collections.singletonMap( "groupId:artifactId", "1.2" ),
-                      releaseDescriptor.getReleaseVersions() );
+        assertEquals( "Check release versions", "1.2",
+                      ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId" ) );
         assertNull( "Check development versions",
-                    releaseDescriptor.getDevelopmentVersions().get( "groupId:artifactId" ) );
+                    ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion( "groupId:artifactId" ) );
     }
 
     @Test
@@ -1181,13 +1180,13 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setAutoVersionSubmodules( true );
-        releaseDescriptor.setBranchCreation( true );
-        releaseDescriptor.setInteractive( false );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setAutoVersionSubmodules( true );
+        builder.setBranchCreation( true );
+        builder.setInteractive( false );
 
         // test
-        phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
         /*
@@ -1195,10 +1194,10 @@
          * This is true for trunk, but when branching from a tag I would expect the next SNAPSHOT version. For now keep
          * '1.2' instead of '1.3-SNAPSHOT' until further investigation.
          */
-        assertEquals( "Check release versions", Collections.singletonMap( "groupId:artifactId", "1.2" ),
-                      releaseDescriptor.getReleaseVersions() );
+        assertEquals( "Check release versions",  "1.2" ,
+                      ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId") );
         assertNull( "Check development versions",
-                    releaseDescriptor.getDevelopmentVersions().get( "groupId:artifactId" ) );
+                    ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId" ) );
     }
 
     @Test
@@ -1210,22 +1209,22 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setBranchCreation( true );
-        releaseDescriptor.setInteractive( false );
-        releaseDescriptor.setUpdateBranchVersions( true );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setBranchCreation( true );
+        builder.setInteractive( false );
+        builder.setUpdateBranchVersions( true );
 
         // test
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
         // updateBranchVersions is set to true, so suggest the next snapshot version
         // org.apache.maven.release:maven-release-manager:(,2.4) > 1.2-SNAPSHOT
         // org.apache.maven.release:maven-release-manager:[2.4,) > 1.3-SNAPSHOT
-        assertEquals( "Check release versions", Collections.singletonMap( "groupId:artifactId", "1.3-SNAPSHOT" ),
-                      releaseDescriptor.getReleaseVersions() );
+        assertEquals( "Check release versions",  "1.3-SNAPSHOT",
+                      ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId") );
         assertNull( "Check development versions",
-                    releaseDescriptor.getDevelopmentVersions().get( "groupId:artifactId" ) );
+                    ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion( "groupId:artifactId" ) );
     }
 
     @Test
@@ -1237,22 +1236,22 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setBranchCreation( true );
-        releaseDescriptor.setInteractive( false );
-        releaseDescriptor.setUpdateBranchVersions( true );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setBranchCreation( true );
+        builder.setInteractive( false );
+        builder.setUpdateBranchVersions( true );
 
         // test
-        phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
         // updateBranchVersions is set to true, so suggest the next snapshot version
         // org.apache.maven.release:maven-release-manager:(,2.4) > 1.2-SNAPSHOT
         // org.apache.maven.release:maven-release-manager:[2.4,) > 1.3-SNAPSHOT
-        assertEquals( "Check release versions", Collections.singletonMap( "groupId:artifactId", "1.3-SNAPSHOT" ),
-                      releaseDescriptor.getReleaseVersions() );
+        assertEquals( "Check release versions", "1.3-SNAPSHOT",
+                      ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId" ) );
         assertNull( "Check development versions",
-                    releaseDescriptor.getDevelopmentVersions().get( "groupId:artifactId" ) );
+                    ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion( "groupId:artifactId" ) );
     }
 
     @Test
@@ -1264,20 +1263,20 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setBranchCreation( true );
-        releaseDescriptor.setDefaultReleaseVersion( "2.1-SNAPSHOT" );
-        releaseDescriptor.setInteractive( false );
-        releaseDescriptor.setUpdateBranchVersions( true );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setBranchCreation( true );
+        builder.setDefaultReleaseVersion( "2.1-SNAPSHOT" );
+        builder.setInteractive( false );
+        builder.setUpdateBranchVersions( true );
 
         // test
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertEquals( "Check release versions", Collections.singletonMap( "groupId:artifactId", "2.1-SNAPSHOT" ),
-                      releaseDescriptor.getReleaseVersions() );
+        assertEquals( "Check release versions", "2.1-SNAPSHOT",
+                      ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId") );
         assertNull( "Check development versions",
-                    releaseDescriptor.getDevelopmentVersions().get( "groupId:artifactId" ) );
+                    ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion( "groupId:artifactId" ) );
     }
 
     @Test
@@ -1289,20 +1288,20 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setBranchCreation( true );
-        releaseDescriptor.setDefaultReleaseVersion( "2.1-SNAPSHOT" );
-        releaseDescriptor.setInteractive( false );
-        releaseDescriptor.setUpdateBranchVersions( true );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setBranchCreation( true );
+        builder.setDefaultReleaseVersion( "2.1-SNAPSHOT" );
+        builder.setInteractive( false );
+        builder.setUpdateBranchVersions( true );
 
         // test
-        phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertEquals( "Check release versions", Collections.singletonMap( "groupId:artifactId", "2.1-SNAPSHOT" ),
-                      releaseDescriptor.getReleaseVersions() );
+        assertEquals( "Check release versions",  "2.1-SNAPSHOT",
+                      ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId") );
         assertNull( "Check development versions",
-                    releaseDescriptor.getDevelopmentVersions().get( "groupId:artifactId" ) );
+                    ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion( "groupId:artifactId" ) );
     }
 
     @Test
@@ -1314,19 +1313,19 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setBranchCreation( true );
-        releaseDescriptor.setDefaultReleaseVersion( "2.1-SNAPSHOT" );
-        releaseDescriptor.setUpdateBranchVersions( true );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setBranchCreation( true );
+        builder.setDefaultReleaseVersion( "2.1-SNAPSHOT" );
+        builder.setUpdateBranchVersions( true );
 
         // test
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertEquals( "Check release versions", Collections.singletonMap( "groupId:artifactId", "2.1-SNAPSHOT" ),
-                      releaseDescriptor.getReleaseVersions() );
+        assertEquals( "Check release versions", "2.1-SNAPSHOT",
+                      ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId") );
         assertNull( "Check development versions",
-                    releaseDescriptor.getDevelopmentVersions().get( "groupId:artifactId" ) );
+                    ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion( "groupId:artifactId" ) );
     }
 
     @Test
@@ -1338,19 +1337,19 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setBranchCreation( true );
-        releaseDescriptor.setDefaultReleaseVersion( "2.1-SNAPSHOT" );
-        releaseDescriptor.setUpdateBranchVersions( true );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setBranchCreation( true );
+        builder.setDefaultReleaseVersion( "2.1-SNAPSHOT" );
+        builder.setUpdateBranchVersions( true );
 
         // test
-        phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertEquals( "Check release versions", Collections.singletonMap( "groupId:artifactId", "2.1-SNAPSHOT" ),
-                      releaseDescriptor.getReleaseVersions() );
+        assertEquals( "Check release versions", "2.1-SNAPSHOT",
+                      ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId" ) );
         assertNull( "Check development versions",
-                    releaseDescriptor.getDevelopmentVersions().get( "groupId:artifactId" ) );
+                    ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion( "groupId:artifactId" ) );
     }
 
     @Test
@@ -1362,9 +1361,9 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setBranchCreation( true );
-        releaseDescriptor.setUpdateBranchVersions( true );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setBranchCreation( true );
+        builder.setUpdateBranchVersions( true );
 
         // updateBranchVersions is set to true, so suggest the next snapshot version
         // org.apache.maven.release:maven-release-manager:(,2.4) > 1.2-SNAPSHOT
@@ -1374,7 +1373,7 @@
         phase.setPrompter( mockPrompter );
 
         // test
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
         // org.apache.maven.release:maven-release-manager:(,2.4) > 1.2-SNAPSHOT
@@ -1391,9 +1390,9 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setBranchCreation( true );
-        releaseDescriptor.setUpdateBranchVersions( true );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setBranchCreation( true );
+        builder.setUpdateBranchVersions( true );
 
         // updateBranchVersions is set to true, so suggest the next snapshot version
         // org.apache.maven.release:maven-release-manager:(,2.4) > 1.2-SNAPSHOT
@@ -1403,7 +1402,7 @@
         phase.setPrompter( mockPrompter );
 
         // test
-        phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
         // org.apache.maven.release:maven-release-manager:(,2.4) > 1.2-SNAPSHOT
@@ -1420,10 +1419,10 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setBranchCreation( true );
-        releaseDescriptor.setUpdateBranchVersions( true );
-        releaseDescriptor.setUpdateVersionsToSnapshot( true );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setBranchCreation( true );
+        builder.setUpdateBranchVersions( true );
+        builder.setUpdateVersionsToSnapshot( true );
 
         // updateBranchVersions is set to true, so suggest the next snapshot version
         // org.apache.maven.release:maven-release-manager:(,2.4) > 1.2-SNAPSHOT (yes, one step back!)
@@ -1433,16 +1432,16 @@
         phase.setPrompter( mockPrompter );
 
         // test
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
         // org.apache.maven.release:maven-release-manager:(,2.4) > 1.2-SNAPSHOT (yes, one step back!)
         // org.apache.maven.release:maven-release-manager:[2.4,) > 1.3-SNAPSHOT
         verify( mockPrompter ).prompt( startsWith( "What is the branch version for" ), eq( "1.3-SNAPSHOT" ) );
-        assertEquals( "Check release versions", Collections.singletonMap( "groupId:artifactId", "2.1-SNAPSHOT" ),
-                      releaseDescriptor.getReleaseVersions() );
+        assertEquals( "Check release versions",  "2.1-SNAPSHOT" ,
+                      ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId") );
         assertNull( "Check development versions",
-                    releaseDescriptor.getDevelopmentVersions().get( "groupId:artifactId" ) );
+                    ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId" ) );
     }
 
     @Test
@@ -1454,10 +1453,10 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setBranchCreation( true );
-        releaseDescriptor.setUpdateBranchVersions( true );
-        releaseDescriptor.setUpdateVersionsToSnapshot( true );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setBranchCreation( true );
+        builder.setUpdateBranchVersions( true );
+        builder.setUpdateVersionsToSnapshot( true );
 
         // updateBranchVersions is set to true, so suggest the next snapshot version
         // org.apache.maven.release:maven-release-manager:(,2.4) > 1.2-SNAPSHOT (yes, one step back!)
@@ -1467,16 +1466,16 @@
         phase.setPrompter( mockPrompter );
 
         // test
-        phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
         // org.apache.maven.release:maven-release-manager:(,2.4) > 1.2-SNAPSHOT (yes, one step back!)
         // org.apache.maven.release:maven-release-manager:[2.4,) > 1.3-SNAPSHOT
         verify( mockPrompter ).prompt( startsWith( "What is the branch version for" ), eq( "1.3-SNAPSHOT" ) );
-        assertEquals( "Check release versions", Collections.singletonMap( "groupId:artifactId", "2.1-SNAPSHOT" ),
-                      releaseDescriptor.getReleaseVersions() );
+        assertEquals( "Check release versions", "2.1-SNAPSHOT",
+                      ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId") );
         assertNull( "Check development versions",
-                    releaseDescriptor.getDevelopmentVersions().get( "groupId:artifactId" ) );
+                    ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId" ) );
     }
 
     @Test
@@ -1488,10 +1487,10 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setBranchCreation( true );
-        releaseDescriptor.setUpdateBranchVersions( true );
-        releaseDescriptor.setUpdateVersionsToSnapshot( true );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setBranchCreation( true );
+        builder.setUpdateBranchVersions( true );
+        builder.setUpdateVersionsToSnapshot( true );
 
         // updateBranchVersions is set to true, so suggest the next snapshot version
         // org.apache.maven.release:maven-release-manager:(,2.4) > 1.2-SNAPSHOT
@@ -1501,7 +1500,7 @@
         phase.setPrompter( mockPrompter );
 
         // test
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
         // org.apache.maven.release:maven-release-manager:(,2.4) > 1.2-SNAPSHOT
@@ -1518,10 +1517,10 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setBranchCreation( true );
-        releaseDescriptor.setUpdateBranchVersions( true );
-        releaseDescriptor.setUpdateVersionsToSnapshot( true );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setBranchCreation( true );
+        builder.setUpdateBranchVersions( true );
+        builder.setUpdateVersionsToSnapshot( true );
 
         // updateBranchVersions is set to true, so suggest the next snapshot version
         // org.apache.maven.release:maven-release-manager:(,2.4) > 1.2-SNAPSHOT
@@ -1531,7 +1530,7 @@
         phase.setPrompter( mockPrompter );
 
         // test
-        phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
         // org.apache.maven.release:maven-release-manager:(,2.4) > 1.2-SNAPSHOT
@@ -1548,11 +1547,11 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setBranchCreation( true );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setBranchCreation( true );
 
         // test
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
         /*
@@ -1560,10 +1559,10 @@
          * This is true for trunk, but when branching from a tag I would expect the next SNAPSHOT version. For now keep
          * '1.2' instead of '1.3-SNAPSHOT' until further investigation.
          */
-        assertEquals( "Check release versions", Collections.singletonMap( "groupId:artifactId", "1.2" ),
-                      releaseDescriptor.getReleaseVersions() );
+        assertEquals( "Check release versions",  "1.2",
+                      ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId") );
         assertNull( "Check development versions",
-                    releaseDescriptor.getDevelopmentVersions().get( "groupId:artifactId" ) );
+                    ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion( "groupId:artifactId" ) );
     }
 
     @Test
@@ -1575,11 +1574,11 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setBranchCreation( true );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setBranchCreation( true );
 
         // test
-        phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
         /*
@@ -1587,10 +1586,10 @@
          * This is true for trunk, but when branching from a tag I would expect the next SNAPSHOT version. For now keep
          * '1.2' instead of '1.3-SNAPSHOT' until further investigation.
          */
-        assertEquals( "Check release versions", Collections.singletonMap( "groupId:artifactId", "1.2" ),
-                      releaseDescriptor.getReleaseVersions() );
+        assertEquals( "Check release versions", "1.2",
+                      ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId") );
         assertNull( "Check development versions",
-                    releaseDescriptor.getDevelopmentVersions().get( "groupId:artifactId" ) );
+                    ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId" ) );
     }
 
     @Test
@@ -1602,17 +1601,17 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setBranchCreation( true );
-        releaseDescriptor.setUpdateWorkingCopyVersions( false );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setBranchCreation( true );
+        builder.setUpdateWorkingCopyVersions( false );
 
         // test
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) );
-        assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.2" ),
-                      releaseDescriptor.getDevelopmentVersions() );
+        assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId" ) );
+        assertEquals( "Check development versions", "1.2",
+                      ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") );
     }
 
     @Test
@@ -1624,17 +1623,17 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setBranchCreation( true );
-        releaseDescriptor.setUpdateWorkingCopyVersions( false );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setBranchCreation( true );
+        builder.setUpdateWorkingCopyVersions( false );
 
         // test
-        phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) );
-        assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.2" ),
-                      releaseDescriptor.getDevelopmentVersions() );
+        assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion( "groupId:artifactId" ) );
+        assertEquals( "Check development versions", "1.2" ,
+                      ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") );
     }
 
     @Test
@@ -1646,17 +1645,17 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setBranchCreation( true );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setBranchCreation( true );
         // org.apache.maven.release:maven-release-manager:(,2.4) > true
         // org.apache.maven.release:maven-release-manager:[2.4,) > false
-        releaseDescriptor.setInteractive( false );
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        builder.setInteractive( false );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) );
-        assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.2" ),
-                      releaseDescriptor.getDevelopmentVersions() );
+        assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId" ) );
+        assertEquals( "Check development versions", "1.2" ,
+                      ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") );
     }
 
     @Test
@@ -1668,19 +1667,19 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setBranchCreation( true );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setBranchCreation( true );
         // org.apache.maven.release:maven-release-manager:(,2.4) > true
         // org.apache.maven.release:maven-release-manager:[2.4,) > false
-        releaseDescriptor.setInteractive( false );
+        builder.setInteractive( false );
 
         // test
-        phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) );
-        assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.2" ),
-                      releaseDescriptor.getDevelopmentVersions() );
+        assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId" ) );
+        assertEquals( "Check development versions", "1.2",
+                      ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") );
     }
 
     @Test
@@ -1692,17 +1691,17 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setBranchCreation( true );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setBranchCreation( true );
 
         // test
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertEquals( "Check release versions", Collections.singletonMap( "groupId:artifactId", "1.2-SNAPSHOT" ),
-                      releaseDescriptor.getReleaseVersions() );
+        assertEquals( "Check release versions", "1.2-SNAPSHOT",
+                      ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId") );
         assertNull( "Check development versions",
-                    releaseDescriptor.getDevelopmentVersions().get( "groupId:artifactId" ) );
+                    ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion( "groupId:artifactId" ) );
     }
 
     @Test
@@ -1714,17 +1713,17 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setBranchCreation( true );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setBranchCreation( true );
 
         // test
-        phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertEquals( "Check release versions", Collections.singletonMap( "groupId:artifactId", "1.2-SNAPSHOT" ),
-                      releaseDescriptor.getReleaseVersions() );
+        assertEquals( "Check release versions", "1.2-SNAPSHOT",
+                      ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId") );
         assertNull( "Check development versions",
-                    releaseDescriptor.getDevelopmentVersions().get( "groupId:artifactId" ) );
+                    ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion( "groupId:artifactId" ) );
     }
 
     @Test
@@ -1736,17 +1735,17 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setBranchCreation( true );
-        releaseDescriptor.setUpdateWorkingCopyVersions( false );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setBranchCreation( true );
+        builder.setUpdateWorkingCopyVersions( false );
 
         // test
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) );
-        assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.2-SNAPSHOT" ),
-                      releaseDescriptor.getDevelopmentVersions() );
+        assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion( "groupId:artifactId" ) );
+        assertEquals( "Check development versions", "1.2-SNAPSHOT",
+                      ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId" ) );
     }
 
     @Test
@@ -1758,17 +1757,17 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setBranchCreation( true );
-        releaseDescriptor.setUpdateWorkingCopyVersions( false );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setBranchCreation( true );
+        builder.setUpdateWorkingCopyVersions( false );
 
         // test
-        phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) );
-        assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.2-SNAPSHOT" ),
-                      releaseDescriptor.getDevelopmentVersions() );
+        assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion( "groupId:artifactId" ) );
+        assertEquals( "Check development versions", "1.2-SNAPSHOT",
+                      ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") );
     }
 
     @Test
@@ -1780,21 +1779,21 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setBranchCreation( true );
-        releaseDescriptor.setUpdateBranchVersions( true );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setBranchCreation( true );
+        builder.setUpdateBranchVersions( true );
         // org.apache.maven.release:maven-release-manager:(,2.4) > true
         // org.apache.maven.release:maven-release-manager:[2.4,) > false
-        releaseDescriptor.setInteractive( false );
+        builder.setInteractive( false );
 
         // test
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertEquals( "Check release versions", Collections.singletonMap( "groupId:artifactId", "1.2" ),
-                      releaseDescriptor.getReleaseVersions() );
+        assertEquals( "Check release versions", "1.2",
+                      ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId") );
         assertNull( "Check development versions",
-                    releaseDescriptor.getDevelopmentVersions().get( "groupId:artifactId" ) );
+                    ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId" ) );
     }
 
     @Test
@@ -1806,21 +1805,21 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setBranchCreation( true );
-        releaseDescriptor.setUpdateBranchVersions( true );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setBranchCreation( true );
+        builder.setUpdateBranchVersions( true );
         // org.apache.maven.release:maven-release-manager:(,2.4) > true
         // org.apache.maven.release:maven-release-manager:[2.4,) > false
-        releaseDescriptor.setInteractive( false );
+        builder.setInteractive( false );
 
         // test
-        phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertEquals( "Check release versions", Collections.singletonMap( "groupId:artifactId", "1.2" ),
-                      releaseDescriptor.getReleaseVersions() );
+        assertEquals( "Check release versions", "1.2" ,
+                      ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId") );
         assertNull( "Check development versions",
-                    releaseDescriptor.getDevelopmentVersions().get( "groupId:artifactId" ) );
+                    ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId" ) );
     }
 
     @Test
@@ -1832,16 +1831,16 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setBranchCreation( true );
-        releaseDescriptor.setUpdateWorkingCopyVersions( true );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setBranchCreation( true );
+        builder.setUpdateWorkingCopyVersions( true );
 
         when( mockPrompter.prompt( startsWith( "What is the new working copy version for" ),
                                    eq( "1.3-SNAPSHOT" ) ) ).thenReturn( "2.0-SNAPSHOT" );
         phase.setPrompter( mockPrompter );
 
         // test
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
         verify( mockPrompter ).prompt( startsWith( "What is the new working copy version for" ), eq( "1.3-SNAPSHOT" ) );
@@ -1856,16 +1855,16 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setBranchCreation( true );
-        releaseDescriptor.setUpdateWorkingCopyVersions( true );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setBranchCreation( true );
+        builder.setUpdateWorkingCopyVersions( true );
 
         when( mockPrompter.prompt( startsWith( "What is the new working copy version for" ),
                                    eq( "1.3-SNAPSHOT" ) ) ).thenReturn( "2.0-SNAPSHOT" );
         phase.setPrompter( mockPrompter );
 
         // test
-        phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
         verify( mockPrompter ).prompt( startsWith( "What is the new working copy version for" ), eq( "1.3-SNAPSHOT" ) );
@@ -1882,19 +1881,18 @@
         Collections.addAll( reactorProjects, createProject( "artifactId", "1.2-SNAPSHOT" ),
                             createProject( "module1", "2.0" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setAutoVersionSubmodules( true );
-        releaseDescriptor.setInteractive( false );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setAutoVersionSubmodules( true );
+        builder.setInteractive( false );
 
         // test
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        Map<String, String> developmentVersions = new HashMap<>();
-        developmentVersions.put( "groupId:artifactId", "1.3-SNAPSHOT" );
-        developmentVersions.put( "groupId:module1", "2.0" );
-        assertEquals( "Check development versions", developmentVersions, releaseDescriptor.getDevelopmentVersions() );
-        assertEquals( "Check release versions", 0, releaseDescriptor.getReleaseVersions().size() );
+        assertEquals( "Check development versions", "1.3-SNAPSHOT", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") );
+        assertEquals( "Check development versions", "2.0" , ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:module1") );
+        assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId") );
+        assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:module1") );
     }
 
     @Test
@@ -1908,19 +1906,18 @@
         Collections.addAll( reactorProjects, createProject( "artifactId", "1.2-SNAPSHOT" ),
                             createProject( "module1", "2.0" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setAutoVersionSubmodules( true );
-        releaseDescriptor.setInteractive( false );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setAutoVersionSubmodules( true );
+        builder.setInteractive( false );
 
         // test
-        phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        Map<String, String> developmentVersions = new HashMap<>();
-        developmentVersions.put( "groupId:artifactId", "1.3-SNAPSHOT" );
-        developmentVersions.put( "groupId:module1", "2.0" );
-        assertEquals( "Check development versions", developmentVersions, releaseDescriptor.getDevelopmentVersions() );
-        assertEquals( "Check release versions", 0, releaseDescriptor.getReleaseVersions().size() );
+        assertEquals( "Check development versions", "1.3-SNAPSHOT", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion( "groupId:artifactId" ) );
+        assertEquals( "Check development versions", "2.0", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:module1") );
+        assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId") );
+        assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:module1") );
     }
 
     @Test
@@ -1933,18 +1930,18 @@
         List<MavenProject> reactorProjects =
             Collections.singletonList( createProject( "artifactId", "1.2.1-SNAPSHOT" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setAutoVersionSubmodules( true );
-        releaseDescriptor.setDefaultReleaseVersion( "3.0" );
-        releaseDescriptor.setInteractive( false );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setAutoVersionSubmodules( true );
+        builder.setDefaultReleaseVersion( "3.0" );
+        builder.setInteractive( false );
 
         // test
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "3.1-SNAPSHOT" ),
-                      releaseDescriptor.getDevelopmentVersions() );
-        assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) );
+        assertEquals( "Check development versions", "3.1-SNAPSHOT" ,
+                      ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") );
+        assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId" ) );
     }
 
     @Test
@@ -1957,18 +1954,18 @@
         List<MavenProject> reactorProjects =
             Collections.singletonList( createProject( "artifactId", "1.2.1-SNAPSHOT" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setAutoVersionSubmodules( true );
-        releaseDescriptor.setDefaultReleaseVersion( "3.0" );
-        releaseDescriptor.setInteractive( false );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setAutoVersionSubmodules( true );
+        builder.setDefaultReleaseVersion( "3.0" );
+        builder.setInteractive( false );
 
         // test
-        phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "3.1-SNAPSHOT" ),
-                      releaseDescriptor.getDevelopmentVersions() );
-        assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) );
+        assertEquals( "Check development versions", "3.1-SNAPSHOT",
+                      ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") );
+        assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion( "groupId:artifactId" ) );
     }
 
     @Test
@@ -1981,18 +1978,18 @@
         List<MavenProject> reactorProjects =
             Collections.singletonList( createProject( "artifactId", "1.2.1-SNAPSHOT" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setAutoVersionSubmodules( true );
-        releaseDescriptor.setDefaultDevelopmentVersion( "3.0-SNAPSHOT" );
-        releaseDescriptor.setInteractive( false );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setAutoVersionSubmodules( true );
+        builder.setDefaultDevelopmentVersion( "3.0-SNAPSHOT" );
+        builder.setInteractive( false );
 
         // test
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "3.0-SNAPSHOT" ),
-                      releaseDescriptor.getDevelopmentVersions() );
-        assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) );
+        assertEquals( "Check development versions", "3.0-SNAPSHOT",
+                      ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") );
+        assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion( "groupId:artifactId" ) );
     }
 
     @Test
@@ -2005,18 +2002,18 @@
         List<MavenProject> reactorProjects =
             Collections.singletonList( createProject( "artifactId", "1.2.1-SNAPSHOT" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setAutoVersionSubmodules( true );
-        releaseDescriptor.setDefaultDevelopmentVersion( "3.0-SNAPSHOT" );
-        releaseDescriptor.setInteractive( false );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setAutoVersionSubmodules( true );
+        builder.setDefaultDevelopmentVersion( "3.0-SNAPSHOT" );
+        builder.setInteractive( false );
 
         // test
-        phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
-        assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "3.0-SNAPSHOT" ),
-                      releaseDescriptor.getDevelopmentVersions() );
-        assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) );
+        assertEquals( "Check development versions", "3.0-SNAPSHOT",
+                      ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") );
+        assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion( "groupId:artifactId" ) );
     }
 
     // MRELEASE-511
@@ -2031,20 +2028,20 @@
         List<MavenProject> reactorProjects =
             Collections.singletonList( createProject( "artifactId", "MYB_200909-SNAPSHOT" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setDefaultReleaseVersion( "PPX" );
-        releaseDescriptor.setDefaultDevelopmentVersion( "MYB_200909-SNAPSHOT" );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setDefaultReleaseVersion( "PPX" );
+        builder.setDefaultDevelopmentVersion( "MYB_200909-SNAPSHOT" );
 
         // test
-        mapReleasephase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
-        mapDevelopmentphase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        mapReleasephase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
+        mapDevelopmentphase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
         assertEquals( "Check development versions",
-                      Collections.singletonMap( "groupId:artifactId", "MYB_200909-SNAPSHOT" ),
-                      releaseDescriptor.getDevelopmentVersions() );
-        assertEquals( "Check release versions", Collections.singletonMap( "groupId:artifactId", "PPX" ),
-                      releaseDescriptor.getReleaseVersions() );
+                      "MYB_200909-SNAPSHOT",
+                      ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") );
+        assertEquals( "Check release versions", "PPX",
+                      ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion( "groupId:artifactId" ) );
     }
 
     // MRELEASE-269
@@ -2057,7 +2054,7 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "bar", "1.11-SNAPSHOT" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
 
         when( mockPrompter.prompt( startsWith( "What is the new development version for " ),
                                    eq( "1.12-SNAPSHOT" ) ) ).thenReturn( "2.0" ) // wrong, expected SNAPSHOT
@@ -2065,7 +2062,7 @@
         phase.setPrompter( mockPrompter );
 
         // test
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
         verify( mockPrompter, times( 2 ) ).prompt( startsWith( "What is the new development version for " ),
@@ -2082,15 +2079,15 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "bar", "1.11-SNAPSHOT" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setDefaultDevelopmentVersion( "" );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setDefaultDevelopmentVersion( "" );
 
         when( mockPrompter.prompt( startsWith( "What is the new development version for " ),
                                    eq( "1.12-SNAPSHOT" ) ) ).thenReturn( "2.0-SNAPSHOT" );
         phase.setPrompter( mockPrompter );
 
         // test
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
         verify( mockPrompter ).prompt( startsWith( "What is the new development version for " ),
@@ -2106,15 +2103,15 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "bar", "1.11-SNAPSHOT" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setDefaultReleaseVersion( "" );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setDefaultReleaseVersion( "" );
 
         when( mockPrompter.prompt( startsWith( "What is the release version for " ),
                                    eq( "1.11" ) ) ).thenReturn( "2.0" );
         phase.setPrompter( mockPrompter );
 
         // test
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
         verify( mockPrompter ).prompt( startsWith( "What is the release version for " ), eq( "1.11" ) );
@@ -2136,11 +2133,11 @@
 
         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.0-SNAPSHOT" ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setProjectVersionPolicyId( "UNKNOWN" );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setProjectVersionPolicyId( "UNKNOWN" );
 
         // test
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
     }
 
     private static MavenProject createProject( String artifactId, String version )
diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RemoveReleasePomsPhaseTest.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RemoveReleasePomsPhaseTest.java
index 54caabe..964a5cf 100644
--- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RemoveReleasePomsPhaseTest.java
+++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RemoveReleasePomsPhaseTest.java
@@ -46,7 +46,8 @@
 import org.apache.maven.scm.provider.ScmProvider;
 import org.apache.maven.scm.repository.ScmRepository;
 import org.apache.maven.shared.release.ReleaseResult;
-import org.apache.maven.shared.release.config.ReleaseDescriptor;
+import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder;
+import org.apache.maven.shared.release.config.ReleaseUtils;
 import org.apache.maven.shared.release.env.DefaultReleaseEnvironment;
 import org.apache.maven.shared.release.util.ReleaseUtil;
 import org.codehaus.plexus.util.IOUtil;
@@ -66,7 +67,7 @@
     {
         super.setUp();
 
-        phase = (ReleasePhase) lookup( ReleasePhase.class, "remove-release-poms" );
+        phase = lookup( ReleasePhase.class, "remove-release-poms" );
     }
 
     @Test
@@ -74,12 +75,13 @@
         throws Exception
     {
         // prepare
+        File workingDirectory = getTestFile( "target/test/checkout" );
         List<MavenProject> reactorProjects = createReactorProjects( "basic-pom" );
-        ReleaseDescriptor config = createReleaseDescriptor();
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( workingDirectory );
         MavenProject project = ReleaseUtil.getRootProject( reactorProjects );
 
         File releasePom = ReleaseUtil.getReleasePom( project );
-        ScmFileSet fileSet = new ScmFileSet( new File( config.getWorkingDirectory() ), releasePom );
+        ScmFileSet fileSet = new ScmFileSet( workingDirectory, releasePom );
 
         ScmProvider scmProviderMock = mock( ScmProvider.class );
         when( scmProviderMock.remove( isA( ScmRepository.class ), argThat( new IsScmFileSetEquals( fileSet ) ),
@@ -91,7 +93,7 @@
         stub.setScmProvider( scmProviderMock );
 
         // execute
-        phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
         verify( scmProviderMock ).remove( isA( ScmRepository.class ), argThat( new IsScmFileSetEquals( fileSet ) ),
@@ -104,8 +106,9 @@
         throws Exception
     {
         // prepare
+        File workingDirectory = getTestFile( "target/test/checkout" );
         List<MavenProject> reactorProjects = createReactorProjects( "pom-with-modules" );
-        ReleaseDescriptor config = createReleaseDescriptor();
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder();
 
         List<File> releasePoms = new ArrayList<>();
         for ( Iterator<MavenProject> iterator = reactorProjects.iterator(); iterator.hasNext(); )
@@ -115,7 +118,7 @@
             releasePoms.add( releasePom );
         }
 
-        ScmFileSet fileSet = new ScmFileSet( new File( config.getWorkingDirectory() ), releasePoms );
+        ScmFileSet fileSet = new ScmFileSet( workingDirectory, releasePoms );
 
         ScmProvider scmProviderMock = mock( ScmProvider.class );
         when( scmProviderMock.remove( isA( ScmRepository.class ), argThat( new IsScmFileSetEquals( fileSet ) ),
@@ -127,7 +130,7 @@
         stub.setScmProvider( scmProviderMock );
 
         // execute
-        phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
         verify( scmProviderMock ).remove( isA( ScmRepository.class ), argThat( new IsScmFileSetEquals( fileSet ) ),
@@ -141,7 +144,7 @@
     {
         // prepare
         List<MavenProject> reactorProjects = createReactorProjects( "basic-pom" );
-        ReleaseDescriptor config = createReleaseDescriptor();
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder();
 
         ScmProvider scmProviderMock = mock( ScmProvider.class );
 
@@ -149,7 +152,7 @@
         stub.setScmProvider( scmProviderMock );
 
         // execute
-        phase.simulate( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // never invoke scmProviderMock
         verifyNoMoreInteractions( scmProviderMock );
@@ -161,9 +164,9 @@
     {
         // prepare
         List<MavenProject> reactorProjects = createReactorProjects( "basic-pom" );
-        ReleaseDescriptor config = createReleaseDescriptor();
-        config.setSuppressCommitBeforeTagOrBranch( true );
-        config.setGenerateReleasePoms( true );
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder();
+        builder.setSuppressCommitBeforeTagOrBranch( true );
+        builder.setGenerateReleasePoms( true );
 
         ScmProvider scmProviderMock = mock( ScmProvider.class );
 
@@ -171,7 +174,7 @@
         stub.setScmProvider( scmProviderMock );
 
         // execute
-        ReleaseResult result = phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        ReleaseResult result = phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         BufferedReader reader = null;
         try
@@ -197,9 +200,9 @@
     {
         // prepare
         List<MavenProject> reactorProjects = createReactorProjects( "basic-pom" );
-        ReleaseDescriptor config = createReleaseDescriptor();
-        config.setSuppressCommitBeforeTagOrBranch( true );
-        config.setGenerateReleasePoms( true );
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder();
+        builder.setSuppressCommitBeforeTagOrBranch( true );
+        builder.setGenerateReleasePoms( true );
 
         ScmProvider scmProviderMock = mock( ScmProvider.class );
 
@@ -207,7 +210,7 @@
         stub.setScmProvider( scmProviderMock );
 
         // execute
-        ReleaseResult result = phase.simulate( config, new DefaultReleaseEnvironment(), reactorProjects );
+        ReleaseResult result = phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         BufferedReader reader = null;
         try
@@ -236,11 +239,16 @@
         return createReactorProjects( dir, dir, null );
     }
 
-    private ReleaseDescriptor createReleaseDescriptor()
+    private ReleaseDescriptorBuilder createReleaseDescriptorBuilder()
     {
-        ReleaseDescriptor descriptor = new ReleaseDescriptor();
-        descriptor.setGenerateReleasePoms( true );
-        descriptor.setWorkingDirectory( getTestFile( "target/test/checkout" ).getAbsolutePath() );
-        return descriptor;
+        return createReleaseDescriptorBuilder( getTestFile( "target/test/checkout" ) );
+    }
+    
+    private ReleaseDescriptorBuilder createReleaseDescriptorBuilder( File workingDirectory )
+    {
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setGenerateReleasePoms( true );
+        builder.setWorkingDirectory( workingDirectory.getAbsolutePath() );
+        return builder;
     }
 }
diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RestoreBackupPomsPhaseTest.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RestoreBackupPomsPhaseTest.java
index e6ae373..dacb66a 100644
--- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RestoreBackupPomsPhaseTest.java
+++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RestoreBackupPomsPhaseTest.java
@@ -22,11 +22,11 @@
 import static org.junit.Assert.assertTrue;
 
 import java.io.File;
-import java.util.Iterator;
 import java.util.List;
 
 import org.apache.maven.project.MavenProject;
-import org.apache.maven.shared.release.config.ReleaseDescriptor;
+import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder;
+import org.apache.maven.shared.release.config.ReleaseUtils;
 import org.apache.maven.shared.release.env.DefaultReleaseEnvironment;
 import org.apache.maven.shared.release.util.ReleaseUtil;
 import org.codehaus.plexus.util.FileUtils;
@@ -44,7 +44,7 @@
     ReleasePhase getReleasePhase()
         throws Exception
     {
-        return (ReleasePhase) lookup( ReleasePhase.class, "restore-backup-poms" );
+        return lookup( ReleasePhase.class, "restore-backup-poms" );
     }
 
     @Test
@@ -84,9 +84,9 @@
     {
         List<MavenProject> projects = getReactorProjects( getTestPath( path ) );
 
-        ReleaseDescriptor desc = new ReleaseDescriptor();
-        desc.setScmSourceUrl( "scm:svn:http://myhost/myrepo" );
-        phase.execute( desc, new DefaultReleaseEnvironment(), projects );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setScmSourceUrl( "scm:svn:http://myhost/myrepo" );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), projects );
 
         testProjectIsRestored( projects );
     }
@@ -94,10 +94,8 @@
     private void testProjectIsRestored( List<MavenProject> reactorProjects )
         throws Exception
     {
-        for ( Iterator<MavenProject> projects = reactorProjects.iterator(); projects.hasNext(); )
+        for ( MavenProject project : reactorProjects )
         {
-            MavenProject project = projects.next();
-
             File pomFile = project.getFile();
 
             File expectedFile = new File( pomFile.getParentFile(), expectedPomFilename );
diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RewritePomsForBranchPhaseTest.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RewritePomsForBranchPhaseTest.java
index b9da089..6eb74b2 100644
--- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RewritePomsForBranchPhaseTest.java
+++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RewritePomsForBranchPhaseTest.java
@@ -25,12 +25,13 @@
 
 import java.io.File;
 import java.io.IOException;
-import java.util.Iterator;
 import java.util.List;
 import java.util.Objects;
 
+import org.apache.maven.artifact.ArtifactUtils;
 import org.apache.maven.project.MavenProject;
-import org.apache.maven.shared.release.config.ReleaseDescriptor;
+import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder;
+import org.apache.maven.shared.release.config.ReleaseUtils;
 import org.apache.maven.shared.release.env.DefaultReleaseEnvironment;
 import org.apache.maven.shared.release.util.ReleaseUtil;
 import org.junit.Test;
@@ -78,12 +79,12 @@
         throws Exception
     {
         List<MavenProject> reactorProjects = createReactorProjectsFromBasicPom();
-        ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects );
-        config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION );
+        ReleaseDescriptorBuilder builder = createDescriptorFromBasicPom( reactorProjects );
+        builder.addReleaseVersion( "groupId:artifactId", NEXT_VERSION );
 
         String expected = readTestProjectFile( "basic-pom/pom.xml" );
 
-        phase.simulate( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         String actual = readTestProjectFile( "basic-pom/pom.xml" );
         assertEquals( "Check the original POM untouched", expected, actual );
@@ -98,12 +99,12 @@
         throws Exception
     {
         List<MavenProject> reactorProjects = createReactorProjects( "basic-pom-with-dashes-in-comment" );
-        ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects );
-        config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION );
+        ReleaseDescriptorBuilder builder = createDescriptorFromBasicPom( reactorProjects );
+        builder.addReleaseVersion( "groupId:artifactId", NEXT_VERSION );
 
         String expected = readTestProjectFile( "basic-pom-with-dashes-in-comment/pom.xml" );
 
-        phase.simulate( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         String actual = readTestProjectFile( "basic-pom-with-dashes-in-comment/pom.xml" );
         assertEquals( "Check the original POM is untouched", expected, actual );
@@ -118,14 +119,14 @@
         throws Exception
     {
         List<MavenProject> reactorProjects = createReactorProjectsFromBasicPom();
-        ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects );
-        config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION );
+        ReleaseDescriptorBuilder builder = createDescriptorFromBasicPom( reactorProjects );
+        builder.addReleaseVersion( "groupId:artifactId", NEXT_VERSION );
 
         File testFile = getTestFile( "target/test-classes/projects/rewrite-for-branch/basic-pom/pom.xml.branch" );
         testFile.delete();
         assertFalse( testFile.exists() );
 
-        phase.simulate( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         assertTrue( testFile.exists() );
 
@@ -139,8 +140,8 @@
         throws Exception
     {
         List<MavenProject> reactorProjects = createReactorProjectsFromBasicPom();
-        ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects );
-        config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION );
+        ReleaseDescriptorBuilder builder = createDescriptorFromBasicPom( reactorProjects );
+        builder.addReleaseVersion( "groupId:artifactId", NEXT_VERSION );
 
         File testFile = getTestFile( "target/test-classes/projects/rewrite-for-branch/basic-pom/pom.xml.branch" );
         testFile.delete();
@@ -157,50 +158,50 @@
         throws Exception
     {
         List<MavenProject> reactorProjects = createReactorProjects( "pom-with-overridden-scm" );
-        ReleaseDescriptor config = createConfigurationForWithParentNextVersion( reactorProjects );
-        config.mapReleaseVersion( "groupId:subsubproject", NEXT_VERSION );
+        ReleaseDescriptorBuilder builder = createConfigurationForWithParentNextVersion( reactorProjects );
+        builder.addReleaseVersion( "groupId:subsubproject", NEXT_VERSION );
 
-        phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         assertTrue( comparePomFiles( reactorProjects ) );
     }
 
     @Override
-    protected void mapAlternateNextVersion( ReleaseDescriptor config, String projectId )
+    protected void mapAlternateNextVersion( ReleaseDescriptorBuilder config, String projectId )
     {
-        config.mapReleaseVersion( projectId, ALTERNATIVE_NEXT_VERSION );
+        config.addReleaseVersion( projectId, ALTERNATIVE_NEXT_VERSION );
     }
 
     @Override
-    protected void mapNextVersion( ReleaseDescriptor config, String projectId )
+    protected void mapNextVersion( ReleaseDescriptorBuilder config, String projectId )
     {
-        config.mapReleaseVersion( projectId, NEXT_VERSION );
+        config.addReleaseVersion( projectId, NEXT_VERSION );
     }
 
     @Override
-    protected ReleaseDescriptor createConfigurationForPomWithParentAlternateNextVersion( List<MavenProject> reactorProjects )
+    protected ReleaseDescriptorBuilder createConfigurationForPomWithParentAlternateNextVersion( List<MavenProject> reactorProjects )
         throws Exception
     {
-        ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
+        ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects );
 
-        config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION );
-        config.mapReleaseVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION );
-        return config;
+        builder.addReleaseVersion( "groupId:artifactId", NEXT_VERSION );
+        builder.addReleaseVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION );
+        return builder;
     }
 
     @Override
-    protected ReleaseDescriptor createConfigurationForWithParentNextVersion( List<MavenProject> reactorProjects )
+    protected ReleaseDescriptorBuilder createConfigurationForWithParentNextVersion( List<MavenProject> reactorProjects )
         throws Exception
     {
-        ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
+        ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects );
 
-        config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION );
-        config.mapReleaseVersion( "groupId:subproject1", NEXT_VERSION );
-        return config;
+        builder.addReleaseVersion( "groupId:artifactId", NEXT_VERSION );
+        builder.addReleaseVersion( "groupId:subproject1", NEXT_VERSION );
+        return builder;
     }
 
     @Override
-    protected void unmapNextVersion( ReleaseDescriptor config, String projectId )
+    protected void unmapNextVersion( ReleaseDescriptorBuilder config, String projectId )
     {
         // nothing to do
     }
@@ -211,10 +212,10 @@
     {
 
         List<MavenProject> reactorProjects = createReactorProjects( "basic-pom-with-cvs" );
-        ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
-        mapNextVersion( config, "groupId:artifactId" );
+        ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects );
+        mapNextVersion( builder, "groupId:artifactId" );
 
-        phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         assertTrue( comparePomFiles( reactorProjects ) );
     }
@@ -225,10 +226,10 @@
     {
 
         List<MavenProject> reactorProjects = createReactorProjects( "basic-pom-with-scm-expression" );
-        ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
-        mapNextVersion( config, "groupId:artifactId" );
+        ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects );
+        mapNextVersion( builder, "groupId:artifactId" );
 
-        phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         assertTrue( comparePomFiles( reactorProjects ) );
     }
@@ -239,11 +240,11 @@
     {
 
         List<MavenProject> reactorProjects = createReactorProjects( "basic-pom-with-tag-base" );
-        ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
-        config.setScmBranchBase( "file://localhost/tmp/scm-repo/branches" );
-        mapNextVersion( config, "groupId:artifactId" );
+        ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects );
+        builder.setScmBranchBase( "file://localhost/tmp/scm-repo/branches" );
+        mapNextVersion( builder, "groupId:artifactId" );
 
-        phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         assertTrue( comparePomFiles( reactorProjects ) );
     }
@@ -253,11 +254,11 @@
         throws Exception
     {
         List<MavenProject> reactorProjects = createReactorProjects( "basic-pom-with-tag-base-and-varying-scm-urls" );
-        ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
-        config.setScmBranchBase( "file://localhost/tmp/scm-repo/allprojects/branches" );
-        mapNextVersion( config, "groupId:artifactId" );
+        ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects );
+        builder.setScmBranchBase( "file://localhost/tmp/scm-repo/allprojects/branches" );
+        mapNextVersion( builder, "groupId:artifactId" );
 
-        phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         assertTrue( comparePomFiles( reactorProjects ) );
     }
@@ -267,10 +268,10 @@
         throws Exception
     {
         List<MavenProject> reactorProjects = createReactorProjects( "basic-pom-with-cvs-from-tag" );
-        ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
-        mapNextVersion( config, "groupId:artifactId" );
+        ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects );
+        mapNextVersion( builder, "groupId:artifactId" );
 
-        phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         assertTrue( comparePomFiles( reactorProjects ) );
     }
@@ -280,10 +281,10 @@
         throws Exception
     {
         List<MavenProject> reactorProjects = createReactorProjects( "basic-pom-with-empty-scm" );
-        ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
-        mapNextVersion( config, "groupId:artifactId" );
+        ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects );
+        mapNextVersion( builder, "groupId:artifactId" );
 
-        phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         assertTrue( comparePomFiles( reactorProjects ) );
     }
@@ -293,9 +294,9 @@
         throws Exception
     {
         List<MavenProject> reactorProjects = createReactorProjects( "interpolated-versions" );
-        ReleaseDescriptor config = createMappedConfiguration( reactorProjects );
+        ReleaseDescriptorBuilder builder = createMappedConfiguration( reactorProjects );
 
-        phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         assertTrue( comparePomFiles( reactorProjects ) );
     }
@@ -305,19 +306,17 @@
         throws Exception
     {
         List<MavenProject> reactorProjects = createReactorProjects( "interpolated-versions" );
-        ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
+        ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects );
 
-        config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION );
-        config.mapReleaseVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION );
-        config.mapReleaseVersion( "groupId:subproject2", NEXT_VERSION );
-        config.mapReleaseVersion( "groupId:subproject3", NEXT_VERSION );
+        builder.addReleaseVersion( "groupId:artifactId", NEXT_VERSION );
+        builder.addReleaseVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION );
+        builder.addReleaseVersion( "groupId:subproject2", NEXT_VERSION );
+        builder.addReleaseVersion( "groupId:subproject3", NEXT_VERSION );
 
-        phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
-        for ( Iterator<MavenProject> i = reactorProjects.iterator(); i.hasNext(); )
+        for ( MavenProject project : reactorProjects )
         {
-            MavenProject project = i.next();
-
             // skip subproject1 - we don't need to worry about its version mapping change, it has no deps of any kind
             if ( !"groupId".equals( project.getGroupId() ) || !"subproject1".equals( project.getArtifactId() ) )
             {
@@ -331,10 +330,10 @@
         throws Exception
     {
         List<MavenProject> reactorProjects = createReactorProjects( "basic-pom-inherited-scm" );
-        ReleaseDescriptor config = createConfigurationForWithParentNextVersion( reactorProjects );
-        config.mapReleaseVersion( "groupId:subsubproject", NEXT_VERSION );
+        ReleaseDescriptorBuilder builder = createConfigurationForWithParentNextVersion( reactorProjects );
+        builder.addReleaseVersion( "groupId:subsubproject", NEXT_VERSION );
 
-        phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         assertTrue( comparePomFiles( reactorProjects ) );
     }
@@ -345,12 +344,12 @@
     {
         List<MavenProject> reactorProjects = createReactorProjects( "pom-with-parent-and-properties" );
 
-        ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
-        config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION );
-        config.mapReleaseVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION );
-        config.mapReleaseVersion( "groupId:subproject2", ALTERNATIVE_NEXT_VERSION );
+        ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects );
+        builder.addReleaseVersion( "groupId:artifactId", NEXT_VERSION );
+        builder.addReleaseVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION );
+        builder.addReleaseVersion( "groupId:subproject2", ALTERNATIVE_NEXT_VERSION );
 
-        phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         assertTrue( comparePomFiles( reactorProjects ) );
     }
@@ -362,12 +361,12 @@
     {
         List<MavenProject> reactorProjects = createReactorProjects( "pom-with-property-dependency-coordinate" );
 
-        ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
-        config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION );
-        config.mapReleaseVersion( "groupId:subproject1-3.4", ALTERNATIVE_NEXT_VERSION );
-        config.mapReleaseVersion( "groupId:subproject2", ALTERNATIVE_NEXT_VERSION );
+        ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects );
+        builder.addReleaseVersion( "groupId:artifactId", NEXT_VERSION );
+        builder.addReleaseVersion( "groupId:subproject1-3.4", ALTERNATIVE_NEXT_VERSION );
+        builder.addReleaseVersion( "groupId:subproject2", ALTERNATIVE_NEXT_VERSION );
 
-        phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         assertTrue( comparePomFiles( reactorProjects ) );
     }
@@ -379,11 +378,11 @@
     {
         List<MavenProject> reactorProjects = createReactorProjects( "pom-with-scm-of-parent-ending-with-a-slash" );
 
-        ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
-        config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION );
-        config.mapReleaseVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION );
+        ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects );
+        builder.addReleaseVersion( "groupId:artifactId", NEXT_VERSION );
+        builder.addReleaseVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION );
 
-        phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         assertTrue( comparePomFiles( reactorProjects ) );
     }
@@ -394,12 +393,12 @@
     {
         List<MavenProject> reactorProjects = createReactorProjects( "multimodule-with-deep-subprojects" );
 
-        ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
-        config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION );
-        config.mapReleaseVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION );
-        config.mapReleaseVersion( "groupId:subproject2", ALTERNATIVE_NEXT_VERSION );
+        ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects );
+        builder.addReleaseVersion( "groupId:artifactId", NEXT_VERSION );
+        builder.addReleaseVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION );
+        builder.addReleaseVersion( "groupId:subproject2", ALTERNATIVE_NEXT_VERSION );
 
-        phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         assertTrue( comparePomFiles( reactorProjects ) );
     }
@@ -410,9 +409,9 @@
     {
         List<MavenProject> reactorProjects =
             createReactorProjects( "rewrite-for-branch/pom-with-parent-flat", "root-project" );
-        ReleaseDescriptor config = createConfigurationForPomWithParentAlternateNextVersion( reactorProjects );
+        ReleaseDescriptorBuilder builder = createConfigurationForPomWithParentAlternateNextVersion( reactorProjects );
 
-        phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         assertTrue( comparePomFiles( reactorProjects ) );
     }
@@ -423,23 +422,23 @@
         throws Exception
     {
         List<MavenProject> reactorProjects = createReactorProjects( "cdata-section" );
-        ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
-        mapNextVersion( config, "groupId:artifactId" );
+        ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects );
+        mapNextVersion( builder, "groupId:artifactId" );
 
         AbstractRewritePomsPhase phase = (AbstractRewritePomsPhase) this.phase;
         phase.setLs( "\r\n" );
-        phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // compare POMS without line ending normalization
         assertTrue( comparePomFiles( reactorProjects, false ) );
     }
 
     @Override
-    protected ReleaseDescriptor createDescriptorFromProjects( List<MavenProject> reactorProjects )
+    protected ReleaseDescriptorBuilder createDescriptorFromProjects( List<MavenProject> reactorProjects )
     {
-        ReleaseDescriptor descriptor = super.createDescriptorFromProjects( reactorProjects );
-        descriptor.setScmReleaseLabel( "release-label" );
-        return descriptor;
+        ReleaseDescriptorBuilder builder = super.createDescriptorFromProjects( reactorProjects );
+        builder.setScmReleaseLabel( "release-label" );
+        return builder;
     }
 
     // MRELEASE-454
@@ -448,9 +447,9 @@
         throws Exception
     {
         List<MavenProject> reactorProjects = createReactorProjects( "imported-dependency-management-in-reactor" );
-        ReleaseDescriptor config = createMappedConfiguration( reactorProjects );
+        ReleaseDescriptorBuilder builder = createMappedConfiguration( reactorProjects );
 
-        phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         assertTrue( comparePomFiles( reactorProjects ) );
     }
@@ -460,10 +459,10 @@
         throws Exception
     {
         List<MavenProject> reactorProjects = createReactorProjects( "modules-with-different-versions" );
-        ReleaseDescriptor config = createMappedConfiguration( reactorProjects );
-        config.mapReleaseVersion( "groupId:subproject2", ALTERNATIVE_NEXT_VERSION );
+        ReleaseDescriptorBuilder builder = createMappedConfiguration( reactorProjects );
+        builder.addReleaseVersion( "groupId:subproject2", ALTERNATIVE_NEXT_VERSION );
 
-        phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         assertTrue( comparePomFiles( reactorProjects ) );
     }
diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RewritePomsForDevelopmentPhaseTest.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RewritePomsForDevelopmentPhaseTest.java
index af94c55..cea16c5 100644
--- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RewritePomsForDevelopmentPhaseTest.java
+++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RewritePomsForDevelopmentPhaseTest.java
@@ -26,7 +26,6 @@
 
 import java.io.File;
 import java.io.IOException;
-import java.util.Iterator;
 import java.util.LinkedList;
 import java.util.List;
 
@@ -34,7 +33,8 @@
 import org.apache.maven.model.Scm;
 import org.apache.maven.project.MavenProject;
 import org.apache.maven.shared.release.ReleaseExecutionException;
-import org.apache.maven.shared.release.config.ReleaseDescriptor;
+import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder;
+import org.apache.maven.shared.release.config.ReleaseUtils;
 import org.apache.maven.shared.release.env.DefaultReleaseEnvironment;
 import org.apache.maven.shared.release.util.ReleaseUtil;
 import org.junit.Test;
@@ -71,13 +71,13 @@
         throws Exception
     {
         List<MavenProject> reactorProjects = createReactorProjectsWhenSimulated( "basic-pom" );
-        ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects );
-        config.mapReleaseVersion( "groupId:artifactId", RELEASE_VERSION );
-        config.mapDevelopmentVersion( "groupId:artifactId", NEXT_VERSION );
+        ReleaseDescriptorBuilder builder = createDescriptorFromBasicPom( reactorProjects );
+        builder.addReleaseVersion( "groupId:artifactId", RELEASE_VERSION );
+        builder.addDevelopmentVersion( "groupId:artifactId", NEXT_VERSION );
 
         String expected = readTestProjectFile( "basic-pom/pom.xml" );
 
-        phase.simulate( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         String actual = readTestProjectFile( "basic-pom/pom.xml" );
         assertEquals( "Check the original POM untouched", expected, actual );
@@ -100,15 +100,15 @@
         List<MavenProject> reactorProjects =
             new LinkedList<>( createReactorProjects( "basic-pom-ejb-client-dep/project" ) );
         reactorProjects.addAll( createReactorProjects( "basic-pom-ejb-client-dep/ejb" ) );
-        ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects );
-        config.mapReleaseVersion( "groupId:artifactId", RELEASE_VERSION );
-        config.mapDevelopmentVersion( "groupId:artifactId", NEXT_VERSION );
-        config.addDevelopmentVersion( ArtifactUtils.versionlessKey( "groupId", "artifactId1" ), NEXT_VERSION );
-        config.addReleaseVersion( ArtifactUtils.versionlessKey( "groupId", "artifactId1" ), RELEASE_VERSION );
+        ReleaseDescriptorBuilder builder = createDescriptorFromBasicPom( reactorProjects );
+        builder.addReleaseVersion( "groupId:artifactId", RELEASE_VERSION );
+        builder.addDevelopmentVersion( "groupId:artifactId", NEXT_VERSION );
+        builder.addDevelopmentVersion( ArtifactUtils.versionlessKey( "groupId", "artifactId1" ), NEXT_VERSION );
+        builder.addReleaseVersion( ArtifactUtils.versionlessKey( "groupId", "artifactId1" ), RELEASE_VERSION );
 
         String expected = readTestProjectFile( "basic-pom-ejb-client-dep/project/pom.xml" );
 
-        phase.simulate( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         String actual = readTestProjectFile( "basic-pom-ejb-client-dep/project/pom.xml" );
         assertEquals( "Check the original POM untouched", expected, actual );
@@ -123,15 +123,15 @@
         throws Exception
     {
         List<MavenProject> reactorProjects = createReactorProjectsWhenSimulated( "basic-pom" );
-        ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects );
-        config.mapReleaseVersion( "groupId:artifactId", RELEASE_VERSION );
-        config.mapDevelopmentVersion( "groupId:artifactId", NEXT_VERSION );
+        ReleaseDescriptorBuilder builder = createDescriptorFromBasicPom( reactorProjects );
+        builder.addReleaseVersion( "groupId:artifactId", RELEASE_VERSION );
+        builder.addDevelopmentVersion( "groupId:artifactId", NEXT_VERSION );
 
         File testFile = getTestFile( "target/test-classes/projects/rewrite-for-development/basic-pom/pom.xml.next" );
         testFile.delete();
         assertFalse( testFile.exists() );
 
-        phase.simulate( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         assertTrue( testFile.exists() );
 
@@ -145,9 +145,6 @@
         throws Exception
     {
         List<MavenProject> reactorProjects = createReactorProjectsFromBasicPom();
-        ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects );
-        config.mapReleaseVersion( "groupId:artifactId", RELEASE_VERSION );
-        config.mapDevelopmentVersion( "groupId:artifactId", NEXT_VERSION );
 
         File testFile = getTestFile( "target/test-classes/projects/rewrite-for-development/basic-pom/pom.xml.next" );
         testFile.delete();
@@ -164,13 +161,19 @@
     {
         List<MavenProject> reactorProjects = prepareReactorProjects( "basic-pom", true );
 
-        ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder() {
+            public ReleaseDescriptorBuilder addOriginalScmInfo(String key, Scm value) {
+                // do nothing
+                return this;
+            };
+        }; 
+        builder = createDescriptorFromProjects( builder, reactorProjects );
 
-        mapNextVersion( config, "groupId:artifactId" );
+        mapNextVersion( builder, "groupId:artifactId" );
 
         try
         {
-            phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "Expected failure" );
         }
@@ -202,73 +205,73 @@
     }
 
     @Override
-    protected ReleaseDescriptor createDescriptorFromBasicPom( List<MavenProject> reactorProjects )
+    protected ReleaseDescriptorBuilder createDescriptorFromBasicPom( List<MavenProject> reactorProjects )
         throws Exception
     {
-        ReleaseDescriptor config = super.createDescriptorFromBasicPom( reactorProjects );
+        ReleaseDescriptorBuilder builder = super.createDescriptorFromBasicPom( reactorProjects );
 
-        mapScm( config );
+        mapScm( builder );
 
-        return config;
+        return builder;
     }
 
-    private void mapScm( ReleaseDescriptor config )
+    private void mapScm( ReleaseDescriptorBuilder builder )
     {
         Scm scm = new Scm();
         scm.setConnection( "scm:svn:file://localhost/tmp/scm-repo/trunk" );
         scm.setDeveloperConnection( "scm:svn:file://localhost/tmp/scm-repo/trunk" );
         scm.setUrl( "file://localhost/tmp/scm-repo/trunk" );
-        config.mapOriginalScmInfo( "groupId:artifactId", scm );
+        builder.addOriginalScmInfo( "groupId:artifactId", scm );
     }
 
     @Override
-    protected void mapAlternateNextVersion( ReleaseDescriptor config, String projectId )
+    protected void mapAlternateNextVersion( ReleaseDescriptorBuilder config, String projectId )
     {
-        config.mapReleaseVersion( projectId, ALTERNATIVE_RELEASE_VERSION );
-        config.mapDevelopmentVersion( projectId, ALTERNATIVE_NEXT_VERSION );
+        config.addReleaseVersion( projectId, ALTERNATIVE_RELEASE_VERSION );
+        config.addDevelopmentVersion( projectId, ALTERNATIVE_NEXT_VERSION );
     }
 
     @Override
-    protected void mapNextVersion( ReleaseDescriptor config, String projectId )
+    protected void mapNextVersion( ReleaseDescriptorBuilder config, String projectId )
     {
-        config.mapReleaseVersion( projectId, RELEASE_VERSION );
-        config.mapDevelopmentVersion( projectId, NEXT_VERSION );
+        config.addReleaseVersion( projectId, RELEASE_VERSION );
+        config.addDevelopmentVersion( projectId, NEXT_VERSION );
     }
 
     @Override
-    protected void unmapNextVersion( ReleaseDescriptor config, String projectId )
+    protected void unmapNextVersion( ReleaseDescriptorBuilder builder, String projectId )
     {
-        config.mapReleaseVersion( projectId, RELEASE_VERSION );
+        builder.addReleaseVersion( projectId, RELEASE_VERSION );
     }
 
     @Override
-    protected ReleaseDescriptor createConfigurationForPomWithParentAlternateNextVersion( List<MavenProject> reactorProjects )
+    protected ReleaseDescriptorBuilder createConfigurationForPomWithParentAlternateNextVersion( List<MavenProject> reactorProjects )
         throws Exception
     {
-        ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
+        ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects );
 
-        config.mapReleaseVersion( "groupId:artifactId", RELEASE_VERSION );
-        config.mapDevelopmentVersion( "groupId:artifactId", NEXT_VERSION );
-        config.mapReleaseVersion( "groupId:subproject1", ALTERNATIVE_RELEASE_VERSION );
-        config.mapDevelopmentVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION );
-        mapScm( config );
+        builder.addReleaseVersion( "groupId:artifactId", RELEASE_VERSION );
+        builder.addDevelopmentVersion( "groupId:artifactId", NEXT_VERSION );
+        builder.addReleaseVersion( "groupId:subproject1", ALTERNATIVE_RELEASE_VERSION );
+        builder.addDevelopmentVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION );
+        mapScm( builder );
 
-        return config;
+        return builder;
     }
 
     @Override
-    protected ReleaseDescriptor createConfigurationForWithParentNextVersion( List<MavenProject> reactorProjects )
+    protected ReleaseDescriptorBuilder createConfigurationForWithParentNextVersion( List<MavenProject> reactorProjects )
         throws Exception
     {
-        ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
+        ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects );
 
-        config.mapReleaseVersion( "groupId:artifactId", RELEASE_VERSION );
-        config.mapDevelopmentVersion( "groupId:artifactId", NEXT_VERSION );
-        config.mapReleaseVersion( "groupId:subproject1", RELEASE_VERSION );
-        config.mapDevelopmentVersion( "groupId:subproject1", NEXT_VERSION );
-        mapScm( config );
+        builder.addReleaseVersion( "groupId:artifactId", RELEASE_VERSION );
+        builder.addDevelopmentVersion( "groupId:artifactId", NEXT_VERSION );
+        builder.addReleaseVersion( "groupId:subproject1", RELEASE_VERSION );
+        builder.addDevelopmentVersion( "groupId:subproject1", NEXT_VERSION );
+        mapScm( builder );
 
-        return config;
+        return builder;
     }
 
     @Test
@@ -277,16 +280,16 @@
     {
 
         List<MavenProject> reactorProjects = createReactorProjects( "basic-pom-with-cvs" );
-        ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
-        mapNextVersion( config, "groupId:artifactId" );
+        ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects );
+        mapNextVersion( builder, "groupId:artifactId" );
 
         Scm scm = new Scm();
         scm.setConnection( "${scm.base}:pserver:anoncvs@localhost:/tmp/scm-repo:module" );
         scm.setDeveloperConnection( "${scm.base}:ext:${username}@localhost:/tmp/scm-repo:module" );
         scm.setUrl( "${baseUrl}/module" );
-        config.mapOriginalScmInfo( "groupId:artifactId", scm );
+        builder.addOriginalScmInfo( "groupId:artifactId", scm );
 
-        phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         assertTrue( comparePomFiles( reactorProjects ) );
     }
@@ -297,17 +300,17 @@
     {
 
         List<MavenProject> reactorProjects = createReactorProjects( "basic-pom-with-cvs-from-tag" );
-        ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
-        mapNextVersion( config, "groupId:artifactId" );
+        ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects );
+        mapNextVersion( builder, "groupId:artifactId" );
 
         Scm scm = new Scm();
         scm.setConnection( "scm:cvs:pserver:anoncvs@localhost:/tmp/scm-repo:module" );
         scm.setDeveloperConnection( "scm:cvs:ext:${username}@localhost:/tmp/scm-repo:module" );
         scm.setUrl( "http://localhost/viewcvs.cgi/module" );
         scm.setTag( "original-label" );
-        config.mapOriginalScmInfo( "groupId:artifactId", scm );
+        builder.addOriginalScmInfo( "groupId:artifactId", scm );
 
-        phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         assertTrue( comparePomFiles( reactorProjects ) );
     }
@@ -318,24 +321,23 @@
     {
 
         List<MavenProject> reactorProjects = createReactorProjects( "basic-pom-inherited-scm" );
-        ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
+        ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects );
 
-        config.mapReleaseVersion( "groupId:artifactId", RELEASE_VERSION );
-        config.mapDevelopmentVersion( "groupId:artifactId", NEXT_VERSION );
-        config.mapReleaseVersion( "groupId:subproject1", RELEASE_VERSION );
-        config.mapDevelopmentVersion( "groupId:subproject1", NEXT_VERSION );
-        config.mapReleaseVersion( "groupId:subsubproject", RELEASE_VERSION );
-        config.mapDevelopmentVersion( "groupId:subsubproject", NEXT_VERSION );
-        config.mapOriginalScmInfo( "groupId:artifactId", null );
+        builder.addReleaseVersion( "groupId:artifactId", RELEASE_VERSION );
+        builder.addDevelopmentVersion( "groupId:artifactId", NEXT_VERSION );
+        builder.addReleaseVersion( "groupId:subproject1", RELEASE_VERSION );
+        builder.addDevelopmentVersion( "groupId:subproject1", NEXT_VERSION );
+        builder.addReleaseVersion( "groupId:subsubproject", RELEASE_VERSION );
+        builder.addDevelopmentVersion( "groupId:subsubproject", NEXT_VERSION );
         Scm scm = new Scm();
         scm.setConnection( "scm:svn:file://localhost/tmp/scm-repo/trunk/subproject1" );
         scm.setDeveloperConnection( "scm:svn:file://localhost/tmp/scm-repo/trunk/subproject1" );
         // MRELEASE-107
         scm.setUrl( "http://localhost/viewvc/mypath/trunk/subproject1" );
-        config.mapOriginalScmInfo( "groupId:subproject1", scm );
-        config.mapOriginalScmInfo( "groupId:subsubproject", null );
+        builder.addOriginalScmInfo( "groupId:subproject1", scm );
+        builder.addOriginalScmInfo( "groupId:subsubproject", null );
 
-        phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         assertTrue( comparePomFiles( reactorProjects ) );
     }
@@ -368,17 +370,17 @@
     {
         List<MavenProject> reactorProjects = createReactorProjects( path );
 
-        ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
-        config.mapReleaseVersion( "groupId:artifactId", RELEASE_VERSION );
-        config.mapDevelopmentVersion( "groupId:artifactId", NEXT_VERSION );
-        config.mapReleaseVersion( "groupId:subproject1", ALTERNATIVE_RELEASE_VERSION );
-        config.mapDevelopmentVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION );
-        config.mapReleaseVersion( "groupId:subproject2", ALTERNATIVE_RELEASE_VERSION );
-        config.mapDevelopmentVersion( "groupId:subproject2", ALTERNATIVE_NEXT_VERSION );
+        ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects );
+        builder.addReleaseVersion( "groupId:artifactId", RELEASE_VERSION );
+        builder.addDevelopmentVersion( "groupId:artifactId", NEXT_VERSION );
+        builder.addReleaseVersion( "groupId:subproject1", ALTERNATIVE_RELEASE_VERSION );
+        builder.addDevelopmentVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION );
+        builder.addReleaseVersion( "groupId:subproject2", ALTERNATIVE_RELEASE_VERSION );
+        builder.addDevelopmentVersion( "groupId:subproject2", ALTERNATIVE_NEXT_VERSION );
 
-        mapScm( config );
+        mapScm( builder );
 
-        phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         assertTrue( comparePomFiles( reactorProjects ) );
     }
@@ -390,22 +392,20 @@
         // use the original ones since simulation didn't modify them
         List<MavenProject> reactorProjects = createReactorProjects( "pom-with-parent-and-properties-sim" );
 
-        ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
-        config.mapReleaseVersion( "groupId:artifactId", RELEASE_VERSION );
-        config.mapDevelopmentVersion( "groupId:artifactId", NEXT_VERSION );
-        config.mapReleaseVersion( "groupId:subproject1", ALTERNATIVE_RELEASE_VERSION );
-        config.mapDevelopmentVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION );
-        config.mapReleaseVersion( "groupId:subproject2", ALTERNATIVE_RELEASE_VERSION );
-        config.mapDevelopmentVersion( "groupId:subproject2", ALTERNATIVE_NEXT_VERSION );
+        ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects );
+        builder.addReleaseVersion( "groupId:artifactId", RELEASE_VERSION );
+        builder.addDevelopmentVersion( "groupId:artifactId", NEXT_VERSION );
+        builder.addReleaseVersion( "groupId:subproject1", ALTERNATIVE_RELEASE_VERSION );
+        builder.addDevelopmentVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION );
+        builder.addReleaseVersion( "groupId:subproject2", ALTERNATIVE_RELEASE_VERSION );
+        builder.addDevelopmentVersion( "groupId:subproject2", ALTERNATIVE_NEXT_VERSION );
 
-        mapScm( config );
+        mapScm( builder );
 
-        phase.simulate( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
-        for ( Iterator<MavenProject> i = reactorProjects.iterator(); i.hasNext(); )
+        for ( MavenProject project : reactorProjects )
         {
-            MavenProject project = i.next();
-
             File pomFile = project.getFile();
             File actualFile = new File( pomFile.getParentFile(), pomFile.getName() + ".next" );
             File expectedFile = new File( actualFile.getParentFile(), "expected-pom.xml" );
@@ -421,17 +421,17 @@
     {
         List<MavenProject> reactorProjects = createReactorProjects( "pom-with-property-dependency-coordinate" );
 
-        ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
-        config.mapReleaseVersion( "groupId:artifactId", RELEASE_VERSION );
-        config.mapDevelopmentVersion( "groupId:artifactId", NEXT_VERSION );
-        config.mapReleaseVersion( "groupId:subproject1-3.4", ALTERNATIVE_RELEASE_VERSION );
-        config.mapDevelopmentVersion( "groupId:subproject1-3.4", ALTERNATIVE_NEXT_VERSION );
-        config.mapReleaseVersion( "groupId:subproject2", ALTERNATIVE_RELEASE_VERSION );
-        config.mapDevelopmentVersion( "groupId:subproject2", ALTERNATIVE_NEXT_VERSION );
+        ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects );
+        builder.addReleaseVersion( "groupId:artifactId", RELEASE_VERSION );
+        builder.addDevelopmentVersion( "groupId:artifactId", NEXT_VERSION );
+        builder.addReleaseVersion( "groupId:subproject1-3.4", ALTERNATIVE_RELEASE_VERSION );
+        builder.addDevelopmentVersion( "groupId:subproject1-3.4", ALTERNATIVE_NEXT_VERSION );
+        builder.addReleaseVersion( "groupId:subproject2", ALTERNATIVE_RELEASE_VERSION );
+        builder.addDevelopmentVersion( "groupId:subproject2", ALTERNATIVE_NEXT_VERSION );
 
-        mapScm( config );
+        mapScm( builder );
 
-        phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         assertTrue( comparePomFiles( reactorProjects ) );
     }
@@ -442,11 +442,11 @@
     {
         List<MavenProject> reactorProjects =
             createReactorProjects( "internal-snapshot-dependencies-without-dependencies-version-update" );
-        ReleaseDescriptor config = createDefaultConfiguration( reactorProjects );
-        config.setUpdateDependencies( false );
-        mapNextVersion( config, "groupId:subsubproject" );
+        ReleaseDescriptorBuilder builder = createDefaultConfiguration( reactorProjects );
+        builder.setUpdateDependencies( false );
+        mapNextVersion( builder, "groupId:subsubproject" );
 
-        phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         assertTrue( comparePomFiles( reactorProjects ) );
     }
diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RewritePomsForReleasePhaseTest.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RewritePomsForReleasePhaseTest.java
index a89ef57..d81b7a5 100644
--- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RewritePomsForReleasePhaseTest.java
+++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RewritePomsForReleasePhaseTest.java
@@ -30,7 +30,9 @@
 import java.util.Objects;
 
 import org.apache.maven.project.MavenProject;
-import org.apache.maven.shared.release.config.ReleaseDescriptor;
+import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder;
+import org.apache.maven.shared.release.config.ReleaseStageVersions;
+import org.apache.maven.shared.release.config.ReleaseUtils;
 import org.apache.maven.shared.release.env.DefaultReleaseEnvironment;
 import org.apache.maven.shared.release.util.ReleaseUtil;
 import org.junit.Test;
@@ -78,12 +80,12 @@
         throws Exception
     {
         List<MavenProject> reactorProjects = createReactorProjectsFromBasicPom();
-        ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects );
-        config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION );
+        ReleaseDescriptorBuilder builder = createDescriptorFromBasicPom( reactorProjects );
+        builder.addReleaseVersion( "groupId:artifactId", NEXT_VERSION );
 
         String expected = readTestProjectFile( "basic-pom/pom.xml" );
 
-        phase.simulate( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         String actual = readTestProjectFile( "basic-pom/pom.xml" );
         assertEquals( "Check the original POM untouched", expected, actual );
@@ -98,12 +100,12 @@
         throws Exception
     {
         List<MavenProject> reactorProjects = createReactorProjects( "basic-pom-with-dashes-in-comment" );
-        ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects );
-        config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION );
+        ReleaseDescriptorBuilder builder = createDescriptorFromBasicPom( reactorProjects );
+        builder.addReleaseVersion( "groupId:artifactId", NEXT_VERSION );
 
         String expected = readTestProjectFile( "basic-pom-with-dashes-in-comment/pom.xml" );
 
-        phase.simulate( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         String actual = readTestProjectFile( "basic-pom-with-dashes-in-comment/pom.xml" );
         assertEquals( "Check the original POM is untouched", expected, actual );
@@ -118,14 +120,14 @@
         throws Exception
     {
         List<MavenProject> reactorProjects = createReactorProjectsFromBasicPom();
-        ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects );
-        config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION );
+        ReleaseDescriptorBuilder builder = createDescriptorFromBasicPom( reactorProjects );
+        builder.addReleaseVersion( "groupId:artifactId", NEXT_VERSION );
 
         File testFile = getTestFile( "target/test-classes/projects/rewrite-for-release/basic-pom/pom.xml.tag" );
         testFile.delete();
         assertFalse( testFile.exists() );
 
-        phase.simulate( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         assertTrue( testFile.exists() );
 
@@ -139,8 +141,6 @@
         throws Exception
     {
         List<MavenProject> reactorProjects = createReactorProjectsFromBasicPom();
-        ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects );
-        config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION );
 
         File testFile = getTestFile( "target/test-classes/projects/rewrite-for-release/basic-pom/pom.xml.tag" );
         testFile.delete();
@@ -157,50 +157,50 @@
         throws Exception
     {
         List<MavenProject> reactorProjects = createReactorProjects( "pom-with-overridden-scm" );
-        ReleaseDescriptor config = createConfigurationForWithParentNextVersion( reactorProjects );
-        config.mapReleaseVersion( "groupId:subsubproject", NEXT_VERSION );
+        ReleaseDescriptorBuilder builder = createConfigurationForWithParentNextVersion( reactorProjects );
+        builder.addReleaseVersion( "groupId:subsubproject", NEXT_VERSION );
 
-        phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         assertTrue( comparePomFiles( reactorProjects ) );
     }
 
     @Override
-    protected void mapAlternateNextVersion( ReleaseDescriptor config, String projectId )
+    protected void mapAlternateNextVersion( ReleaseDescriptorBuilder config, String projectId )
     {
-        config.mapReleaseVersion( projectId, ALTERNATIVE_NEXT_VERSION );
+        config.addReleaseVersion( projectId, ALTERNATIVE_NEXT_VERSION );
     }
 
     @Override
-    protected void mapNextVersion( ReleaseDescriptor config, String projectId )
+    protected void mapNextVersion( ReleaseDescriptorBuilder config, String projectId )
     {
-        config.mapReleaseVersion( projectId, NEXT_VERSION );
+        config.addReleaseVersion( projectId, NEXT_VERSION );
     }
 
     @Override
-    protected ReleaseDescriptor createConfigurationForPomWithParentAlternateNextVersion( List<MavenProject> reactorProjects )
+    protected ReleaseDescriptorBuilder createConfigurationForPomWithParentAlternateNextVersion( List<MavenProject> reactorProjects )
         throws Exception
     {
-        ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
+        ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects );
 
-        config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION );
-        config.mapReleaseVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION );
-        return config;
+        builder.addReleaseVersion( "groupId:artifactId", NEXT_VERSION );
+        builder.addReleaseVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION );
+        return builder;
     }
 
     @Override
-    protected ReleaseDescriptor createConfigurationForWithParentNextVersion( List<MavenProject> reactorProjects )
+    protected ReleaseDescriptorBuilder createConfigurationForWithParentNextVersion( List<MavenProject> reactorProjects )
         throws Exception
     {
-        ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
+        ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects );
 
-        config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION );
-        config.mapReleaseVersion( "groupId:subproject1", NEXT_VERSION );
-        return config;
+        builder.addReleaseVersion( "groupId:artifactId", NEXT_VERSION );
+        builder.addReleaseVersion( "groupId:subproject1", NEXT_VERSION );
+        return builder;
     }
 
     @Override
-    protected void unmapNextVersion( ReleaseDescriptor config, String projectId )
+    protected void unmapNextVersion( ReleaseDescriptorBuilder config, String projectId )
     {
         // nothing to do
     }
@@ -211,10 +211,10 @@
     {
 
         List<MavenProject> reactorProjects = createReactorProjects( "basic-pom-with-cvs" );
-        ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
-        mapNextVersion( config, "groupId:artifactId" );
+        ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects );
+        mapNextVersion( builder, "groupId:artifactId" );
 
-        phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         assertTrue( comparePomFiles( reactorProjects ) );
     }
@@ -225,10 +225,10 @@
     {
 
         List<MavenProject> reactorProjects = createReactorProjects( "basic-pom-with-scm-expression" );
-        ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
-        mapNextVersion( config, "groupId:artifactId" );
+        ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects );
+        mapNextVersion( builder, "groupId:artifactId" );
 
-        phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         assertTrue( comparePomFiles( reactorProjects ) );
     }
@@ -239,11 +239,11 @@
     {
 
         List<MavenProject> reactorProjects = createReactorProjects( "basic-pom-with-tag-base" );
-        ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
-        config.setScmTagBase( "file://localhost/tmp/scm-repo/releases" );
-        mapNextVersion( config, "groupId:artifactId" );
+        ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects );
+        builder.setScmTagBase( "file://localhost/tmp/scm-repo/releases" );
+        mapNextVersion( builder, "groupId:artifactId" );
 
-        phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         assertTrue( comparePomFiles( reactorProjects ) );
     }
@@ -253,11 +253,11 @@
         throws Exception
     {
         List<MavenProject> reactorProjects = createReactorProjects( "basic-pom-with-tag-base-and-varying-scm-urls" );
-        ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
-        config.setScmTagBase( "file://localhost/tmp/scm-repo/allprojects/releases" );
-        mapNextVersion( config, "groupId:artifactId" );
+        ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects );
+        builder.setScmTagBase( "file://localhost/tmp/scm-repo/allprojects/releases" );
+        mapNextVersion( builder, "groupId:artifactId" );
 
-        phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         assertTrue( comparePomFiles( reactorProjects ) );
     }
@@ -267,10 +267,10 @@
         throws Exception
     {
         List<MavenProject> reactorProjects = createReactorProjects( "basic-pom-with-cvs-from-tag" );
-        ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
-        mapNextVersion( config, "groupId:artifactId" );
+        ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects );
+        mapNextVersion( builder, "groupId:artifactId" );
 
-        phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         assertTrue( comparePomFiles( reactorProjects ) );
     }
@@ -280,10 +280,10 @@
         throws Exception
     {
         List<MavenProject> reactorProjects = createReactorProjects( "basic-pom-with-empty-scm" );
-        ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
-        mapNextVersion( config, "groupId:artifactId" );
+        ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects );
+        mapNextVersion( builder, "groupId:artifactId" );
 
-        phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         assertTrue( comparePomFiles( reactorProjects ) );
     }
@@ -293,9 +293,9 @@
         throws Exception
     {
         List<MavenProject> reactorProjects = createReactorProjects( "interpolated-versions" );
-        ReleaseDescriptor config = createMappedConfiguration( reactorProjects );
+        ReleaseDescriptorBuilder builder = createMappedConfiguration( reactorProjects );
 
-        phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         assertTrue( comparePomFiles( reactorProjects ) );
     }
@@ -305,14 +305,14 @@
         throws Exception
     {
         List<MavenProject> reactorProjects = createReactorProjects( "interpolated-versions" );
-        ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
+        ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects );
 
-        config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION );
-        config.mapReleaseVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION );
-        config.mapReleaseVersion( "groupId:subproject2", NEXT_VERSION );
-        config.mapReleaseVersion( "groupId:subproject3", NEXT_VERSION );
+        builder.addReleaseVersion( "groupId:artifactId", NEXT_VERSION );
+        builder.addReleaseVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION );
+        builder.addReleaseVersion( "groupId:subproject2", NEXT_VERSION );
+        builder.addReleaseVersion( "groupId:subproject3", NEXT_VERSION );
 
-        phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         for ( Iterator<MavenProject> i = reactorProjects.iterator(); i.hasNext(); )
         {
@@ -331,10 +331,10 @@
         throws Exception
     {
         List<MavenProject> reactorProjects = createReactorProjects( "basic-pom-inherited-scm" );
-        ReleaseDescriptor config = createConfigurationForWithParentNextVersion( reactorProjects );
-        config.mapReleaseVersion( "groupId:subsubproject", NEXT_VERSION );
+        ReleaseDescriptorBuilder builder = createConfigurationForWithParentNextVersion( reactorProjects );
+        builder.addReleaseVersion( "groupId:subsubproject", NEXT_VERSION );
 
-        phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         assertTrue( comparePomFiles( reactorProjects ) );
     }
@@ -345,12 +345,12 @@
     {
         List<MavenProject> reactorProjects = createReactorProjects( "pom-with-parent-and-properties" );
 
-        ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
-        config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION );
-        config.mapReleaseVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION );
-        config.mapReleaseVersion( "groupId:subproject2", ALTERNATIVE_NEXT_VERSION );
+        ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects );
+        builder.addReleaseVersion( "groupId:artifactId", NEXT_VERSION );
+        builder.addReleaseVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION );
+        builder.addReleaseVersion( "groupId:subproject2", ALTERNATIVE_NEXT_VERSION );
 
-        phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         assertTrue( comparePomFiles( reactorProjects ) );
     }
@@ -362,12 +362,12 @@
     {
         List<MavenProject> reactorProjects = createReactorProjects( "pom-with-property-dependency-coordinate" );
 
-        ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
-        config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION );
-        config.mapReleaseVersion( "groupId:subproject1-3.4", ALTERNATIVE_NEXT_VERSION );
-        config.mapReleaseVersion( "groupId:subproject2", ALTERNATIVE_NEXT_VERSION );
+        ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects );
+        builder.addReleaseVersion( "groupId:artifactId", NEXT_VERSION );
+        builder.addReleaseVersion( "groupId:subproject1-3.4", ALTERNATIVE_NEXT_VERSION );
+        builder.addReleaseVersion( "groupId:subproject2", ALTERNATIVE_NEXT_VERSION );
 
-        phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         assertTrue( comparePomFiles( reactorProjects ) );
     }
@@ -379,11 +379,11 @@
     {
         List<MavenProject> reactorProjects = createReactorProjects( "pom-with-scm-of-parent-ending-with-a-slash" );
 
-        ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
-        config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION );
-        config.mapReleaseVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION );
+        ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects );
+        builder.addReleaseVersion( "groupId:artifactId", NEXT_VERSION );
+        builder.addReleaseVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION );
 
-        phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         assertTrue( comparePomFiles( reactorProjects ) );
     }
@@ -394,12 +394,12 @@
     {
         List<MavenProject> reactorProjects = createReactorProjects( "multimodule-with-deep-subprojects" );
 
-        ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
-        config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION );
-        config.mapReleaseVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION );
-        config.mapReleaseVersion( "groupId:subproject2", ALTERNATIVE_NEXT_VERSION );
+        ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects );
+        builder.addReleaseVersion( "groupId:artifactId", NEXT_VERSION );
+        builder.addReleaseVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION );
+        builder.addReleaseVersion( "groupId:subproject2", ALTERNATIVE_NEXT_VERSION );
 
-        phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         assertTrue( comparePomFiles( reactorProjects ) );
     }
@@ -410,9 +410,9 @@
     {
         List<MavenProject> reactorProjects =
             createReactorProjects( "rewrite-for-release/pom-with-parent-flat", "root-project" );
-        ReleaseDescriptor config = createConfigurationForPomWithParentAlternateNextVersion( reactorProjects );
+        ReleaseDescriptorBuilder builder = createConfigurationForPomWithParentAlternateNextVersion( reactorProjects );
 
-        phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         assertTrue( comparePomFiles( reactorProjects ) );
     }
@@ -423,23 +423,23 @@
         throws Exception
     {
         List<MavenProject> reactorProjects = createReactorProjects( "cdata-section" );
-        ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
-        mapNextVersion( config, "groupId:artifactId" );
+        ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects );
+        mapNextVersion( builder, "groupId:artifactId" );
 
         RewritePomsForReleasePhase phase = (RewritePomsForReleasePhase) this.phase;
         phase.setLs( "\r\n" );
-        phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // compare POMS without line ending normalization
         assertTrue( comparePomFiles( reactorProjects, false ) );
     }
 
     @Override
-    protected ReleaseDescriptor createDescriptorFromProjects( List<MavenProject> reactorProjects )
+    protected ReleaseDescriptorBuilder createDescriptorFromProjects( List<MavenProject> reactorProjects )
     {
-        ReleaseDescriptor descriptor = super.createDescriptorFromProjects( reactorProjects );
-        descriptor.setScmReleaseLabel( "release-label" );
-        return descriptor;
+        ReleaseDescriptorBuilder builder = super.createDescriptorFromProjects( reactorProjects );
+        builder.setScmReleaseLabel( "release-label" );
+        return builder;
     }
 
     @Test
@@ -448,11 +448,12 @@
     {
         List<MavenProject> reactorProjects = createReactorProjects( "pom-with-externally-released-parent" );
 
-        ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
-        config.mapResolvedSnapshotDependencies( "external:parent-artifactId", "1", "2-SNAPSHOT" );
-        config.mapReleaseVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION );
+        ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects );
+        builder.addDependencyReleaseVersion( "external:parent-artifactId", "1" );
+        builder.addDependencyDevelopmentVersion( "external:parent-artifactId", "2-SNAPSHOT" );
+        builder.addReleaseVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION );
 
-        phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         assertTrue( comparePomFiles( reactorProjects ) );
     }
@@ -463,9 +464,9 @@
         throws Exception
     {
         List<MavenProject> reactorProjects = createReactorProjects( "imported-dependency-management-in-reactor" );
-        ReleaseDescriptor config = createMappedConfiguration( reactorProjects );
+        ReleaseDescriptorBuilder builder = createMappedConfiguration( reactorProjects );
 
-        phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         assertTrue( comparePomFiles( reactorProjects ) );
     }
@@ -475,10 +476,10 @@
         throws Exception
     {
         List<MavenProject> reactorProjects = createReactorProjects( "modules-with-different-versions" );
-        ReleaseDescriptor config = createMappedConfiguration( reactorProjects );
-        config.mapReleaseVersion( "groupId:subproject2", ALTERNATIVE_NEXT_VERSION );
+        ReleaseDescriptorBuilder builder = createMappedConfiguration( reactorProjects );
+        builder.addReleaseVersion( "groupId:subproject2", ALTERNATIVE_NEXT_VERSION );
 
-        phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         assertTrue( comparePomFiles( reactorProjects ) );
     }
diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RunCompleteGoalsPhaseTest.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RunCompleteGoalsPhaseTest.java
index 9710ddc..ee520f3 100644
--- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RunCompleteGoalsPhaseTest.java
+++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RunCompleteGoalsPhaseTest.java
@@ -37,7 +37,8 @@
 import org.apache.maven.shared.release.ReleaseExecutionException;
 import org.apache.maven.shared.release.ReleaseFailureException;
 import org.apache.maven.shared.release.ReleaseResult;
-import org.apache.maven.shared.release.config.ReleaseDescriptor;
+import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder;
+import org.apache.maven.shared.release.config.ReleaseUtils;
 import org.apache.maven.shared.release.env.DefaultReleaseEnvironment;
 import org.apache.maven.shared.release.env.ReleaseEnvironment;
 import org.apache.maven.shared.release.exec.MavenExecutor;
@@ -57,7 +58,7 @@
 
     private MavenExecutorWrapper mavenExecutorWrapper;
 
-    private ReleaseEnvironment releaseEnvironment;
+    private DefaultReleaseEnvironment releaseEnvironment;
 
     @Override
     public void setUp()
@@ -80,16 +81,16 @@
         // prepare
         File testFile = getTestFile( "target/working-directory" );
 
-        ReleaseDescriptor config = new ReleaseDescriptor();
-        config.setCompletionGoals( "clean integration-test" );
-        config.setWorkingDirectory( testFile.getAbsolutePath() );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setCompletionGoals( "clean integration-test" );
+        builder.setWorkingDirectory( testFile.getAbsolutePath() );
 
         MavenExecutor mock = mock( MavenExecutor.class );
 
         mavenExecutorWrapper.setMavenExecutor( mock );
 
         // execute
-        phase.execute( config, releaseEnvironment, (List<MavenProject>) null );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), releaseEnvironment, (List<MavenProject>) null );
 
         // verify
         verify( mock ).executeGoals( eq( testFile ), eq( "clean integration-test" ), isA( ReleaseEnvironment.class ),
@@ -105,16 +106,16 @@
         // prepare
         File testFile = getTestFile( "target/working-directory" );
 
-        ReleaseDescriptor config = new ReleaseDescriptor();
-        config.setCompletionGoals( "clean integration-test" );
-        config.setWorkingDirectory( testFile.getAbsolutePath() );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setCompletionGoals( "clean integration-test" );
+        builder.setWorkingDirectory( testFile.getAbsolutePath() );
 
         MavenExecutor mock = mock( MavenExecutor.class );
 
         mavenExecutorWrapper.setMavenExecutor( mock );
 
         // execute
-        phase.simulate( config, releaseEnvironment, null );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), releaseEnvironment, null );
 
         // verify
         verify( mock ).executeGoals( eq( testFile ), eq( "clean integration-test" ), isA( ReleaseEnvironment.class ),
@@ -130,9 +131,9 @@
         // prepare
         File testFile = getTestFile( "target/working-directory" );
 
-        ReleaseDescriptor config = new ReleaseDescriptor();
-        config.setCompletionGoals( "clean integration-test" );
-        config.setWorkingDirectory( testFile.getAbsolutePath() );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setCompletionGoals( "clean integration-test" );
+        builder.setWorkingDirectory( testFile.getAbsolutePath() );
 
         MavenExecutor mock = mock( MavenExecutor.class );
         doThrow( new MavenExecutorException( "...",
@@ -149,7 +150,7 @@
         // execute
         try
         {
-            phase.execute( config, releaseEnvironment, (List<MavenProject>) null );
+            phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), releaseEnvironment, (List<MavenProject>) null );
 
             fail( "Should have thrown an exception" );
         }
@@ -172,9 +173,9 @@
         // prepare
         File testFile = getTestFile( "target/working-directory" );
 
-        ReleaseDescriptor config = new ReleaseDescriptor();
-        config.setCompletionGoals( "clean integration-test" );
-        config.setWorkingDirectory( testFile.getAbsolutePath() );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setCompletionGoals( "clean integration-test" );
+        builder.setWorkingDirectory( testFile.getAbsolutePath() );
 
         MavenExecutor mock = mock( MavenExecutor.class );
         doThrow( new MavenExecutorException( "...",
@@ -191,7 +192,7 @@
         // execute
         try
         {
-            phase.simulate( config, releaseEnvironment, null );
+            phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), releaseEnvironment, null );
 
             fail( "Should have thrown an exception" );
         }
@@ -214,16 +215,16 @@
         // prepare
         File testFile = getTestFile( "target/working-directory" );
 
-        ReleaseDescriptor config = new ReleaseDescriptor();
-        config.setCompletionGoals( "" );
-        config.setWorkingDirectory( testFile.getAbsolutePath() );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setCompletionGoals( "" );
+        builder.setWorkingDirectory( testFile.getAbsolutePath() );
 
         MavenExecutor mock = mock( MavenExecutor.class );
 
         mavenExecutorWrapper.setMavenExecutor( mock );
 
         // execute
-        phase.execute( config, releaseEnvironment, (List<MavenProject>) null );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), releaseEnvironment, (List<MavenProject>) null );
 
         // verify
         // never invoke mock
diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RunPerformGoalsPhaseTest.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RunPerformGoalsPhaseTest.java
index f7bcd64..4b7ca8a 100644
--- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RunPerformGoalsPhaseTest.java
+++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RunPerformGoalsPhaseTest.java
@@ -48,7 +48,8 @@
 import org.apache.maven.shared.release.PlexusJUnit4TestCase;
 import org.apache.maven.shared.release.ReleaseExecutionException;
 import org.apache.maven.shared.release.ReleaseResult;
-import org.apache.maven.shared.release.config.ReleaseDescriptor;
+import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder;
+import org.apache.maven.shared.release.config.ReleaseUtils;
 import org.apache.maven.shared.release.env.DefaultReleaseEnvironment;
 import org.apache.maven.shared.release.env.ReleaseEnvironment;
 import org.apache.maven.shared.release.exec.MavenExecutor;
@@ -67,7 +68,7 @@
 
     private MavenExecutorWrapper mavenExecutorWrapper;
 
-    private ReleaseEnvironment releaseEnvironment;
+    private DefaultReleaseEnvironment releaseEnvironment;
 
     @Override
     public void setUp()
@@ -90,9 +91,9 @@
         // prepare
         File testFile = getTestFile( "target/checkout-directory" );
 
-        ReleaseDescriptor config = new ReleaseDescriptor();
-        config.setPerformGoals( "goal1 goal2" );
-        config.setCheckoutDirectory( testFile.getAbsolutePath() );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setPerformGoals( "goal1 goal2" );
+        builder.setCheckoutDirectory( testFile.getAbsolutePath() );
 
         MavenExecutor mock = mock( MavenExecutor.class );
 
@@ -111,7 +112,7 @@
         // execute
         try
         {
-            phase.execute( config, releaseEnvironment, (List<MavenProject>) null );
+            phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), releaseEnvironment, (List<MavenProject>) null );
 
             fail( "Should have thrown an exception" );
         }
@@ -136,16 +137,16 @@
     {
         //prepare
         File testFile = getTestFile( "target/checkout-directory" );
-        ReleaseDescriptor config = new ReleaseDescriptor();
-        config.setPerformGoals( "goal1 goal2" );
-        config.setPomFileName( "pom1.xml" );
-        config.setCheckoutDirectory( testFile.getAbsolutePath() );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setPerformGoals( "goal1 goal2" );
+        builder.setPomFileName( "pom1.xml" );
+        builder.setCheckoutDirectory( testFile.getAbsolutePath() );
 
         MavenExecutor mock = mock( MavenExecutor.class );
 
         mavenExecutorWrapper.setMavenExecutor( mock );
 
-        phase.execute( config, releaseEnvironment, (List<MavenProject>) null );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), releaseEnvironment, (List<MavenProject>) null );
 
         verify( mock ).executeGoals( eq( testFile ),
                                      eq( "goal1 goal2" ),
@@ -162,12 +163,12 @@
                     throws Exception
     {
         // prepare
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setScmSourceUrl( "scm-url" );
-        releaseDescriptor.setAdditionalArguments( "-Dmaven.test.skip=true" );
-        releaseDescriptor.setPerformGoals( "goal1 goal2" );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setScmSourceUrl( "scm-url" );
+        builder.setAdditionalArguments( "-Dmaven.test.skip=true" );
+        builder.setPerformGoals( "goal1 goal2" );
         File checkoutDirectory = getTestFile( "target/checkout-directory" );
-        releaseDescriptor.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
+        builder.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
 
         MavenExecutor mock = mock( MavenExecutor.class );
         mavenExecutorWrapper.setMavenExecutor( mock );
@@ -182,10 +183,10 @@
         ScmManagerStub stub = (ScmManagerStub) lookup( ScmManager.class );
         stub.setScmProvider( scmProviderMock );
 
-        releaseDescriptor.setUseReleaseProfile( false );
+        builder.setUseReleaseProfile( false );
 
         // execute
-        phase.execute( releaseDescriptor, releaseEnvironment, createReactorProjects() );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), releaseEnvironment, createReactorProjects() );
 
         // verify
         verify( mock ).executeGoals( eq( checkoutDirectory ),
@@ -206,11 +207,11 @@
                     throws Exception
     {
         // prepare
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setScmSourceUrl( "scm-url" );
-        releaseDescriptor.setPerformGoals( "goal1 goal2" );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setScmSourceUrl( "scm-url" );
+        builder.setPerformGoals( "goal1 goal2" );
         File checkoutDirectory = getTestFile( "target/checkout-directory" );
-        releaseDescriptor.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
+        builder.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
 
         MavenExecutor mock = mock( MavenExecutor.class );
         mavenExecutorWrapper.setMavenExecutor( mock );
@@ -226,7 +227,7 @@
         stub.setScmProvider( scmProviderMock );
 
         // execute
-        phase.execute( releaseDescriptor, releaseEnvironment, createReactorProjects() );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), releaseEnvironment, createReactorProjects() );
 
         // verify
         verify( mock ).executeGoals( eq( checkoutDirectory ),
@@ -247,11 +248,11 @@
                     throws Exception
     {
         // prepare
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setScmSourceUrl( "scm-url" );
-        releaseDescriptor.setPerformGoals( "goal1 goal2" );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setScmSourceUrl( "scm-url" );
+        builder.setPerformGoals( "goal1 goal2" );
         File checkoutDirectory = getTestFile( "target/checkout-directory" );
-        releaseDescriptor.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
+        builder.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
 
         MavenExecutor mock = mock( MavenExecutor.class );
         mavenExecutorWrapper.setMavenExecutor( mock );
@@ -266,10 +267,10 @@
         ScmManagerStub stub = (ScmManagerStub) lookup( ScmManager.class );
         stub.setScmProvider( scmProviderMock );
 
-        releaseDescriptor.setUseReleaseProfile( false );
+        builder.setUseReleaseProfile( false );
 
         // execute
-        phase.execute( releaseDescriptor, releaseEnvironment, createReactorProjects() );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), releaseEnvironment, createReactorProjects() );
 
         // verify
         verify( mock ).executeGoals( eq( checkoutDirectory ),
@@ -290,12 +291,12 @@
                     throws Exception
     {
         // prepare
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setScmSourceUrl( "scm-url" );
-        releaseDescriptor.setAdditionalArguments( "-Dmaven.test.skip=true" );
-        releaseDescriptor.setPerformGoals( "goal1 goal2" );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setScmSourceUrl( "scm-url" );
+        builder.setAdditionalArguments( "-Dmaven.test.skip=true" );
+        builder.setPerformGoals( "goal1 goal2" );
         File checkoutDirectory = getTestFile( "target/checkout-directory" );
-        releaseDescriptor.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
+        builder.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
 
         MavenExecutor mock = mock( MavenExecutor.class );
         mavenExecutorWrapper.setMavenExecutor( mock );
@@ -311,7 +312,7 @@
         stub.setScmProvider( scmProviderMock );
 
         // execute
-        phase.execute( releaseDescriptor, releaseEnvironment, createReactorProjects() );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), releaseEnvironment, createReactorProjects() );
 
         // verify
         verify( mock ).executeGoals( eq( checkoutDirectory ),
@@ -332,11 +333,11 @@
                     throws Exception
     {
         // prepare
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setScmSourceUrl( "scm-url" );
-        releaseDescriptor.setPerformGoals( "goal1 goal2" );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setScmSourceUrl( "scm-url" );
+        builder.setPerformGoals( "goal1 goal2" );
         File checkoutDirectory = getTestFile( "target/checkout-directory" );
-        releaseDescriptor.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
+        builder.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
 
         MavenExecutor mock = mock( MavenExecutor.class );
         mavenExecutorWrapper.setMavenExecutor( mock );
@@ -351,10 +352,10 @@
         ScmManagerStub stub = (ScmManagerStub) lookup( ScmManager.class );
         stub.setScmProvider( scmProviderMock );
 
-        releaseDescriptor.setCompletedPhase( "end-release" );
+        builder.setCompletedPhase( "end-release" );
 
         // execute
-        phase.execute( releaseDescriptor, releaseEnvironment, createReactorProjects() );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), releaseEnvironment, createReactorProjects() );
 
         // verify
         verify( mock ).executeGoals( eq( checkoutDirectory ),
diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RunPrepareGoalsPhaseTest.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RunPrepareGoalsPhaseTest.java
index 6a84ff7..4222580 100644
--- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RunPrepareGoalsPhaseTest.java
+++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RunPrepareGoalsPhaseTest.java
@@ -37,7 +37,8 @@
 import org.apache.maven.shared.release.ReleaseExecutionException;
 import org.apache.maven.shared.release.ReleaseFailureException;
 import org.apache.maven.shared.release.ReleaseResult;
-import org.apache.maven.shared.release.config.ReleaseDescriptor;
+import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder;
+import org.apache.maven.shared.release.config.ReleaseUtils;
 import org.apache.maven.shared.release.env.DefaultReleaseEnvironment;
 import org.apache.maven.shared.release.env.ReleaseEnvironment;
 import org.apache.maven.shared.release.exec.MavenExecutor;
@@ -57,7 +58,7 @@
 
     private MavenExecutorWrapper mavenExecutorWrapper;
 
-    private ReleaseEnvironment releaseEnvironment;
+    private DefaultReleaseEnvironment releaseEnvironment;
 
     @Override
     public void setUp()
@@ -80,16 +81,16 @@
         // prepare
         File testFile = getTestFile( "target/working-directory" );
 
-        ReleaseDescriptor config = new ReleaseDescriptor();
-        config.setPreparationGoals( "clean integration-test" );
-        config.setWorkingDirectory( testFile.getAbsolutePath() );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setPreparationGoals( "clean integration-test" );
+        builder.setWorkingDirectory( testFile.getAbsolutePath() );
 
         MavenExecutor mock = mock( MavenExecutor.class );
 
         mavenExecutorWrapper.setMavenExecutor( mock );
 
         // execute
-        phase.execute( config, releaseEnvironment, (List<MavenProject>) null );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), releaseEnvironment, (List<MavenProject>) null );
 
         // verify
         verify( mock ).executeGoals( eq( testFile ), eq( "clean integration-test" ), isA( ReleaseEnvironment.class ),
@@ -105,16 +106,16 @@
         // prepare
         File testFile = getTestFile( "target/working-directory" );
 
-        ReleaseDescriptor config = new ReleaseDescriptor();
-        config.setPreparationGoals( "clean integration-test" );
-        config.setWorkingDirectory( testFile.getAbsolutePath() );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setPreparationGoals( "clean integration-test" );
+        builder.setWorkingDirectory( testFile.getAbsolutePath() );
 
         MavenExecutor mock = mock( MavenExecutor.class );
 
         mavenExecutorWrapper.setMavenExecutor( mock );
 
         // execute
-        phase.simulate( config, releaseEnvironment, null );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), releaseEnvironment, null );
 
         // verify
         verify( mock ).executeGoals( eq( testFile ), eq( "clean integration-test" ), isA( ReleaseEnvironment.class ),
@@ -130,9 +131,9 @@
         // prepare
         File testFile = getTestFile( "target/working-directory" );
 
-        ReleaseDescriptor config = new ReleaseDescriptor();
-        config.setPreparationGoals( "clean integration-test" );
-        config.setWorkingDirectory( testFile.getAbsolutePath() );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setPreparationGoals( "clean integration-test" );
+        builder.setWorkingDirectory( testFile.getAbsolutePath() );
 
         MavenExecutor mock = mock( MavenExecutor.class );
         doThrow( new MavenExecutorException( "...",
@@ -149,7 +150,7 @@
         // execute
         try
         {
-            phase.execute( config, releaseEnvironment, (List<MavenProject>) null );
+            phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), releaseEnvironment, (List<MavenProject>) null );
 
             fail( "Should have thrown an exception" );
         }
@@ -172,9 +173,9 @@
         // prepare
         File testFile = getTestFile( "target/working-directory" );
 
-        ReleaseDescriptor config = new ReleaseDescriptor();
-        config.setPreparationGoals( "clean integration-test" );
-        config.setWorkingDirectory( testFile.getAbsolutePath() );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setPreparationGoals( "clean integration-test" );
+        builder.setWorkingDirectory( testFile.getAbsolutePath() );
 
         MavenExecutor mock = mock( MavenExecutor.class );
         doThrow( new MavenExecutorException( "...",
@@ -191,7 +192,7 @@
         // execute
         try
         {
-            phase.simulate( config, releaseEnvironment, null );
+            phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), releaseEnvironment, null );
 
             fail( "Should have thrown an exception" );
         }
@@ -215,16 +216,16 @@
         // prepare
         File testFile = getTestFile( "target/working-directory" );
 
-        ReleaseDescriptor config = new ReleaseDescriptor();
-        config.setPreparationGoals( "" );
-        config.setWorkingDirectory( testFile.getAbsolutePath() );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setPreparationGoals( "" );
+        builder.setWorkingDirectory( testFile.getAbsolutePath() );
 
         MavenExecutor mock = mock( MavenExecutor.class );
 
         mavenExecutorWrapper.setMavenExecutor( mock );
 
         // execute
-        phase.execute( config, releaseEnvironment, (List<MavenProject>) null );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), releaseEnvironment, (List<MavenProject>) null );
 
         // verify
         // no invocations of mock
diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/ScmBranchPhaseTest.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/ScmBranchPhaseTest.java
index 748c2a6..9136cb2 100644
--- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/ScmBranchPhaseTest.java
+++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/ScmBranchPhaseTest.java
@@ -52,7 +52,8 @@
 import org.apache.maven.scm.repository.ScmRepositoryException;
 import org.apache.maven.shared.release.ReleaseExecutionException;
 import org.apache.maven.shared.release.ReleaseFailureException;
-import org.apache.maven.shared.release.config.ReleaseDescriptor;
+import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder;
+import org.apache.maven.shared.release.config.ReleaseUtils;
 import org.apache.maven.shared.release.env.DefaultReleaseEnvironment;
 import org.apache.maven.shared.release.scm.ReleaseScmCommandException;
 import org.apache.maven.shared.release.scm.ReleaseScmRepositoryException;
@@ -74,7 +75,7 @@
     {
         super.setUp();
 
-        phase = (ReleasePhase) lookup( ReleasePhase.class, "scm-branch" );
+        phase = lookup( ReleasePhase.class, "scm-branch" );
     }
 
     public static String getPath( File file )
@@ -88,13 +89,13 @@
         throws Exception
     {
         // prepare
-        ReleaseDescriptor descriptor = new ReleaseDescriptor();
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
         List<MavenProject> reactorProjects = createReactorProjects();
-        descriptor.setScmSourceUrl( "scm-url" );
+        builder.setScmSourceUrl( "scm-url" );
         MavenProject rootProject = ReleaseUtil.getRootProject( reactorProjects );
-        descriptor.setWorkingDirectory( getPath( rootProject.getFile().getParentFile() ) );
-        descriptor.setScmReleaseLabel( "release-label" );
-        descriptor.setScmCommentPrefix( "[my prefix] " );
+        builder.setWorkingDirectory( getPath( rootProject.getFile().getParentFile() ) );
+        builder.setScmReleaseLabel( "release-label" );
+        builder.setScmCommentPrefix( "[my prefix] " );
 
         ScmFileSet fileSet = new ScmFileSet( rootProject.getFile().getParentFile() );
 
@@ -108,7 +109,7 @@
         stub.setScmProvider( scmProviderMock );
 
         // execute
-        phase.execute( descriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
         verify( scmProviderMock ).branch( isA( ScmRepository.class ), argThat( new IsScmFileSetEquals( fileSet ) ),
@@ -127,13 +128,13 @@
             createReactorProjects( dir, dir, null );
         String sourceUrl = "http://svn.example.com/repos/project/trunk/";
         String scmUrl = "scm:svn:" + sourceUrl;
-        ReleaseDescriptor descriptor = new ReleaseDescriptor();
-        descriptor.setScmSourceUrl( scmUrl );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setScmSourceUrl( scmUrl );
         MavenProject rootProject = ReleaseUtil.getRootProject( reactorProjects );
-        descriptor.setWorkingDirectory( getPath( rootProject.getFile().getParentFile() ) );
-        descriptor.setScmReleaseLabel( "release-label" );
-        descriptor.setScmCommentPrefix( "[my prefix] " );
-        descriptor.setScmBranchBase( "http://svn.example.com/repos/project/branches/" );
+        builder.setWorkingDirectory( getPath( rootProject.getFile().getParentFile() ) );
+        builder.setScmReleaseLabel( "release-label" );
+        builder.setScmCommentPrefix( "[my prefix] " );
+        builder.setScmBranchBase( "http://svn.example.com/repos/project/branches/" );
 
         ScmFileSet fileSet = new ScmFileSet( rootProject.getFile().getParentFile() );
 
@@ -152,7 +153,7 @@
         stub.addScmRepositoryForUrl( scmUrl, repository );
 
         // execute
-        phase.execute( descriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
         verify( scmProviderMock ).branch( eq( repository ), argThat( new IsScmFileSetEquals( fileSet ) ),
@@ -169,11 +170,11 @@
         List<MavenProject> reactorProjects =
             createReactorProjects( "rewrite-for-release/pom-with-parent-flat", "root-project" );
         MavenProject rootProject = ReleaseUtil.getRootProject( reactorProjects );
-        ReleaseDescriptor descriptor = new ReleaseDescriptor();
-        descriptor.setScmSourceUrl( rootProject.getScm().getConnection() );
-        descriptor.setWorkingDirectory( getPath( rootProject.getFile().getParentFile() ) );
-        descriptor.setScmReleaseLabel( "release-label" );
-        descriptor.setScmCommentPrefix( "[my prefix] " );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setScmSourceUrl( rootProject.getScm().getConnection() );
+        builder.setWorkingDirectory( getPath( rootProject.getFile().getParentFile() ) );
+        builder.setScmReleaseLabel( "release-label" );
+        builder.setScmCommentPrefix( "[my prefix] " );
 
         // one directory up from root project
         ScmFileSet fileSet = new ScmFileSet( rootProject.getFile().getParentFile().getParentFile() );
@@ -193,7 +194,7 @@
         stub.addScmRepositoryForUrl( "scm:svn:" + scmUrl, repository );
 
         // execute
-        phase.execute( descriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
         verify( scmProviderMock ).branch( eq( repository ), argThat( new IsScmFileSetEquals( fileSet ) ),
@@ -207,14 +208,14 @@
         throws Exception
     {
         // prepare
-        ReleaseDescriptor descriptor = new ReleaseDescriptor();
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
         String dir = "scm-commit/multiple-poms";
         List<MavenProject> reactorProjects = createReactorProjects( dir, dir, null );
-        descriptor.setScmSourceUrl( "scm-url" );
+        builder.setScmSourceUrl( "scm-url" );
         MavenProject rootProject = ReleaseUtil.getRootProject( reactorProjects );
-        descriptor.setWorkingDirectory( getPath( rootProject.getFile().getParentFile() ) );
-        descriptor.setScmReleaseLabel( "release-label" );
-        descriptor.setScmCommentPrefix( "[my prefix] " );
+        builder.setWorkingDirectory( getPath( rootProject.getFile().getParentFile() ) );
+        builder.setScmReleaseLabel( "release-label" );
+        builder.setScmCommentPrefix( "[my prefix] " );
 
         ScmFileSet fileSet = new ScmFileSet( rootProject.getFile().getParentFile() );
 
@@ -229,7 +230,7 @@
         stub.setScmProvider( scmProviderMock );
 
         // exeucte
-        phase.execute( descriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
         verify( scmProviderMock ).branch( isA( ScmRepository.class ), argThat( new IsScmFileSetEquals( fileSet ) ),
@@ -242,12 +243,12 @@
     public void testBranchNoReleaseLabel()
         throws Exception
     {
-        ReleaseDescriptor descriptor = new ReleaseDescriptor();
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
         List<MavenProject> reactorProjects = createReactorProjects();
 
         try
         {
-            phase.execute( descriptor, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
             fail( "Should have thrown an exception" );
         }
         catch ( ReleaseFailureException e )
@@ -260,12 +261,12 @@
     public void testSimulateBranch()
         throws Exception
     {
-        ReleaseDescriptor descriptor = new ReleaseDescriptor();
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
         List<MavenProject> reactorProjects = createReactorProjects();
-        descriptor.setScmSourceUrl( "scm-url" );
+        builder.setScmSourceUrl( "scm-url" );
         MavenProject rootProject = ReleaseUtil.getRootProject( reactorProjects );
-        descriptor.setWorkingDirectory( getPath( rootProject.getFile().getParentFile() ) );
-        descriptor.setScmReleaseLabel( "release-label" );
+        builder.setWorkingDirectory( getPath( rootProject.getFile().getParentFile() ) );
+        builder.setScmReleaseLabel( "release-label" );
 
         ScmProvider scmProviderMock = mock( ScmProvider.class );
 
@@ -273,7 +274,7 @@
         stub.setScmProvider( scmProviderMock );
 
         // execute
-        phase.simulate( descriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
         // no scmProvider invocation
@@ -284,12 +285,12 @@
     public void testSimulateBranchNoReleaseLabel()
         throws Exception
     {
-        ReleaseDescriptor descriptor = new ReleaseDescriptor();
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
         List<MavenProject> reactorProjects = createReactorProjects();
 
         try
         {
-            phase.simulate( descriptor, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
             fail( "Should have thrown an exception" );
         }
         catch ( ReleaseFailureException e )
@@ -304,7 +305,7 @@
     {
         // prepare
         List<MavenProject> reactorProjects = createReactorProjects();
-        ReleaseDescriptor releaseDescriptor = createReleaseDescriptor();
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder();
 
         ScmManagerStub scmManagerStub = (ScmManagerStub) lookup( ScmManager.class );
         scmManagerStub.setException( new NoSuchScmProviderException( "..." )  );
@@ -312,7 +313,7 @@
         // execute
         try
         {
-            phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "Status check should have failed" );
         }
@@ -329,7 +330,7 @@
     {
         // prepare
         List<MavenProject> reactorProjects = createReactorProjects();
-        ReleaseDescriptor releaseDescriptor = createReleaseDescriptor();
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder();
 
         ScmManagerStub scmManagerStub = (ScmManagerStub) lookup( ScmManager.class );
         scmManagerStub.setException( new ScmRepositoryException( "..." )  );
@@ -337,7 +338,7 @@
         // execute
         try
         {
-            phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "Status check should have failed" );
         }
@@ -355,7 +356,7 @@
     {
         // prepare
         List<MavenProject> reactorProjects = createReactorProjects();
-        ReleaseDescriptor releaseDescriptor = createReleaseDescriptor();
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder();
 
         ScmProvider scmProviderMock = mock( ScmProvider.class );
         when( scmProviderMock.branch( isA( ScmRepository.class ), isA( ScmFileSet.class ), isA( String.class ),
@@ -367,7 +368,7 @@
         // execute
         try
         {
-            phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "Status check should have failed" );
         }
@@ -387,17 +388,17 @@
         throws Exception
     {
         List<MavenProject> reactorProjects = createReactorProjects();
-        ReleaseDescriptor releaseDescriptor = createReleaseDescriptor();
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder();
 
         ScmManager scmManager = (ScmManager) lookup( ScmManager.class );
         ScmProviderStub providerStub =
-            (ScmProviderStub) scmManager.getProviderByUrl( releaseDescriptor.getScmSourceUrl() );
+            (ScmProviderStub) scmManager.getProviderByUrl( "scm-url" );
 
         providerStub.setBranchScmResult( new BranchScmResult( "", "", "", false ) );
 
         try
         {
-            phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "Commit should have failed" );
         }
@@ -414,13 +415,13 @@
         return createReactorProjects( dir, dir, null );
     }
 
-    private static ReleaseDescriptor createReleaseDescriptor()
+    private static ReleaseDescriptorBuilder createReleaseDescriptorBuilder()
         throws IOException
     {
-        ReleaseDescriptor descriptor = new ReleaseDescriptor();
-        descriptor.setScmSourceUrl( "scm-url" );
-        descriptor.setScmReleaseLabel( "release-label" );
-        descriptor.setWorkingDirectory( getPath( getTestFile( "target/test/checkout" ) ) );
-        return descriptor;
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setScmSourceUrl( "scm-url" );
+        builder.setScmReleaseLabel( "release-label" );
+        builder.setWorkingDirectory( getPath( getTestFile( "target/test/checkout" ) ) );
+        return builder;
     }
 }
diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/ScmCheckModificationsPhaseTest.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/ScmCheckModificationsPhaseTest.java
index e6fad03..bff49da 100644
--- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/ScmCheckModificationsPhaseTest.java
+++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/ScmCheckModificationsPhaseTest.java
@@ -51,7 +51,8 @@
 import org.apache.maven.shared.release.ReleaseExecutionException;
 import org.apache.maven.shared.release.ReleaseFailureException;
 import org.apache.maven.shared.release.ReleaseResult;
-import org.apache.maven.shared.release.config.ReleaseDescriptor;
+import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder;
+import org.apache.maven.shared.release.config.ReleaseUtils;
 import org.apache.maven.shared.release.env.DefaultReleaseEnvironment;
 import org.apache.maven.shared.release.scm.ReleaseScmCommandException;
 import org.apache.maven.shared.release.scm.ReleaseScmRepositoryException;
@@ -82,9 +83,9 @@
         throws Exception
     {
         // prepare
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setScmSourceUrl( "scm-url" );
-        releaseDescriptor.setWorkingDirectory( getTestFile( "target/test/checkout" ).getAbsolutePath() );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setScmSourceUrl( "scm-url" );
+        builder.setWorkingDirectory( getTestFile( "target/test/checkout" ).getAbsolutePath() );
 
         ScmManagerStub scmManagerStub = (ScmManagerStub) lookup( ScmManager.class );
         scmManagerStub.setException( new NoSuchScmProviderException( "..." )  );
@@ -92,7 +93,7 @@
         // execute
         try
         {
-            phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), null );
+            phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), null );
 
             fail( "Status check should have failed" );
         }
@@ -103,7 +104,7 @@
 
         try
         {
-            phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), null );
+            phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), null );
 
             fail( "Status check should have failed" );
         }
@@ -119,9 +120,9 @@
         throws Exception
     {
         // prepare
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setScmSourceUrl( "scm-url" );
-        releaseDescriptor.setWorkingDirectory( getTestFile( "target/test/checkout" ).getAbsolutePath() );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setScmSourceUrl( "scm-url" );
+        builder.setWorkingDirectory( getTestFile( "target/test/checkout" ).getAbsolutePath() );
 
         ScmManagerStub scmManagerStub = (ScmManagerStub) lookup( ScmManager.class );
         scmManagerStub.setException( new ScmRepositoryException( "..." )  );
@@ -129,7 +130,7 @@
         // execute
         try
         {
-            phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), null );
+            phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), null );
 
             fail( "Status check should have failed" );
         }
@@ -140,7 +141,7 @@
 
         try
         {
-            phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), null );
+            phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), null );
 
             fail( "Status check should have failed" );
         }
@@ -155,9 +156,9 @@
         throws Exception
     {
         // prepare
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setScmSourceUrl( "scm-url" );
-        releaseDescriptor.setWorkingDirectory( getTestFile( "target/test/checkout" ).getAbsolutePath() );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setScmSourceUrl( "scm-url" );
+        builder.setWorkingDirectory( getTestFile( "target/test/checkout" ).getAbsolutePath() );
 
         ScmProvider scmProviderMock = mock( ScmProvider.class );
         when( scmProviderMock.status( isA( ScmRepository.class ),
@@ -169,7 +170,7 @@
         // execute
         try
         {
-            phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), null );
+            phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), null );
 
             fail( "Status check should have failed" );
         }
@@ -180,7 +181,7 @@
 
         try
         {
-            phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), null );
+            phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), null );
 
             fail( "Status check should have failed" );
         }
@@ -198,17 +199,17 @@
     public void testScmResultFailure()
         throws Exception
     {
-        ReleaseDescriptor releaseDescriptor = createReleaseDescriptor();
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder();
 
-        ScmManager scmManager = (ScmManager) lookup( ScmManager.class );
+        ScmManager scmManager = lookup( ScmManager.class );
         ScmProviderStub providerStub =
-            (ScmProviderStub) scmManager.getProviderByUrl( releaseDescriptor.getScmSourceUrl() );
+            (ScmProviderStub) scmManager.getProviderByUrl( "scm:svn:file://localhost/tmp/scm-repo" );
 
         providerStub.setStatusScmResult( new StatusScmResult( "", "", "", false ) );
 
         try
         {
-            phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), null );
+            phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), null );
 
             fail( "Status check should have failed" );
         }
@@ -219,7 +220,7 @@
 
         try
         {
-            phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), null );
+            phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), null );
 
             fail( "Status check should have failed" );
         }
@@ -233,13 +234,13 @@
     public void testNoModifications()
         throws Exception
     {
-        ReleaseDescriptor releaseDescriptor = createReleaseDescriptor();
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder();
 
-        setChangedFiles( releaseDescriptor, Collections.<String>emptyList() );
+        setChangedFiles( builder, Collections.<String>emptyList() );
 
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), null );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), null );
 
-        phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), null );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), null );
 
         // successful execution is verification enough
         assertTrue( true );
@@ -249,14 +250,14 @@
     public void testModificationsToExcludedFilesOnly()
         throws Exception
     {
-        ReleaseDescriptor releaseDescriptor = createReleaseDescriptor();
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder();
 
-        setChangedFiles( releaseDescriptor,
+        setChangedFiles( builder,
                          Arrays.asList( "release.properties", "pom.xml.backup", "pom.xml.tag", "pom.xml.next" ) );
 
-        phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), null );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), null );
 
-        phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), null );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), null );
 
         // successful execution is verification enough
         assertTrue( true );
@@ -267,32 +268,32 @@
     public void testModificationsToCustomExcludedFilesOnly()
         throws Exception
     {
-        ReleaseDescriptor releaseDescriptor = createReleaseDescriptor();
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder();
 
-        releaseDescriptor.setCheckModificationExcludes( Collections.singletonList( "**/keep.me" ) );
+        builder.setCheckModificationExcludes( Collections.singletonList( "**/keep.me" ) );
 
-        setChangedFiles( releaseDescriptor,
+        setChangedFiles( builder,
                          Arrays.asList( "release.properties", "pom.xml.backup", "pom.xml.tag", "pom.xml.next",
                                         "keep.me", "src/app/keep.me", "config\\keep.me" ) );
 
         assertEquals( ReleaseResult.SUCCESS,
-                      phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), null ).getResultCode() );
+                      phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), null ).getResultCode() );
 
         assertEquals( ReleaseResult.SUCCESS,
-                      phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), null ).getResultCode() );
+                      phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), null ).getResultCode() );
     }
 
     @Test
     public void testModificationsToPoms()
         throws Exception
     {
-        ReleaseDescriptor releaseDescriptor = createReleaseDescriptor();
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder();
 
-        setChangedFiles( releaseDescriptor, Arrays.asList( "pom.xml", "module/pom.xml" ) );
+        setChangedFiles( builder, Arrays.asList( "pom.xml", "module/pom.xml" ) );
 
         try
         {
-            phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), null );
+            phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), null );
 
             fail( "Status check should have failed" );
         }
@@ -303,7 +304,7 @@
 
         try
         {
-            phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), null );
+            phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), null );
 
             fail( "Status check should have failed" );
         }
@@ -317,13 +318,13 @@
     public void testModificationsToIncludedFilesOnly()
         throws Exception
     {
-        ReleaseDescriptor releaseDescriptor = createReleaseDescriptor();
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder();
 
-        setChangedFiles( releaseDescriptor, Collections.singletonList( "something.txt" ) );
+        setChangedFiles( builder, Collections.singletonList( "something.txt" ) );
 
         try
         {
-            phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), null );
+            phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), null );
 
             fail( "Status check should have failed" );
         }
@@ -334,7 +335,7 @@
 
         try
         {
-            phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), null );
+            phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), null );
 
             fail( "Status check should have failed" );
         }
@@ -348,14 +349,14 @@
     public void testModificationsToIncludedAndExcludedFiles()
         throws Exception
     {
-        ReleaseDescriptor releaseDescriptor = createReleaseDescriptor();
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder();
 
-        setChangedFiles( releaseDescriptor, Arrays.asList( "release.properties", "pom.xml.backup", "pom.xml.tag",
+        setChangedFiles( builder, Arrays.asList( "release.properties", "pom.xml.backup", "pom.xml.tag",
                                                            "pom.xml.release", "something.txt" ) );
 
         try
         {
-            phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), null );
+            phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), null );
 
             fail( "Status check should have failed" );
         }
@@ -366,7 +367,7 @@
 
         try
         {
-            phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), null );
+            phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), null );
 
             fail( "Status check should have failed" );
         }
@@ -380,16 +381,16 @@
     public void testModificationsToAdditionalExcludedFiles()
         throws Exception
     {
-        ReleaseDescriptor releaseDescriptor = createReleaseDescriptor();
-        releaseDescriptor.setCheckModificationExcludes( Collections.singletonList( "something.*" ) );
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder();
+        builder.setCheckModificationExcludes( Collections.singletonList( "something.*" ) );
 
-        setChangedFiles( releaseDescriptor, Collections.singletonList( "something.txt" ) );
+        setChangedFiles( builder, Collections.singletonList( "something.txt" ) );
 
         assertEquals( ReleaseResult.SUCCESS,
-                      phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), null ).getResultCode() );
+                      phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), null ).getResultCode() );
 
         assertEquals( ReleaseResult.SUCCESS,
-                      phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), null ).getResultCode() );
+                      phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), null ).getResultCode() );
     }
 
     // MRELEASE-775
@@ -397,25 +398,25 @@
     public void testMultipleExclusionPatternMatch()
         throws Exception
     {
-        ReleaseDescriptor releaseDescriptor = createReleaseDescriptor();
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder();
 
-        releaseDescriptor.setCheckModificationExcludes( Collections.singletonList( "release.properties" ) );
+        builder.setCheckModificationExcludes( Collections.singletonList( "release.properties" ) );
 
-        setChangedFiles( releaseDescriptor, Arrays.asList( "release.properties" ) );
+        setChangedFiles( builder, Arrays.asList( "release.properties" ) );
 
         assertEquals( ReleaseResult.SUCCESS,
-                      phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), null ).getResultCode() );
+                      phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), null ).getResultCode() );
 
         assertEquals( ReleaseResult.SUCCESS,
-                      phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), null ).getResultCode() );
+                      phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), null ).getResultCode() );
     }
 
-    private void setChangedFiles( ReleaseDescriptor releaseDescriptor, List<String> changedFiles )
+    private void setChangedFiles( ReleaseDescriptorBuilder builder, List<String> changedFiles )
         throws Exception
     {
         ScmManager scmManager = (ScmManager) lookup( ScmManager.class );
         ScmProviderStub providerStub =
-            (ScmProviderStub) scmManager.getProviderByUrl( releaseDescriptor.getScmSourceUrl() );
+            (ScmProviderStub) scmManager.getProviderByUrl( "scm:svn:file://localhost/tmp/scm-repo" );
 
         providerStub.setStatusScmResult( new StatusScmResult( "", createScmFiles( changedFiles ) ) );
     }
@@ -431,11 +432,11 @@
         return files;
     }
 
-    private static ReleaseDescriptor createReleaseDescriptor()
+    private static ReleaseDescriptorBuilder createReleaseDescriptorBuilder()
     {
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo" );
-        releaseDescriptor.setWorkingDirectory( getTestFile( "target/test/checkout" ).getAbsolutePath() );
-        return releaseDescriptor;
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo" );
+        builder.setWorkingDirectory( getTestFile( "target/test/checkout" ).getAbsolutePath() );
+        return builder;
     }
 }
diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/ScmCommitDevelopmentPhaseTest.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/ScmCommitDevelopmentPhaseTest.java
index fc67417..41c90f3 100644
--- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/ScmCommitDevelopmentPhaseTest.java
+++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/ScmCommitDevelopmentPhaseTest.java
@@ -42,7 +42,8 @@
 import org.apache.maven.scm.manager.ScmManagerStub;
 import org.apache.maven.scm.provider.ScmProvider;
 import org.apache.maven.scm.repository.ScmRepository;
-import org.apache.maven.shared.release.config.ReleaseDescriptor;
+import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder;
+import org.apache.maven.shared.release.config.ReleaseUtils;
 import org.apache.maven.shared.release.env.DefaultReleaseEnvironment;
 import org.apache.maven.shared.release.util.ReleaseUtil;
 import org.junit.Test;
@@ -64,7 +65,7 @@
 
     private MavenProject rootProject;
 
-    private ReleaseDescriptor descriptor;
+    private ReleaseDescriptorBuilder builder;
 
     private ScmProvider scmProviderMock;
 
@@ -78,7 +79,7 @@
 
         reactorProjects = createReactorProjects();
         rootProject = ReleaseUtil.getRootProject( reactorProjects );
-        descriptor = createReleaseDescriptor( rootProject );
+        builder = createReleaseDescriptorBuilder( rootProject );
     }
 
     @Test
@@ -91,16 +92,16 @@
     public void testNoCommitOrRollbackRequired()
         throws Exception
     {
-        ReleaseDescriptor descriptor = createReleaseDescriptor( rootProject );
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( rootProject );
         List<MavenProject> reactorProjects = createReactorProjects();
 
-        descriptor.setRemoteTagging( false );
-        descriptor.setSuppressCommitBeforeTagOrBranch( true );
-        descriptor.setUpdateWorkingCopyVersions( false );
+        builder.setRemoteTagging( false );
+        builder.setSuppressCommitBeforeTagOrBranch( true );
+        builder.setUpdateWorkingCopyVersions( false );
 
         prepareNoCheckin();
 
-        phase.execute( descriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         verifyNoCheckin();
     }
@@ -109,11 +110,11 @@
     public void testCommitsNextVersions()
         throws Exception
     {
-        descriptor.setUpdateWorkingCopyVersions( true );
+        builder.setUpdateWorkingCopyVersions( true );
 
         prepareCheckin( COMMIT_MESSAGE );
 
-        phase.execute( descriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         verifyCheckin( COMMIT_MESSAGE );
     }
@@ -122,13 +123,13 @@
     public void testCommitsRollbackPrepare()
         throws Exception
     {
-        descriptor.setUpdateWorkingCopyVersions( false );
+        builder.setUpdateWorkingCopyVersions( false );
 
-        String message = ROLLBACK_PREFIX + descriptor.getScmReleaseLabel();
+        String message = ROLLBACK_PREFIX + "release-label";
 
         prepareCheckin( message );
 
-        phase.execute( descriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         verifyCheckin( message );
     }
@@ -176,12 +177,12 @@
         return createReactorProjects( dir, dir, null );
     }
 
-    private static ReleaseDescriptor createReleaseDescriptor( MavenProject rootProject )
+    private static ReleaseDescriptorBuilder createReleaseDescriptorBuilder( MavenProject rootProject )
     {
-        ReleaseDescriptor descriptor = new ReleaseDescriptor();
-        descriptor.setScmSourceUrl( "scm-url" );
-        descriptor.setScmReleaseLabel( "release-label" );
-        descriptor.setWorkingDirectory( rootProject.getFile().getParentFile().getAbsolutePath() );
-        return descriptor;
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setScmSourceUrl( "scm-url" );
+        builder.setScmReleaseLabel( "release-label" );
+        builder.setWorkingDirectory( rootProject.getFile().getParentFile().getAbsolutePath() );
+        return builder;
     }
 }
\ No newline at end of file
diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/ScmCommitPreparationPhaseTest.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/ScmCommitPreparationPhaseTest.java
index c1d562e..54c1860 100644
--- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/ScmCommitPreparationPhaseTest.java
+++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/ScmCommitPreparationPhaseTest.java
@@ -53,7 +53,8 @@
 import org.apache.maven.scm.repository.ScmRepositoryException;
 import org.apache.maven.shared.release.ReleaseExecutionException;
 import org.apache.maven.shared.release.ReleaseFailureException;
-import org.apache.maven.shared.release.config.ReleaseDescriptor;
+import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder;
+import org.apache.maven.shared.release.config.ReleaseUtils;
 import org.apache.maven.shared.release.env.DefaultReleaseEnvironment;
 import org.apache.maven.shared.release.scm.ReleaseScmCommandException;
 import org.apache.maven.shared.release.scm.ReleaseScmRepositoryException;
@@ -99,11 +100,11 @@
     {
         // prepare
         List<MavenProject> reactorProjects = createReactorProjects();
-        ReleaseDescriptor descriptor = new ReleaseDescriptor();
-        descriptor.setScmSourceUrl( "scm-url" );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setScmSourceUrl( "scm-url" );
         MavenProject rootProject = ReleaseUtil.getRootProject( reactorProjects );
-        descriptor.setWorkingDirectory( rootProject.getFile().getParentFile().getAbsolutePath() );
-        descriptor.setScmReleaseLabel( "release-label" );
+        builder.setWorkingDirectory( rootProject.getFile().getParentFile().getAbsolutePath() );
+        builder.setScmReleaseLabel( "release-label" );
 
         ScmFileSet fileSet = new ScmFileSet( rootProject.getFile().getParentFile(), rootProject.getFile() );
 
@@ -119,7 +120,7 @@
         stub.setScmProvider( scmProviderMock );
 
         // execute
-        phase.execute( descriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
         verify( scmProviderMock ).checkIn( isA( ScmRepository.class ), argThat( new IsScmFileSetEquals( fileSet ) ),
@@ -132,13 +133,13 @@
         throws Exception
     {
         // prepare
-        ReleaseDescriptor descriptor = new ReleaseDescriptor();
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
         String dir = "scm-commit/multiple-poms";
         List<MavenProject> reactorProjects = createReactorProjects( dir, dir, null );
-        descriptor.setScmSourceUrl( "scm-url" );
+        builder.setScmSourceUrl( "scm-url" );
         MavenProject rootProject = ReleaseUtil.getRootProject( reactorProjects );
-        descriptor.setWorkingDirectory( rootProject.getFile().getParentFile().getAbsolutePath() );
-        descriptor.setScmReleaseLabel( "release-label" );
+        builder.setWorkingDirectory( rootProject.getFile().getParentFile().getAbsolutePath() );
+        builder.setScmReleaseLabel( "release-label" );
 
         List<File> poms = new ArrayList<>();
         for ( Iterator<MavenProject> i = reactorProjects.iterator(); i.hasNext(); )
@@ -159,7 +160,7 @@
         stub.setScmProvider( scmProviderMock );
 
         // execute
-        phase.execute( descriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
         verify( scmProviderMock ).checkIn( isA( ScmRepository.class ), argThat( new IsScmFileSetEquals( fileSet ) ),
@@ -174,12 +175,12 @@
         // prepare
         phase = (ReleasePhase) lookup( ReleasePhase.class, "scm-commit-development" );
 
-        ReleaseDescriptor descriptor = new ReleaseDescriptor();
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
         List<MavenProject> reactorProjects = createReactorProjects();
-        descriptor.setScmSourceUrl( "scm-url" );
+        builder.setScmSourceUrl( "scm-url" );
         MavenProject rootProject = ReleaseUtil.getRootProject( reactorProjects );
-        descriptor.setWorkingDirectory( rootProject.getFile().getParentFile().getAbsolutePath() );
-        descriptor.setScmReleaseLabel( "release-label" );
+        builder.setWorkingDirectory( rootProject.getFile().getParentFile().getAbsolutePath() );
+        builder.setScmReleaseLabel( "release-label" );
 
         ScmFileSet fileSet = new ScmFileSet( rootProject.getFile().getParentFile(), rootProject.getFile() );
 
@@ -194,7 +195,7 @@
         stub.setScmProvider( scmProviderMock );
 
         // execute
-        phase.execute( descriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
         verify( scmProviderMock ).checkIn( isA( ScmRepository.class ), argThat( new IsScmFileSetEquals( fileSet ) ),
@@ -207,12 +208,12 @@
     public void testCommitNoReleaseLabel()
         throws Exception
     {
-        ReleaseDescriptor descriptor = new ReleaseDescriptor();
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
         List<MavenProject> reactorProjects = createReactorProjects();
 
         try
         {
-            phase.execute( descriptor, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
             fail( "Should have thrown an exception" );
         }
         catch ( ReleaseFailureException e )
@@ -227,12 +228,12 @@
     {
         // prepare
         List<MavenProject> reactorProjects = createReactorProjects();
-        ReleaseDescriptor descriptor = new ReleaseDescriptor();
-        descriptor.setScmSourceUrl( "scm-url" );
-        descriptor.setGenerateReleasePoms( true );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setScmSourceUrl( "scm-url" );
+        builder.setGenerateReleasePoms( true );
         MavenProject rootProject = ReleaseUtil.getRootProject( reactorProjects );
-        descriptor.setWorkingDirectory( rootProject.getFile().getParentFile().getAbsolutePath() );
-        descriptor.setScmReleaseLabel( "release-label" );
+        builder.setWorkingDirectory( rootProject.getFile().getParentFile().getAbsolutePath() );
+        builder.setScmReleaseLabel( "release-label" );
 
         List<File> files = new ArrayList<>();
         files.add( rootProject.getFile() );
@@ -251,7 +252,7 @@
         stub.setScmProvider( scmProviderMock );
 
         // execute
-        phase.execute( descriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
         verify( scmProviderMock ).checkIn( isA( ScmRepository.class ), argThat( new IsScmFileSetEquals( fileSet ) ),
@@ -263,19 +264,19 @@
     public void testSimulateCommit()
         throws Exception
     {
-        ReleaseDescriptor descriptor = new ReleaseDescriptor();
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
         List<MavenProject> reactorProjects = createReactorProjects();
-        descriptor.setScmSourceUrl( "scm-url" );
+        builder.setScmSourceUrl( "scm-url" );
         MavenProject rootProject = ReleaseUtil.getRootProject( reactorProjects );
-        descriptor.setWorkingDirectory( rootProject.getFile().getParentFile().getAbsolutePath() );
-        descriptor.setScmReleaseLabel( "release-label" );
+        builder.setWorkingDirectory( rootProject.getFile().getParentFile().getAbsolutePath() );
+        builder.setScmReleaseLabel( "release-label" );
 
         ScmProvider scmProviderMock = mock( ScmProvider.class );
 
         ScmManagerStub stub = (ScmManagerStub) lookup( ScmManager.class );
         stub.setScmProvider( scmProviderMock );
 
-        phase.simulate( descriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // never invoke scmProviderMock
         verifyNoMoreInteractions( scmProviderMock );
@@ -285,12 +286,12 @@
     public void testSimulateCommitNoReleaseLabel()
         throws Exception
     {
-        ReleaseDescriptor descriptor = new ReleaseDescriptor();
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
         List<MavenProject> reactorProjects = createReactorProjects();
 
         try
         {
-            phase.simulate( descriptor, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
             fail( "Should have thrown an exception" );
         }
         catch ( ReleaseFailureException e )
@@ -305,14 +306,14 @@
     {
         // prepare
         List<MavenProject> reactorProjects = createReactorProjects();
-        ReleaseDescriptor releaseDescriptor = createReleaseDescriptor();
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder();
 
         ScmManagerStub scmManagerStub = (ScmManagerStub) lookup( ScmManager.class );
         scmManagerStub.setException( new NoSuchScmProviderException( "..." )  );
         // execute
         try
         {
-            phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "Status check should have failed" );
         }
@@ -329,7 +330,7 @@
     {
         // prepare
         List<MavenProject> reactorProjects = createReactorProjects();
-        ReleaseDescriptor releaseDescriptor = createReleaseDescriptor();
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder();
 
         ScmManagerStub scmManagerStub = (ScmManagerStub) lookup( ScmManager.class );
         scmManagerStub.setException( new ScmRepositoryException( "..." )  );
@@ -337,7 +338,7 @@
         // execute
         try
         {
-            phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "Status check should have failed" );
         }
@@ -354,7 +355,7 @@
     {
         // prepare
         List<MavenProject> reactorProjects = createReactorProjects();
-        ReleaseDescriptor releaseDescriptor = createReleaseDescriptor();
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder();
 
         ScmProvider scmProviderMock = mock( ScmProvider.class );
         when( scmProviderMock.checkIn( isA( ScmRepository.class ), isA( ScmFileSet.class ), isNull( ScmVersion.class ),
@@ -366,7 +367,7 @@
         // execute
         try
         {
-            phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "Status check should have failed" );
         }
@@ -386,17 +387,17 @@
         throws Exception
     {
         List<MavenProject> reactorProjects = createReactorProjects();
-        ReleaseDescriptor releaseDescriptor = createReleaseDescriptor();
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder();
 
         ScmManager scmManager = (ScmManager) lookup( ScmManager.class );
         ScmProviderStub providerStub =
-            (ScmProviderStub) scmManager.getProviderByUrl( releaseDescriptor.getScmSourceUrl() );
+            (ScmProviderStub) scmManager.getProviderByUrl( "scm-url" );
 
         providerStub.setCheckInScmResult( new CheckInScmResult( "", "", "", false ) );
 
         try
         {
-            phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "Commit should have failed" );
         }
@@ -410,11 +411,11 @@
     public void testSuppressCommitWithRemoteTaggingFails()
         throws Exception
     {
-        ReleaseDescriptor descriptor = createReleaseDescriptor();
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder();
         List<MavenProject> reactorProjects = createReactorProjects();
 
-        descriptor.setRemoteTagging( true );
-        descriptor.setSuppressCommitBeforeTagOrBranch( true );
+        builder.setRemoteTagging( true );
+        builder.setSuppressCommitBeforeTagOrBranch( true );
 
         ScmProvider scmProviderMock = mock( ScmProvider.class );
 
@@ -423,7 +424,7 @@
 
         try
         {
-            phase.execute( descriptor, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "Commit should have failed with ReleaseFailureException" );
         }
@@ -440,19 +441,19 @@
     public void testSuppressCommitAfterBranch()
         throws Exception
     {
-        ReleaseDescriptor descriptor = createReleaseDescriptor();
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder();
         List<MavenProject> reactorProjects = createReactorProjects();
 
-        descriptor.setBranchCreation( true );
-        descriptor.setRemoteTagging( false );
-        descriptor.setSuppressCommitBeforeTagOrBranch( true );
+        builder.setBranchCreation( true );
+        builder.setRemoteTagging( false );
+        builder.setSuppressCommitBeforeTagOrBranch( true );
 
         ScmProvider scmProviderMock = mock( ScmProvider.class );
 
         ScmManagerStub stub = (ScmManagerStub) lookup( ScmManager.class );
         stub.setScmProvider( scmProviderMock );
 
-        phase.execute( descriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // never invoke scmProviderMock
         verifyNoMoreInteractions( scmProviderMock );
@@ -465,12 +466,12 @@
         return createReactorProjects( dir, dir, null );
     }
 
-    private static ReleaseDescriptor createReleaseDescriptor()
+    private static ReleaseDescriptorBuilder createReleaseDescriptorBuilder()
     {
-        ReleaseDescriptor descriptor = new ReleaseDescriptor();
-        descriptor.setScmSourceUrl( "scm-url" );
-        descriptor.setScmReleaseLabel( "release-label" );
-        descriptor.setWorkingDirectory( getTestFile( "target/test/checkout" ).getAbsolutePath() );
-        return descriptor;
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setScmSourceUrl( "scm-url" );
+        builder.setScmReleaseLabel( "release-label" );
+        builder.setWorkingDirectory( getTestFile( "target/test/checkout" ).getAbsolutePath() );
+        return builder;
     }
 }
\ No newline at end of file
diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/ScmTagPhaseTest.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/ScmTagPhaseTest.java
index 8f31526..1ac428b 100644
--- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/ScmTagPhaseTest.java
+++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/ScmTagPhaseTest.java
@@ -52,7 +52,8 @@
 import org.apache.maven.scm.repository.ScmRepositoryException;
 import org.apache.maven.shared.release.ReleaseExecutionException;
 import org.apache.maven.shared.release.ReleaseFailureException;
-import org.apache.maven.shared.release.config.ReleaseDescriptor;
+import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder;
+import org.apache.maven.shared.release.config.ReleaseUtils;
 import org.apache.maven.shared.release.env.DefaultReleaseEnvironment;
 import org.apache.maven.shared.release.scm.ReleaseScmCommandException;
 import org.apache.maven.shared.release.scm.ReleaseScmRepositoryException;
@@ -88,13 +89,13 @@
         throws Exception
     {
         // prepare
-        ReleaseDescriptor descriptor = new ReleaseDescriptor();
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
         List<MavenProject> reactorProjects = createReactorProjects();
-        descriptor.setScmSourceUrl( "scm-url" );
+        builder.setScmSourceUrl( "scm-url" );
         MavenProject rootProject = ReleaseUtil.getRootProject( reactorProjects );
-        descriptor.setWorkingDirectory( getPath( rootProject.getFile().getParentFile() ) );
-        descriptor.setScmReleaseLabel( "release-label" );
-        descriptor.setScmCommentPrefix( "[my prefix] " );
+        builder.setWorkingDirectory( getPath( rootProject.getFile().getParentFile() ) );
+        builder.setScmReleaseLabel( "release-label" );
+        builder.setScmCommentPrefix( "[my prefix] " );
 
         ScmFileSet fileSet = new ScmFileSet( rootProject.getFile().getParentFile() );
 
@@ -108,7 +109,7 @@
         stub.setScmProvider( scmProviderMock );
 
         // execute
-        phase.execute( descriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
         verify( scmProviderMock ).tag( isA( ScmRepository.class ), argThat( new IsScmFileSetEquals( fileSet ) ),
@@ -126,13 +127,13 @@
             createReactorProjects( "scm-commit/multimodule-with-deep-subprojects", "" );
         String sourceUrl = "http://svn.example.com/repos/project/trunk/";
         String scmUrl = "scm:svn:" + sourceUrl;
-        ReleaseDescriptor descriptor = new ReleaseDescriptor();
-        descriptor.setScmSourceUrl( scmUrl );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setScmSourceUrl( scmUrl );
         MavenProject rootProject = ReleaseUtil.getRootProject( reactorProjects );
-        descriptor.setWorkingDirectory( getPath( rootProject.getFile().getParentFile() ) );
-        descriptor.setScmReleaseLabel( "release-label" );
-        descriptor.setScmCommentPrefix( "[my prefix] " );
-        descriptor.setScmTagBase( "http://svn.example.com/repos/project/releases/" );
+        builder.setWorkingDirectory( getPath( rootProject.getFile().getParentFile() ) );
+        builder.setScmReleaseLabel( "release-label" );
+        builder.setScmCommentPrefix( "[my prefix] " );
+        builder.setScmTagBase( "http://svn.example.com/repos/project/releases/" );
 
         ScmFileSet fileSet = new ScmFileSet( rootProject.getFile().getParentFile() );
 
@@ -151,7 +152,7 @@
         stub.addScmRepositoryForUrl( scmUrl, repository );
 
         // execute
-        phase.execute( descriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
         verify( scmProviderMock ).tag( eq( repository ), argThat( new IsScmFileSetEquals( fileSet ) ),
@@ -168,11 +169,11 @@
         List<MavenProject> reactorProjects =
             createReactorProjects( "rewrite-for-release/pom-with-parent-flat", "root-project" );
         MavenProject rootProject = ReleaseUtil.getRootProject( reactorProjects );
-        ReleaseDescriptor descriptor = new ReleaseDescriptor();
-        descriptor.setScmSourceUrl( rootProject.getScm().getConnection() );
-        descriptor.setWorkingDirectory( getPath( rootProject.getFile().getParentFile() ) );
-        descriptor.setScmReleaseLabel( "release-label" );
-        descriptor.setScmCommentPrefix( "[my prefix] " );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setScmSourceUrl( rootProject.getScm().getConnection() );
+        builder.setWorkingDirectory( getPath( rootProject.getFile().getParentFile() ) );
+        builder.setScmReleaseLabel( "release-label" );
+        builder.setScmCommentPrefix( "[my prefix] " );
 
         // one directory up from root project
         ScmFileSet fileSet = new ScmFileSet( rootProject.getFile().getParentFile().getParentFile() );
@@ -192,7 +193,7 @@
         stub.addScmRepositoryForUrl( "scm:svn:" + scmUrl, repository );
 
         // execute
-        phase.execute( descriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
         verify( scmProviderMock ).tag( eq( repository ), argThat( new IsScmFileSetEquals( fileSet ) ),
@@ -206,14 +207,14 @@
         throws Exception
     {
         // prepare
-        ReleaseDescriptor descriptor = new ReleaseDescriptor();
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
         String dir = "scm-commit/multiple-poms";
         List<MavenProject> reactorProjects = createReactorProjects( dir, dir, null );
-        descriptor.setScmSourceUrl( "scm-url" );
+        builder.setScmSourceUrl( "scm-url" );
         MavenProject rootProject = ReleaseUtil.getRootProject( reactorProjects );
-        descriptor.setWorkingDirectory( getPath( rootProject.getFile().getParentFile() ) );
-        descriptor.setScmReleaseLabel( "release-label" );
-        descriptor.setScmCommentPrefix( "[my prefix] " );
+        builder.setWorkingDirectory( getPath( rootProject.getFile().getParentFile() ) );
+        builder.setScmReleaseLabel( "release-label" );
+        builder.setScmCommentPrefix( "[my prefix] " );
 
         ScmFileSet fileSet = new ScmFileSet( rootProject.getFile().getParentFile() );
 
@@ -228,7 +229,7 @@
         stub.setScmProvider( scmProviderMock );
 
         // exeucte
-        phase.execute( descriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
         verify( scmProviderMock ).tag( isA( ScmRepository.class ), argThat( new IsScmFileSetEquals( fileSet ) ),
@@ -241,12 +242,12 @@
     public void testTagNoReleaseLabel()
         throws Exception
     {
-        ReleaseDescriptor descriptor = new ReleaseDescriptor();
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
         List<MavenProject> reactorProjects = createReactorProjects();
 
         try
         {
-            phase.execute( descriptor, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
             fail( "Should have thrown an exception" );
         }
         catch ( ReleaseFailureException e )
@@ -259,12 +260,12 @@
     public void testSimulateTag()
         throws Exception
     {
-        ReleaseDescriptor descriptor = new ReleaseDescriptor();
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
         List<MavenProject> reactorProjects = createReactorProjects();
-        descriptor.setScmSourceUrl( "scm-url" );
+        builder.setScmSourceUrl( "scm-url" );
         MavenProject rootProject = ReleaseUtil.getRootProject( reactorProjects );
-        descriptor.setWorkingDirectory( getPath( rootProject.getFile().getParentFile() ) );
-        descriptor.setScmReleaseLabel( "release-label" );
+        builder.setWorkingDirectory( getPath( rootProject.getFile().getParentFile() ) );
+        builder.setScmReleaseLabel( "release-label" );
 
         ScmProvider scmProviderMock = mock( ScmProvider.class );
 
@@ -272,7 +273,7 @@
         stub.setScmProvider( scmProviderMock );
 
         // execute
-        phase.simulate( descriptor, new DefaultReleaseEnvironment(), reactorProjects );
+        phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
         // verify
         // no scmProvider invocation
@@ -283,12 +284,12 @@
     public void testSimulateTagNoReleaseLabel()
         throws Exception
     {
-        ReleaseDescriptor descriptor = new ReleaseDescriptor();
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
         List<MavenProject> reactorProjects = createReactorProjects();
 
         try
         {
-            phase.simulate( descriptor, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
             fail( "Should have thrown an exception" );
         }
         catch ( ReleaseFailureException e )
@@ -303,7 +304,7 @@
     {
         // prepare
         List<MavenProject> reactorProjects = createReactorProjects();
-        ReleaseDescriptor releaseDescriptor = createReleaseDescriptor();
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder();
 
         ScmManagerStub scmManagerStub = (ScmManagerStub) lookup( ScmManager.class );
         scmManagerStub.setException( new NoSuchScmProviderException( "..." )  );
@@ -311,7 +312,7 @@
         // execute
         try
         {
-            phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "Status check should have failed" );
         }
@@ -328,7 +329,7 @@
     {
         // prepare
         List<MavenProject> reactorProjects = createReactorProjects();
-        ReleaseDescriptor releaseDescriptor = createReleaseDescriptor();
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder();
 
         ScmManagerStub scmManagerStub = (ScmManagerStub) lookup( ScmManager.class );
         scmManagerStub.setException( new ScmRepositoryException( "..." )  );
@@ -336,7 +337,7 @@
         // execute
         try
         {
-            phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "Status check should have failed" );
         }
@@ -353,7 +354,7 @@
     {
         // prepare
         List<MavenProject> reactorProjects = createReactorProjects();
-        ReleaseDescriptor releaseDescriptor = createReleaseDescriptor();
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder();
 
         ScmProvider scmProviderMock = mock( ScmProvider.class );
         when( scmProviderMock.tag( isA( ScmRepository.class ), isA( ScmFileSet.class ), isA( String.class ),
@@ -365,7 +366,7 @@
         // execute
         try
         {
-            phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "Status check should have failed" );
         }
@@ -385,17 +386,17 @@
         throws Exception
     {
         List<MavenProject> reactorProjects = createReactorProjects();
-        ReleaseDescriptor releaseDescriptor = createReleaseDescriptor();
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder();
 
-        ScmManager scmManager = (ScmManager) lookup( ScmManager.class );
+        ScmManager scmManager = lookup( ScmManager.class );
         ScmProviderStub providerStub =
-            (ScmProviderStub) scmManager.getProviderByUrl( releaseDescriptor.getScmSourceUrl() );
+            (ScmProviderStub) scmManager.getProviderByUrl( "scm-url" );
 
         providerStub.setTagScmResult( new TagScmResult( "", "", "", false ) );
 
         try
         {
-            phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+            phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
 
             fail( "Commit should have failed" );
         }
@@ -411,13 +412,13 @@
         return createReactorProjects( "scm-commit/single-pom", "" );
     }
 
-    private static ReleaseDescriptor createReleaseDescriptor()
+    private static ReleaseDescriptorBuilder createReleaseDescriptorBuilder()
         throws IOException
     {
-        ReleaseDescriptor descriptor = new ReleaseDescriptor();
-        descriptor.setScmSourceUrl( "scm-url" );
-        descriptor.setScmReleaseLabel( "release-label" );
-        descriptor.setWorkingDirectory( getPath( getTestFile( "target/test/checkout" ) ) );
-        return descriptor;
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setScmSourceUrl( "scm-url" );
+        builder.setScmReleaseLabel( "release-label" );
+        builder.setWorkingDirectory( getPath( getTestFile( "target/test/checkout" ) ) );
+        return builder;
     }
 }
diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/scm/DefaultScmRepositoryConfiguratorTest.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/scm/DefaultScmRepositoryConfiguratorTest.java
index e57c23d..985e6cf 100644
--- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/scm/DefaultScmRepositoryConfiguratorTest.java
+++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/scm/DefaultScmRepositoryConfiguratorTest.java
@@ -27,7 +27,8 @@
 import org.apache.maven.scm.repository.ScmRepositoryException;
 import org.apache.maven.settings.Server;
 import org.apache.maven.settings.Settings;
-import org.apache.maven.shared.release.config.ReleaseDescriptor;
+import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder;
+import org.apache.maven.shared.release.config.ReleaseUtils;
 import org.codehaus.plexus.PlexusTestCase;
 
 /**
@@ -54,9 +55,9 @@
     public void testGetConfiguredRepository()
         throws ScmRepositoryException, NoSuchScmProviderException
     {
-        ReleaseDescriptor releaseDescriptor = createReleaseDescriptor();
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder();
 
-        ScmRepository repository = scmRepositoryConfigurator.getConfiguredRepository( releaseDescriptor, null );
+        ScmRepository repository = scmRepositoryConfigurator.getConfiguredRepository( ReleaseUtils.buildReleaseDescriptor( builder ), null );
 
         assertEquals( "check provider", "cvs", repository.getProvider() );
         assertEquals( "check username", "anoncvs", repository.getProviderRepository().getUser() );
@@ -66,9 +67,9 @@
     public void testGetConfiguredRepositoryWithUsernameAndPassword()
         throws ScmRepositoryException, NoSuchScmProviderException
     {
-        ReleaseDescriptor releaseDescriptor = createReleaseDescriptor( "username", "password" );
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( "username", "password" );
 
-        ScmRepository repository = scmRepositoryConfigurator.getConfiguredRepository( releaseDescriptor, null );
+        ScmRepository repository = scmRepositoryConfigurator.getConfiguredRepository( ReleaseUtils.buildReleaseDescriptor( builder ), null );
 
         assertEquals( "check username", "username", repository.getProviderRepository().getUser() );
         assertEquals( "check password", "password", repository.getProviderRepository().getPassword() );
@@ -77,11 +78,11 @@
     public void testGetConfiguredRepositoryWithTagBase()
         throws ScmRepositoryException, NoSuchScmProviderException
     {
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setScmSourceUrl( "scm:svn:http://localhost/home/svn/module/trunk" );
-        releaseDescriptor.setScmTagBase( "http://localhost/home/svn/module/tags" );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setScmSourceUrl( "scm:svn:http://localhost/home/svn/module/trunk" );
+        builder.setScmTagBase( "http://localhost/home/svn/module/tags" );
 
-        ScmRepository repository = scmRepositoryConfigurator.getConfiguredRepository( releaseDescriptor, null );
+        ScmRepository repository = scmRepositoryConfigurator.getConfiguredRepository( ReleaseUtils.buildReleaseDescriptor( builder ), null );
 
         SvnScmProviderRepository providerRepository = (SvnScmProviderRepository) repository.getProviderRepository();
         assertEquals( "check tag base", "http://localhost/home/svn/module/tags", providerRepository.getTagBase() );
@@ -99,10 +100,10 @@
         server.setPassphrase( "settings-passphrase" );
         settings.addServer( server );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setScmSourceUrl( "scm:cvs:pserver:anoncvs@localhost:/home/cvs:module" );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setScmSourceUrl( "scm:cvs:pserver:anoncvs@localhost:/home/cvs:module" );
 
-        ScmRepository repository = scmRepositoryConfigurator.getConfiguredRepository( releaseDescriptor, settings );
+        ScmRepository repository = scmRepositoryConfigurator.getConfiguredRepository( ReleaseUtils.buildReleaseDescriptor( builder ), settings );
 
         ScmProviderRepositoryWithHost providerRepository =
             (ScmProviderRepositoryWithHost) repository.getProviderRepository();
@@ -125,10 +126,10 @@
         server.setPassphrase( "{7zK9P8hNVeUHbTsjiA/vnOs0zUXbND+9MBNPvdvl+x4=}" );
         settings.addServer( server );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setScmSourceUrl( "scm:svn:svn://localhost/repo" );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setScmSourceUrl( "scm:svn:svn://localhost/repo" );
 
-        ScmRepository repository = scmRepositoryConfigurator.getConfiguredRepository( releaseDescriptor, settings );
+        ScmRepository repository = scmRepositoryConfigurator.getConfiguredRepository( ReleaseUtils.buildReleaseDescriptor( builder ), settings );
 
         ScmProviderRepositoryWithHost providerRepository =
             (ScmProviderRepositoryWithHost) repository.getProviderRepository();
@@ -141,12 +142,12 @@
     public void testGetConfiguredRepositoryInvalidScmUrl()
         throws Exception
     {
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setScmSourceUrl( "scm-url" );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setScmSourceUrl( "scm-url" );
 
         try
         {
-            scmRepositoryConfigurator.getConfiguredRepository( releaseDescriptor, null );
+            scmRepositoryConfigurator.getConfiguredRepository( ReleaseUtils.buildReleaseDescriptor( builder ), null );
 
             fail( "Expected failure to get a repository with an invalid SCM URL" );
         }
@@ -159,12 +160,12 @@
     public void testGetConfiguredRepositoryInvalidScmProvider()
         throws ScmRepositoryException
     {
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setScmSourceUrl( "scm:url:" );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setScmSourceUrl( "scm:url:" );
 
         try
         {
-            scmRepositoryConfigurator.getConfiguredRepository( releaseDescriptor, null );
+            scmRepositoryConfigurator.getConfiguredRepository( ReleaseUtils.buildReleaseDescriptor( builder ), null );
 
             fail( "Expected failure to get a repository with an invalid SCM URL" );
         }
@@ -177,12 +178,12 @@
     public void testGetConfiguredRepositoryInvalidScmUrlParameters()
         throws NoSuchScmProviderException
     {
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setScmSourceUrl( "scm:cvs:" );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setScmSourceUrl( "scm:cvs:" );
 
         try
         {
-            scmRepositoryConfigurator.getConfiguredRepository( releaseDescriptor, null );
+            scmRepositoryConfigurator.getConfiguredRepository( ReleaseUtils.buildReleaseDescriptor( builder ), null );
 
             fail( "Expected failure to get a repository with an invalid SCM URL" );
         }
@@ -195,26 +196,26 @@
     public void testGetRepositoryProvider()
         throws ScmRepositoryException, NoSuchScmProviderException
     {
-        ReleaseDescriptor releaseDescriptor = createReleaseDescriptor();
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder();
 
-        ScmRepository repository = scmRepositoryConfigurator.getConfiguredRepository( releaseDescriptor, null );
+        ScmRepository repository = scmRepositoryConfigurator.getConfiguredRepository( ReleaseUtils.buildReleaseDescriptor( builder ), null );
 
         ScmProvider provider = scmRepositoryConfigurator.getRepositoryProvider( repository );
         assertEquals( "Check SCM provider", "cvs", provider.getScmType() );
     }
 
-    private static ReleaseDescriptor createReleaseDescriptor()
+    private static ReleaseDescriptorBuilder createReleaseDescriptorBuilder()
     {
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setScmSourceUrl( "scm:cvs:pserver:anoncvs@localhost:/home/cvs:module" );
-        return releaseDescriptor;
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setScmSourceUrl( "scm:cvs:pserver:anoncvs@localhost:/home/cvs:module" );
+        return builder;
     }
 
-    private static ReleaseDescriptor createReleaseDescriptor( String username, String password )
+    private static ReleaseDescriptorBuilder createReleaseDescriptorBuilder( String username, String password )
     {
-        ReleaseDescriptor releaseDescriptor = createReleaseDescriptor();
-        releaseDescriptor.setScmUsername( username );
-        releaseDescriptor.setScmPassword( password );
-        return releaseDescriptor;
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder();
+        builder.setScmUsername( username );
+        builder.setScmPassword( password );
+        return builder;
     }
 }
diff --git a/maven-release-manager/src/test/resources/projects/rewrite-for-development/basic-pom-inherited-scm/pom.xml b/maven-release-manager/src/test/resources/projects/rewrite-for-development/basic-pom-inherited-scm/pom.xml
index 95ed5b8..ff02627 100644
--- a/maven-release-manager/src/test/resources/projects/rewrite-for-development/basic-pom-inherited-scm/pom.xml
+++ b/maven-release-manager/src/test/resources/projects/rewrite-for-development/basic-pom-inherited-scm/pom.xml
@@ -37,9 +37,4 @@
     <module>subproject1</module>
   </modules>
 
-  <scm>
-    <connection>scm:svn:file://localhost/tmp/scm-repo/tags/release-label</connection>
-    <developerConnection>scm:svn:file://localhost/tmp/scm-repo/tags/release-label</developerConnection>
-    <url>file://localhost/tmp/scm-repo/tags/release-label</url>
-  </scm>
 </project>
\ No newline at end of file
diff --git a/maven-release-plugin/src/it/projects/prepare/MRELEASE-420/verify.groovy b/maven-release-plugin/src/it/projects/prepare/MRELEASE-420/verify.groovy
index bc7b56b..a41f9c3 100644
--- a/maven-release-plugin/src/it/projects/prepare/MRELEASE-420/verify.groovy
+++ b/maven-release-plugin/src/it/projects/prepare/MRELEASE-420/verify.groovy
@@ -22,4 +22,3 @@
 assert releaseProperties.exists()
 
 assert 1 == releaseProperties.getText().count("scm.id=it-server")
-assert 1 == releaseProperties.getText().count("project.scm.org.apache.maven.plugin.release.its\\:mrelease-420.id=it-server")
diff --git a/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/AbstractReleaseMojo.java b/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/AbstractReleaseMojo.java
index f6242ed..7dda662 100644
--- a/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/AbstractReleaseMojo.java
+++ b/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/AbstractReleaseMojo.java
@@ -23,6 +23,7 @@
 import java.util.Iterator;
 import java.util.List;
 
+import org.apache.maven.artifact.ArtifactUtils;
 import org.apache.maven.execution.MavenSession;
 import org.apache.maven.plugin.AbstractMojo;
 import org.apache.maven.plugins.annotations.Component;
@@ -30,7 +31,7 @@
 import org.apache.maven.project.MavenProject;
 import org.apache.maven.settings.Settings;
 import org.apache.maven.shared.release.ReleaseManager;
-import org.apache.maven.shared.release.config.ReleaseDescriptor;
+import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder;
 import org.apache.maven.shared.release.env.DefaultReleaseEnvironment;
 import org.apache.maven.shared.release.env.ReleaseEnvironment;
 import org.codehaus.plexus.util.StringUtils;
@@ -149,16 +150,22 @@
      *
      * @return The release descriptor, never <code>null</code>.
      */
-    protected ReleaseDescriptor createReleaseDescriptor()
+    protected ReleaseDescriptorBuilder createReleaseDescriptor()
     {
-        ReleaseDescriptor descriptor = new ReleaseDescriptor();
-
+        ReleaseDescriptorBuilder descriptor = new ReleaseDescriptorBuilder();
+        
         descriptor.setInteractive( settings.isInteractiveMode() );
 
         descriptor.setWorkingDirectory( basedir.getAbsolutePath() );
 
         descriptor.setPomFileName( pomFileName );
 
+        for ( MavenProject project : reactorProjects )
+        {
+            String versionlessKey = ArtifactUtils.versionlessKey( project.getGroupId(), project.getArtifactId() );
+            descriptor.putOriginalVersion( versionlessKey, project.getVersion() );
+        }
+
         List<String> profileIds = session.getRequest().getActiveProfiles();
         String additionalProfiles = getAdditionalProfiles();
 
@@ -270,25 +277,4 @@
             arguments = argument;
         }
     }
-
-    /**
-     * This method takes some of the release configuration picked up from the command line system properties and copies
-     * it into the release config object.
-     *
-     * @param config The release configuration to merge the system properties into, must not be <code>null</code>.
-     * @param sysPropertiesConfig The configuration from the system properties to merge in, must not be
-     *            <code>null</code>.
-     */
-    protected void mergeCommandLineConfig( ReleaseDescriptor config, ReleaseDescriptor sysPropertiesConfig )
-    {
-        // If the user specifies versions, these should override the existing versions
-        if ( sysPropertiesConfig.getReleaseVersions() != null )
-        {
-            config.getReleaseVersions().putAll( sysPropertiesConfig.getReleaseVersions() );
-        }
-        if ( sysPropertiesConfig.getDevelopmentVersions() != null )
-        {
-            config.getDevelopmentVersions().putAll( sysPropertiesConfig.getDevelopmentVersions() );
-        }
-    }
 }
diff --git a/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/AbstractScmReleaseMojo.java b/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/AbstractScmReleaseMojo.java
index b57aab4..d75064e 100644
--- a/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/AbstractScmReleaseMojo.java
+++ b/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/AbstractScmReleaseMojo.java
@@ -21,12 +21,15 @@
 
 import java.util.Map;
 
+import org.apache.maven.artifact.ArtifactUtils;
+import org.apache.maven.model.Scm;
 import org.apache.maven.plugin.MojoExecutionException;
 import org.apache.maven.plugin.MojoFailureException;
 import org.apache.maven.plugins.annotations.Component;
 import org.apache.maven.plugins.annotations.Parameter;
+import org.apache.maven.project.MavenProject;
 import org.apache.maven.scm.manager.ScmManager;
-import org.apache.maven.shared.release.config.ReleaseDescriptor;
+import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder;
 
 /**
  * Abstract Mojo containing SCM parameters
@@ -127,9 +130,9 @@
     }
 
     @Override
-    protected ReleaseDescriptor createReleaseDescriptor()
+    protected ReleaseDescriptorBuilder createReleaseDescriptor()
     {
-        ReleaseDescriptor descriptor = super.createReleaseDescriptor();
+        ReleaseDescriptorBuilder descriptor = super.createReleaseDescriptor();
 
         descriptor.setScmPassword( password );
         descriptor.setScmReleaseLabel( tag );
@@ -139,7 +142,51 @@
         descriptor.setScmCommentPrefix( scmCommentPrefix );
 
         descriptor.setPushChanges( pushChanges );
+        
+        if ( project.getScm() != null )
+        {
+            if ( project.getScm().getDeveloperConnection() != null )
+            {
+                descriptor.setScmSourceUrl( project.getScm().getDeveloperConnection() );
+            }
+            else if ( project.getScm().getConnection() != null )
+            {
+                descriptor.setScmSourceUrl( project.getScm().getConnection() );
+            }
+        }
+        
+        // As long as Scm.getId() does not exist, read it as a property
+        descriptor.setScmId( project.getProperties().getProperty( "project.scm.id" ) );
+        
+        for ( MavenProject reactorProject : session.getProjects() )
+        {
+            if ( reactorProject.getScm() != null )
+            {
+                String projectId =
+                    ArtifactUtils.versionlessKey( reactorProject.getGroupId(), reactorProject.getArtifactId() );
+                
+                descriptor.addOriginalScmInfo( projectId, buildScm( project ) );
+            }
+        }
 
         return descriptor;
     }
+    
+    protected Scm buildScm( MavenProject project )
+    {
+        Scm scm;
+        if ( project.getOriginalModel().getScm() == null )
+        {
+            scm = null;
+        }
+        else
+        {
+            scm = new Scm();
+            scm.setConnection( project.getOriginalModel().getScm().getConnection() );
+            scm.setDeveloperConnection( project.getOriginalModel().getScm().getDeveloperConnection() );
+            scm.setTag( project.getOriginalModel().getScm().getTag() );
+            scm.setUrl( project.getOriginalModel().getScm().getUrl() );
+        }
+        return scm;
+    }
 }
diff --git a/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/BranchReleaseMojo.java b/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/BranchReleaseMojo.java
index 14829ea..4378d24 100644
--- a/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/BranchReleaseMojo.java
+++ b/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/BranchReleaseMojo.java
@@ -28,8 +28,7 @@
 import org.apache.maven.shared.release.ReleaseBranchRequest;
 import org.apache.maven.shared.release.ReleaseExecutionException;
 import org.apache.maven.shared.release.ReleaseFailureException;
-import org.apache.maven.shared.release.config.ReleaseDescriptor;
-import org.apache.maven.shared.release.config.ReleaseUtils;
+import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder;
 
 /**
  * Branch a project in SCM, using the same steps as the <tt>release:prepare</tt> goal, creating a branch instead of a
@@ -217,7 +216,7 @@
     {
         super.execute();
 
-        ReleaseDescriptor config = createReleaseDescriptor();
+        final ReleaseDescriptorBuilder config = createReleaseDescriptor();
         config.setAddSchema( addSchema );
         config.setScmUseEditMode( useEditMode );
         config.setUpdateDependencies( updateDependencies );
@@ -235,11 +234,6 @@
         config.setProjectVersionPolicyId( projectVersionPolicyId );
         config.setProjectNamingPolicyId( projectBranchNamingPolicyId );
 
-        // Create a config containing values from the session properties (ie command line properties with cli).
-        ReleaseDescriptor sysPropertiesConfig
-                = ReleaseUtils.copyPropertiesToReleaseDescriptor( session.getExecutionProperties() );
-        mergeCommandLineConfig( config, sysPropertiesConfig );
-
         if ( checkModificationExcludeList != null )
         {
             checkModificationExcludes = checkModificationExcludeList.replaceAll( "\\s", "" ).split( "," );
@@ -253,10 +247,11 @@
         try
         {
             ReleaseBranchRequest branchRequest = new ReleaseBranchRequest();
-            branchRequest.setReleaseDescriptor( config );
+            branchRequest.setReleaseDescriptorBuilder( config );
             branchRequest.setReleaseEnvironment( getReleaseEnvironment() );
             branchRequest.setReactorProjects( getReactorProjects() );
             branchRequest.setDryRun( dryRun );
+            branchRequest.setUserProperties( session.getUserProperties() );
 
             releaseManager.branch( branchRequest );
         }
diff --git a/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/CleanReleaseMojo.java b/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/CleanReleaseMojo.java
index 186785b..3de5857 100644
--- a/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/CleanReleaseMojo.java
+++ b/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/CleanReleaseMojo.java
@@ -24,7 +24,7 @@
 import org.apache.maven.plugins.annotations.Mojo;
 import org.apache.maven.shared.release.ReleaseCleanRequest;
 import org.apache.maven.shared.release.ReleaseFailureException;
-import org.apache.maven.shared.release.config.ReleaseDescriptor;
+import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder;
 
 /**
  * Clean up after a release preparation. This is done automatically after a successful <tt>release:perform</tt>,
@@ -44,11 +44,11 @@
     public void execute()
         throws MojoExecutionException, MojoFailureException
     {
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
+        ReleaseDescriptorBuilder releaseDescriptor = new ReleaseDescriptorBuilder();
         releaseDescriptor.setWorkingDirectory( getBasedir().getAbsolutePath() );
 
         ReleaseCleanRequest cleanRequest = new ReleaseCleanRequest();
-        cleanRequest.setReleaseDescriptor( releaseDescriptor );
+        cleanRequest.setReleaseDescriptorBuilder( releaseDescriptor );
         cleanRequest.setReactorProjects( getReactorProjects() );
         
         try
diff --git a/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/PerformReleaseMojo.java b/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/PerformReleaseMojo.java
index 4826f78..9abd94f 100644
--- a/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/PerformReleaseMojo.java
+++ b/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/PerformReleaseMojo.java
@@ -31,7 +31,7 @@
 import org.apache.maven.shared.release.ReleaseExecutionException;
 import org.apache.maven.shared.release.ReleaseFailureException;
 import org.apache.maven.shared.release.ReleasePerformRequest;
-import org.apache.maven.shared.release.config.ReleaseDescriptor;
+import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder;
 import org.codehaus.plexus.util.StringUtils;
 
 /**
@@ -166,7 +166,7 @@
         {
             setDeploymentRepository();
             // Note that the working directory here is not the same as in the release configuration, so don't reuse that
-            ReleaseDescriptor releaseDescriptor = createReleaseDescriptor();
+            ReleaseDescriptorBuilder releaseDescriptor = createReleaseDescriptor();
             if ( connectionUrl != null )
             {
                 releaseDescriptor.setScmSourceUrl( connectionUrl );
@@ -191,7 +191,7 @@
             releaseDescriptor.setPerformGoals( goals );
 
             ReleasePerformRequest performRequest  = new ReleasePerformRequest();
-            performRequest.setReleaseDescriptor( releaseDescriptor );
+            performRequest.setReleaseDescriptorBuilder( releaseDescriptor );
             performRequest.setReleaseEnvironment( getReleaseEnvironment() );
             performRequest.setReactorProjects( getReactorProjects() );
             performRequest.setDryRun( dryRun );
diff --git a/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/PrepareReleaseMojo.java b/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/PrepareReleaseMojo.java
index a73962d..196f727 100644
--- a/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/PrepareReleaseMojo.java
+++ b/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/PrepareReleaseMojo.java
@@ -28,8 +28,7 @@
 import org.apache.maven.shared.release.ReleaseExecutionException;
 import org.apache.maven.shared.release.ReleaseFailureException;
 import org.apache.maven.shared.release.ReleasePrepareRequest;
-import org.apache.maven.shared.release.config.ReleaseDescriptor;
-import org.apache.maven.shared.release.config.ReleaseUtils;
+import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder;
 
 /**
  * Prepare for a release in SCM. Steps through several phases to ensure the POM is ready to be released and then
@@ -259,7 +258,7 @@
         // above
         super.execute();
 
-        ReleaseDescriptor config = createReleaseDescriptor();
+        final ReleaseDescriptorBuilder config = createReleaseDescriptor();
         config.setAddSchema( addSchema );
         config.setGenerateReleasePoms( generateReleasePoms );
         config.setScmUseEditMode( useEditMode );
@@ -288,18 +287,14 @@
         {
             config.setCheckModificationExcludes( Arrays.asList( checkModificationExcludes ) );
         }
-
-        // Create a config containing values from the session properties (ie command line properties with cli).
-        ReleaseDescriptor sysPropertiesConfig =
-            ReleaseUtils.copyPropertiesToReleaseDescriptor( session.getExecutionProperties() );
-        mergeCommandLineConfig( config, sysPropertiesConfig );
         
         ReleasePrepareRequest prepareRequest = new ReleasePrepareRequest();
-        prepareRequest.setReleaseDescriptor( config );
+        prepareRequest.setReleaseDescriptorBuilder( config );
         prepareRequest.setReleaseEnvironment( getReleaseEnvironment() );
         prepareRequest.setReactorProjects( getReactorProjects() );
         prepareRequest.setResume( resume );
         prepareRequest.setDryRun( dryRun );
+        prepareRequest.setUserProperties( session.getUserProperties() );
 
         try
         {
diff --git a/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/RollbackReleaseMojo.java b/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/RollbackReleaseMojo.java
index cefcbbe..970dad6 100644
--- a/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/RollbackReleaseMojo.java
+++ b/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/RollbackReleaseMojo.java
@@ -49,7 +49,7 @@
         try
         {
             ReleaseRollbackRequest rollbackRequest = new ReleaseRollbackRequest();
-            rollbackRequest.setReleaseDescriptor( createReleaseDescriptor() );
+            rollbackRequest.setReleaseDescriptorBuilder( createReleaseDescriptor() );
             rollbackRequest.setReleaseEnvironment( getReleaseEnvironment() );
             rollbackRequest.setReactorProjects( getReactorProjects()  );
             
diff --git a/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/UpdateVersionsMojo.java b/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/UpdateVersionsMojo.java
index 242ed2b..2aa1e8e 100644
--- a/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/UpdateVersionsMojo.java
+++ b/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/UpdateVersionsMojo.java
@@ -27,8 +27,7 @@
 import org.apache.maven.shared.release.ReleaseExecutionException;
 import org.apache.maven.shared.release.ReleaseFailureException;
 import org.apache.maven.shared.release.ReleaseUpdateVersionsRequest;
-import org.apache.maven.shared.release.config.ReleaseDescriptor;
-import org.apache.maven.shared.release.config.ReleaseUtils;
+import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder;
 
 /**
  * Update the POM versions for a project. This performs the normal version updates of the <tt>release:prepare</tt> goal
@@ -98,7 +97,7 @@
     public void execute()
         throws MojoExecutionException, MojoFailureException
     {
-        ReleaseDescriptor config = createReleaseDescriptor();
+        final ReleaseDescriptorBuilder config = createReleaseDescriptor();
         config.setAddSchema( addSchema );
         config.setAutoVersionSubmodules( autoVersionSubmodules );
         config.setDefaultDevelopmentVersion( developmentVersion );
@@ -109,17 +108,13 @@
         config.addOriginalScmInfo( ArtifactUtils.versionlessKey( project.getGroupId(), project.getArtifactId() ),
                                    project.getScm() );
 
-        // Create a config containing values from the session properties (ie command line properties with cli).
-        ReleaseDescriptor sysPropertiesConfig =
-            ReleaseUtils.copyPropertiesToReleaseDescriptor( session.getExecutionProperties() );
-        mergeCommandLineConfig( config, sysPropertiesConfig );
-
         try
         {
             ReleaseUpdateVersionsRequest updateVersionsRequest = new ReleaseUpdateVersionsRequest();
-            updateVersionsRequest.setReleaseDescriptor( config );
+            updateVersionsRequest.setReleaseDescriptorBuilder( config );
             updateVersionsRequest.setReleaseEnvironment( getReleaseEnvironment() );
             updateVersionsRequest.setReactorProjects( getReactorProjects() );
+            updateVersionsRequest.setUserProperties( session.getUserProperties() );
 
             releaseManager.updateVersions( updateVersionsRequest );
         }
diff --git a/maven-release-plugin/src/test/java/org/apache/maven/plugins/release/CleanReleaseMojoTest.java b/maven-release-plugin/src/test/java/org/apache/maven/plugins/release/CleanReleaseMojoTest.java
index 2a972c3..d80848a 100644
--- a/maven-release-plugin/src/test/java/org/apache/maven/plugins/release/CleanReleaseMojoTest.java
+++ b/maven-release-plugin/src/test/java/org/apache/maven/plugins/release/CleanReleaseMojoTest.java
@@ -68,8 +68,6 @@
         // verify
         verify( mock ).clean( request.capture() );
         
-        assertEquals( workingDirectory.getAbsolutePath(),
-                      request.getValue().getReleaseDescriptor().getWorkingDirectory() );
         assertEquals( mojo.getReactorProjects(), request.getValue().getReactorProjects() );
         
         verifyNoMoreInteractions( mock );
diff --git a/maven-release-plugin/src/test/java/org/apache/maven/plugins/release/PerformReleaseMojoTest.java b/maven-release-plugin/src/test/java/org/apache/maven/plugins/release/PerformReleaseMojoTest.java
index 09b5a52..16fc026 100644
--- a/maven-release-plugin/src/test/java/org/apache/maven/plugins/release/PerformReleaseMojoTest.java
+++ b/maven-release-plugin/src/test/java/org/apache/maven/plugins/release/PerformReleaseMojoTest.java
@@ -27,6 +27,7 @@
 
 import java.io.File;
 import java.util.Arrays;
+import java.util.List;
 
 import org.apache.maven.execution.MavenSession;
 import org.apache.maven.model.DistributionManagement;
@@ -40,7 +41,7 @@
 import org.apache.maven.shared.release.ReleaseFailureException;
 import org.apache.maven.shared.release.ReleaseManager;
 import org.apache.maven.shared.release.ReleasePerformRequest;
-import org.apache.maven.shared.release.config.ReleaseDescriptor;
+import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder;
 import org.mockito.ArgumentCaptor;
 
 /**
@@ -58,11 +59,11 @@
     {
         PerformReleaseMojo mojo = getMojoWithProjectSite( "perform.xml" );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setWorkingDirectory( workingDirectory.getAbsolutePath() );
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( mojo );
+        builder.setWorkingDirectory( workingDirectory.getAbsolutePath() );
         File checkoutDirectory = getTestFile( "target/checkout" );
-        releaseDescriptor.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
-        releaseDescriptor.setPerformGoals( "deploy site-deploy" );
+        builder.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
+        builder.setPerformGoals( "deploy site-deploy" );
 
         ReleaseManager mock = mock( ReleaseManager.class );
         mojo.setReleaseManager( mock );
@@ -73,9 +74,9 @@
         // verify
         ArgumentCaptor<ReleasePerformRequest> argument = ArgumentCaptor.forClass(ReleasePerformRequest.class);
         verify( mock ).perform( argument.capture() );
-        assertEquals( releaseDescriptor, argument.getValue().getReleaseDescriptor() );
+        assertNotNull( argument.getValue().getReleaseDescriptorBuilder() );
         assertNotNull( argument.getValue().getReleaseEnvironment()  );
-        assertNull( argument.getValue().getReactorProjects() );
+        assertNotNull( argument.getValue().getReactorProjects() );
         assertEquals( Boolean.FALSE, argument.getValue().getDryRun() );
         verifyNoMoreInteractions( mock );
     }
@@ -85,12 +86,12 @@
     {
         PerformReleaseMojo mojo = getMojoWithProjectSite( "perform-with-flat-structure.xml" );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setWorkingDirectory( workingDirectory.getAbsolutePath() );
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( mojo );
+        builder.setWorkingDirectory( workingDirectory.getAbsolutePath() );
         File checkoutDirectory = getTestFile( "target/checkout" );
-        releaseDescriptor.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
-        releaseDescriptor.setPerformGoals( "deploy" );
-        releaseDescriptor.setScmSourceUrl( "scm:svn:file://localhost/target/svnroot/flat-multi-module/trunk/root-project" );
+        builder.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
+        builder.setPerformGoals( "deploy" );
+        builder.setScmSourceUrl( "scm:svn:file://localhost/target/svnroot/flat-multi-module/trunk/root-project" );
 
         ReleaseManager mock = mock( ReleaseManager.class );
         mojo.setReleaseManager( mock );
@@ -101,9 +102,9 @@
         // verify
         ArgumentCaptor<ReleasePerformRequest> argument = ArgumentCaptor.forClass(ReleasePerformRequest.class);
         verify( mock ).perform( argument.capture() );
-        assertEquals( releaseDescriptor, argument.getValue().getReleaseDescriptor() );
+        assertNotNull( argument.getValue().getReleaseDescriptorBuilder() );
         assertNotNull( argument.getValue().getReleaseEnvironment()  );
-        assertNull( argument.getValue().getReactorProjects() );
+        assertNotNull( argument.getValue().getReactorProjects() );
         assertEquals( Boolean.FALSE, argument.getValue().getDryRun() );
         verifyNoMoreInteractions( mock );
     }
@@ -120,11 +121,11 @@
         MavenProject project = (MavenProject) getVariableValueFromObject( mojo, "project" );
         setVariableValueToObject( mojo, "session", newMavenSession( project ) );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setWorkingDirectory( workingDirectory.getAbsolutePath() );
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( mojo );
+        builder.setWorkingDirectory( workingDirectory.getAbsolutePath() );
         File checkoutDirectory = getTestFile( "target/checkout" );
-        releaseDescriptor.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
-        releaseDescriptor.setPerformGoals( "deploy" );
+        builder.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
+        builder.setPerformGoals( "deploy" );
 
         ReleaseManager mock = mock( ReleaseManager.class );
         mojo.setReleaseManager( mock );
@@ -135,9 +136,9 @@
         // verify
         ArgumentCaptor<ReleasePerformRequest> argument = ArgumentCaptor.forClass(ReleasePerformRequest.class);
         verify( mock ).perform( argument.capture() );
-        assertEquals( releaseDescriptor, argument.getValue().getReleaseDescriptor() );
+        assertNotNull( argument.getValue().getReleaseDescriptorBuilder() );
         assertNotNull( argument.getValue().getReleaseEnvironment()  );
-        assertNull( argument.getValue().getReactorProjects() );
+        assertNotNull( argument.getValue().getReactorProjects() );
         assertEquals( Boolean.FALSE, argument.getValue().getDryRun() );
         verifyNoMoreInteractions( mock );
     }
@@ -163,11 +164,11 @@
     {
         PerformReleaseMojo mojo = getMojoWithProjectSite( "perform.xml" );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setWorkingDirectory( workingDirectory.getAbsolutePath() );
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( mojo );
+        builder.setWorkingDirectory( workingDirectory.getAbsolutePath() );
         File checkoutDirectory = getTestFile( "target/checkout" );
-        releaseDescriptor.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
-        releaseDescriptor.setPerformGoals( "deploy site-deploy" );
+        builder.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
+        builder.setPerformGoals( "deploy site-deploy" );
 
         ReleaseManager mock = mock( ReleaseManager.class );
         doThrow( new ReleaseExecutionException( "..." ) ).when( mock ).perform( isA( ReleasePerformRequest.class ) );
@@ -188,9 +189,9 @@
         // verify
         ArgumentCaptor<ReleasePerformRequest> argument = ArgumentCaptor.forClass(ReleasePerformRequest.class);
         verify( mock ).perform( argument.capture() );
-        assertEquals( releaseDescriptor, argument.getValue().getReleaseDescriptor() );
+        assertNotNull( argument.getValue().getReleaseDescriptorBuilder() );
         assertNotNull( argument.getValue().getReleaseEnvironment()  );
-        assertNull( argument.getValue().getReactorProjects() );
+        assertNotNull( argument.getValue().getReactorProjects() );
         assertEquals( Boolean.FALSE, argument.getValue().getDryRun() );
 
         verifyNoMoreInteractions( mock );
@@ -201,11 +202,11 @@
     {
         PerformReleaseMojo mojo = getMojoWithProjectSite( "perform.xml" );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setWorkingDirectory( workingDirectory.getAbsolutePath() );
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( mojo );
+        builder.setWorkingDirectory( workingDirectory.getAbsolutePath() );
         File checkoutDirectory = getTestFile( "target/checkout" );
-        releaseDescriptor.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
-        releaseDescriptor.setPerformGoals( "deploy site-deploy" );
+        builder.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
+        builder.setPerformGoals( "deploy site-deploy" );
 
         ReleaseManager mock = mock( ReleaseManager.class );
         ReleaseFailureException cause = new ReleaseFailureException( "..." );
@@ -228,9 +229,9 @@
         // verify
         ArgumentCaptor<ReleasePerformRequest> argument = ArgumentCaptor.forClass(ReleasePerformRequest.class);
         verify( mock ).perform( argument.capture() );
-        assertEquals( releaseDescriptor, argument.getValue().getReleaseDescriptor() );
+        assertNotNull( argument.getValue().getReleaseDescriptorBuilder() );
         assertNotNull( argument.getValue().getReleaseEnvironment()  );
-        assertNull( argument.getValue().getReactorProjects() );
+        assertNotNull( argument.getValue().getReactorProjects() );
         assertEquals( Boolean.FALSE, argument.getValue().getDryRun() );
 
         verifyNoMoreInteractions( mock );
@@ -241,12 +242,12 @@
     {
         PerformReleaseMojo mojo = getMojoWithProjectSite( "perform-with-scm.xml" );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setWorkingDirectory( workingDirectory.getAbsolutePath() );
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( mojo );
+        builder.setWorkingDirectory( workingDirectory.getAbsolutePath() );
         File checkoutDirectory = getTestFile( "target/checkout" );
-        releaseDescriptor.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
-        releaseDescriptor.setPerformGoals( "deploy site-deploy" );
-        releaseDescriptor.setScmSourceUrl( "scm-url" );
+        builder.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
+        builder.setPerformGoals( "deploy site-deploy" );
+        builder.setScmSourceUrl( "scm-url" );
 
         ReleaseManager mock = mock( ReleaseManager.class );
         mojo.setReleaseManager( mock );
@@ -257,9 +258,9 @@
         // verify
         ArgumentCaptor<ReleasePerformRequest> argument = ArgumentCaptor.forClass(ReleasePerformRequest.class);
         verify( mock ).perform( argument.capture() );
-        assertEquals( releaseDescriptor, argument.getValue().getReleaseDescriptor() );
+        assertNotNull( argument.getValue().getReleaseDescriptorBuilder() );
         assertNotNull( argument.getValue().getReleaseEnvironment()  );
-        assertNull( argument.getValue().getReactorProjects() );
+        assertNotNull( argument.getValue().getReactorProjects() );
         assertEquals( Boolean.FALSE, argument.getValue().getDryRun() );
 
         verifyNoMoreInteractions( mock );
@@ -270,12 +271,12 @@
     {
         PerformReleaseMojo mojo = getMojoWithProjectSite( "perform.xml" );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setWorkingDirectory( workingDirectory.getAbsolutePath() );
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( mojo );
+        builder.setWorkingDirectory( workingDirectory.getAbsolutePath() );
         File checkoutDirectory = getTestFile( "target/checkout" );
-        releaseDescriptor.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
-        releaseDescriptor.setPerformGoals( "deploy site-deploy" );
-        releaseDescriptor.setAdditionalArguments( "-P prof1,2prof" );
+        builder.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
+        builder.setPerformGoals( "deploy site-deploy" );
+        builder.setAdditionalArguments( "-P prof1,2prof" );
 
         MavenSession session = (MavenSession) getVariableValueFromObject( mojo, "session");
         Profile profile1 = new Profile();
@@ -295,9 +296,9 @@
         // verify
         ArgumentCaptor<ReleasePerformRequest> argument = ArgumentCaptor.forClass(ReleasePerformRequest.class);
         verify( mock ).perform( argument.capture() );
-        assertEquals( releaseDescriptor, argument.getValue().getReleaseDescriptor() );
+        assertNotNull( argument.getValue().getReleaseDescriptorBuilder() );
         assertNotNull( argument.getValue().getReleaseEnvironment()  );
-        assertNull( argument.getValue().getReactorProjects() );
+        assertNotNull( argument.getValue().getReactorProjects() );
         assertEquals( Boolean.FALSE, argument.getValue().getDryRun() );
 
         verifyNoMoreInteractions( mock );
@@ -308,12 +309,12 @@
     {
         PerformReleaseMojo mojo = getMojoWithProjectSite( "perform-with-args.xml" );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setWorkingDirectory( workingDirectory.getAbsolutePath() );
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( mojo );
+        builder.setWorkingDirectory( workingDirectory.getAbsolutePath() );
         File checkoutDirectory = getTestFile( "target/checkout" );
-        releaseDescriptor.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
-        releaseDescriptor.setPerformGoals( "deploy site-deploy" );
-        releaseDescriptor.setAdditionalArguments( "-Dmaven.test.skip=true -P prof1,2prof" );
+        builder.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
+        builder.setPerformGoals( "deploy site-deploy" );
+        builder.setAdditionalArguments( "-Dmaven.test.skip=true -P prof1,2prof" );
 
         MavenSession session = (MavenSession) getVariableValueFromObject( mojo, "session");
         Profile profile1 = new Profile();
@@ -333,9 +334,9 @@
         // verify
         ArgumentCaptor<ReleasePerformRequest> argument = ArgumentCaptor.forClass(ReleasePerformRequest.class);
         verify( mock ).perform( argument.capture() );
-        assertEquals( releaseDescriptor, argument.getValue().getReleaseDescriptor() );
+        assertNotNull( argument.getValue().getReleaseDescriptorBuilder() );
         assertNotNull( argument.getValue().getReleaseEnvironment()  );
-        assertNull( argument.getValue().getReactorProjects() );
+        assertNotNull( argument.getValue().getReactorProjects() );
         assertEquals( Boolean.FALSE, argument.getValue().getDryRun() );
 
         verifyNoMoreInteractions( mock );
@@ -346,11 +347,11 @@
     {
 	    PerformReleaseMojo mojo = getMojoWithProjectSite( "perform-with-multiline-goals.xml" );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setWorkingDirectory( workingDirectory.getAbsolutePath() );
+        ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( mojo );
+        builder.setWorkingDirectory( workingDirectory.getAbsolutePath() );
         File checkoutDirectory = getTestFile( "target/checkout" );
-        releaseDescriptor.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
-        releaseDescriptor.setPerformGoals( "deploy site-deploy" );
+        builder.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
+        builder.setPerformGoals( "deploy site-deploy" );
 
         ReleaseManager mock = mock( ReleaseManager.class );
         mojo.setReleaseManager( mock );
@@ -361,14 +362,28 @@
         // verify
         ArgumentCaptor<ReleasePerformRequest> argument = ArgumentCaptor.forClass(ReleasePerformRequest.class);
         verify( mock ).perform( argument.capture() );
-        assertEquals( releaseDescriptor, argument.getValue().getReleaseDescriptor() );
+        assertNotNull( argument.getValue().getReleaseDescriptorBuilder() );
         assertNotNull( argument.getValue().getReleaseEnvironment()  );
-        assertNull( argument.getValue().getReactorProjects() );
+        assertNotNull( argument.getValue().getReactorProjects() );
         assertEquals( Boolean.FALSE, argument.getValue().getDryRun() );
 
         verifyNoMoreInteractions( mock );
     }
 
+    private ReleaseDescriptorBuilder createReleaseDescriptorBuilder( PerformReleaseMojo mojo ) throws Exception
+    {
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        
+        @SuppressWarnings( "unchecked" )
+        List<MavenProject> reactorProjects = (List<MavenProject>) getVariableValueFromObject( mojo, "reactorProjects" );
+        
+        for ( MavenProject project : reactorProjects )
+        {
+            builder.putOriginalVersion( project.getGroupId() + ':' + project.getArtifactId(), project.getVersion() );
+        }
+        
+        return builder;
+    }
 
     protected void setUp()
         throws Exception
diff --git a/maven-release-plugin/src/test/java/org/apache/maven/plugins/release/PrepareReleaseMojoTest.java b/maven-release-plugin/src/test/java/org/apache/maven/plugins/release/PrepareReleaseMojoTest.java
index deca8a5..876044b 100644
--- a/maven-release-plugin/src/test/java/org/apache/maven/plugins/release/PrepareReleaseMojoTest.java
+++ b/maven-release-plugin/src/test/java/org/apache/maven/plugins/release/PrepareReleaseMojoTest.java
@@ -22,7 +22,7 @@
 
 import static org.hamcrest.CoreMatchers.instanceOf;
 import static org.hamcrest.CoreMatchers.is;
-import static org.hamcrest.CoreMatchers.nullValue;
+import static org.hamcrest.CoreMatchers.notNullValue;
 import static org.junit.Assert.assertThat;
 
 import static org.mockito.Matchers.isA;
@@ -32,17 +32,20 @@
 import static org.mockito.Mockito.verifyNoMoreInteractions;
 
 import java.io.File;
+import java.util.Collections;
+import java.util.List;
 import java.util.Properties;
 
 import org.apache.maven.execution.MavenSession;
 import org.apache.maven.plugin.MojoExecutionException;
 import org.apache.maven.plugin.MojoFailureException;
 import org.apache.maven.plugin.testing.AbstractMojoTestCase;
+import org.apache.maven.project.MavenProject;
 import org.apache.maven.shared.release.ReleaseExecutionException;
 import org.apache.maven.shared.release.ReleaseFailureException;
 import org.apache.maven.shared.release.ReleaseManager;
 import org.apache.maven.shared.release.ReleasePrepareRequest;
-import org.apache.maven.shared.release.config.ReleaseDescriptor;
+import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder;
 import org.apache.maven.shared.release.env.ReleaseEnvironment;
 import org.mockito.ArgumentCaptor;
 
@@ -64,19 +67,26 @@
         throws Exception
     {
         File testFile = getTestFile( "target/test-classes/mojos/prepare/prepare.xml" );
-        PrepareReleaseMojo mojo = (PrepareReleaseMojo) lookupMojo( "prepare", testFile );
+        final PrepareReleaseMojo mojo = (PrepareReleaseMojo) lookupMojo( "prepare", testFile );
         setDefaults( mojo );
         mojo.setBasedir( testFile.getParentFile() );
         mojo.session = new MavenSession( null, null, null, null, null, null, null, null, null )
         {
-          public Properties getExecutionProperties(){
-              return new Properties();
-          };
+            public Properties getExecutionProperties()
+            {
+                return new Properties();
+            };
+
+            @Override
+            public List<MavenProject> getProjects()
+            {
+                return Collections.singletonList( mojo.project );
+            }
         };
         
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setWorkingDirectory( testFile.getParentFile().getAbsolutePath() );
-        releaseDescriptor.setUpdateDependencies( false );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setWorkingDirectory( testFile.getParentFile().getAbsolutePath() );
+        builder.setUpdateDependencies( false );
         
         ReleaseManager mock = mock( ReleaseManager.class );
         mojo.setReleaseManager( mock );
@@ -89,9 +99,10 @@
         // verify
         verify( mock ).prepare( prepareRequest.capture() );
         
-        assertThat( prepareRequest.getValue().getReleaseDescriptor(), is( releaseDescriptor ) );
-        assertThat( prepareRequest.getValue().getReleaseEnvironment(), is(instanceOf( ReleaseEnvironment.class ) ) );
-        assertThat( prepareRequest.getValue().getReactorProjects(), is( nullValue() ) );
+        assertThat( prepareRequest.getValue().getReleaseDescriptorBuilder(),
+                    is( instanceOf( ReleaseDescriptorBuilder.class ) ) );
+        assertThat( prepareRequest.getValue().getReleaseEnvironment(), is( instanceOf( ReleaseEnvironment.class ) ) );
+        assertThat( prepareRequest.getValue().getReactorProjects(), is( notNullValue() ) );
         assertThat( prepareRequest.getValue().getResume(), is( true ) );
         assertThat( prepareRequest.getValue().getDryRun(), is( false ) );
     }
@@ -100,7 +111,7 @@
         throws Exception
     {
         File testFile = getTestFile( "target/test-classes/mojos/prepare/prepare.xml" );
-        PrepareReleaseMojo mojo = (PrepareReleaseMojo) lookupMojo( "prepare", testFile );
+        final PrepareReleaseMojo mojo = (PrepareReleaseMojo) lookupMojo( "prepare", testFile );
         setDefaults( mojo );
         mojo.setBasedir( testFile.getParentFile() );
         mojo.session = new MavenSession( null, null, null, null, null, null, null, null, null )
@@ -108,11 +119,14 @@
           public Properties getExecutionProperties(){
               return new Properties();
           };
+
+          @Override
+          public List<MavenProject> getProjects()
+          {
+              return Collections.singletonList( mojo.project );
+          }
         };
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setWorkingDirectory( testFile.getParentFile().getAbsolutePath() );
-        releaseDescriptor.setUpdateDependencies( false );
-        
+
         ReleaseManager mock = mock( ReleaseManager.class );
         doThrow( new ReleaseExecutionException( "..." ) ).when( mock ).prepare( isA( ReleasePrepareRequest.class ) );
         mojo.setReleaseManager( mock );
@@ -138,7 +152,7 @@
         throws Exception
     {
         File testFile = getTestFile( "target/test-classes/mojos/prepare/prepare.xml" );
-        PrepareReleaseMojo mojo = (PrepareReleaseMojo) lookupMojo( "prepare", testFile );
+        final PrepareReleaseMojo mojo = (PrepareReleaseMojo) lookupMojo( "prepare", testFile );
         setDefaults( mojo );
         mojo.setBasedir( testFile.getParentFile() );
         mojo.session = new MavenSession( null, null, null, null, null, null, null, null, null )
@@ -146,10 +160,13 @@
           public Properties getExecutionProperties(){
               return new Properties();
           };
+          
+          @Override
+          public List<MavenProject> getProjects()
+          {
+              return Collections.singletonList( mojo.project );
+          }
         };
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setWorkingDirectory( testFile.getParentFile().getAbsolutePath() );
-        releaseDescriptor.setUpdateDependencies( false );
         
         ReleaseManager mock = mock( ReleaseManager.class );
         ReleaseFailureException cause = new ReleaseFailureException( "..." );
diff --git a/maven-release-plugin/src/test/java/org/apache/maven/plugins/release/StageReleaseMojoTest.java b/maven-release-plugin/src/test/java/org/apache/maven/plugins/release/StageReleaseMojoTest.java
index 092d77e..b88eb24 100644
--- a/maven-release-plugin/src/test/java/org/apache/maven/plugins/release/StageReleaseMojoTest.java
+++ b/maven-release-plugin/src/test/java/org/apache/maven/plugins/release/StageReleaseMojoTest.java
@@ -31,7 +31,7 @@
 import org.apache.maven.project.MavenProject;
 import org.apache.maven.shared.release.ReleaseManager;
 import org.apache.maven.shared.release.ReleasePerformRequest;
-import org.apache.maven.shared.release.config.ReleaseDescriptor;
+import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder;
 import org.mockito.ArgumentCaptor;
 
 /**
@@ -49,15 +49,15 @@
     {
         StageReleaseMojo mojo = getMojoWithProjectSite( "stage.xml" );
 
-        ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-        releaseDescriptor.setWorkingDirectory( workingDirectory.getAbsolutePath() );
+        ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+        builder.setWorkingDirectory( workingDirectory.getAbsolutePath() );
         File checkoutDirectory = getTestFile( "target/checkout" );
-        releaseDescriptor.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
-        releaseDescriptor.setPerformGoals( "deploy site:stage-deploy" );
-        releaseDescriptor.setAdditionalArguments( "-DaltDeploymentRepository=\"staging\"" );
+        builder.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
+        builder.setPerformGoals( "deploy site:stage-deploy" );
+        builder.setAdditionalArguments( "-DaltDeploymentRepository=\"staging\"" );
 
         ReleasePerformRequest performRequest = new ReleasePerformRequest();
-        performRequest.setReleaseDescriptor( releaseDescriptor );
+        performRequest.setReleaseDescriptorBuilder( builder );
         performRequest.setReleaseEnvironment( mojo.getReleaseEnvironment() );
         performRequest.setReactorProjects( mojo.getReactorProjects() );
         performRequest.setDryRun( false );
@@ -70,9 +70,9 @@
         // verify
         ArgumentCaptor<ReleasePerformRequest> argument = ArgumentCaptor.forClass(ReleasePerformRequest.class);
         verify( mock ).perform( argument.capture() );
-        assertEquals( releaseDescriptor, argument.getValue().getReleaseDescriptor() );
+        assertNotNull( argument.getValue().getReleaseDescriptorBuilder() );
         assertNotNull( argument.getValue().getReleaseEnvironment() );
-        assertNull( argument.getValue().getReactorProjects() );
+        assertNotNull( argument.getValue().getReactorProjects() );
         assertEquals( Boolean.FALSE, argument.getValue().getDryRun() );
         verifyNoMoreInteractions( mock );
     }
diff --git a/maven-release-plugin/src/test/java/org/apache/maven/plugins/release/stubs/FlatMultiModuleMavenProjectStub.java b/maven-release-plugin/src/test/java/org/apache/maven/plugins/release/stubs/FlatMultiModuleMavenProjectStub.java
index 99ee9e2..7617d41 100644
--- a/maven-release-plugin/src/test/java/org/apache/maven/plugins/release/stubs/FlatMultiModuleMavenProjectStub.java
+++ b/maven-release-plugin/src/test/java/org/apache/maven/plugins/release/stubs/FlatMultiModuleMavenProjectStub.java
@@ -82,5 +82,22 @@
         
         return scm;
     }
-
+    
+    @Override
+    public String getGroupId()
+    {
+        return "GROUPID";
+    }
+    
+    @Override
+    public String getArtifactId()
+    {
+        return "ARTIFACTID";
+    }
+    
+    @Override
+    public String getVersion()
+    {
+        return "VERSION";
+    }
 }
diff --git a/maven-release-plugin/src/test/java/org/apache/maven/plugins/release/stubs/MavenProjectStub.java b/maven-release-plugin/src/test/java/org/apache/maven/plugins/release/stubs/MavenProjectStub.java
index 44f654f..63eefa4 100644
--- a/maven-release-plugin/src/test/java/org/apache/maven/plugins/release/stubs/MavenProjectStub.java
+++ b/maven-release-plugin/src/test/java/org/apache/maven/plugins/release/stubs/MavenProjectStub.java
@@ -54,4 +54,22 @@
     {
         return getModel().getDistributionManagement();
     }
+    
+    @Override
+    public String getGroupId()
+    {
+        return "GROUPID";
+    }
+    
+    @Override
+    public String getArtifactId()
+    {
+        return "ARTIFACTID";
+    }
+    
+    @Override
+    public String getVersion()
+    {
+        return "VERSION";
+    }
 }
diff --git a/maven-release-plugin/src/test/resources/mojos/perform/perform-with-args.xml b/maven-release-plugin/src/test/resources/mojos/perform/perform-with-args.xml
index 1ea3faa..14af0dc 100644
--- a/maven-release-plugin/src/test/resources/mojos/perform/perform-with-args.xml
+++ b/maven-release-plugin/src/test/resources/mojos/perform/perform-with-args.xml
@@ -26,6 +26,9 @@
         <configuration>
           <settings implementation="org.apache.maven.settings.Settings"/>
           <project implementation="org.apache.maven.plugins.release.stubs.MavenProjectStub"/>
+          <reactorProjects>
+            <reactorProject implementation="org.apache.maven.plugins.release.stubs.MavenProjectStub"/>
+          </reactorProjects>
           <workingDirectory>${basedir}/target/checkout</workingDirectory>
           <useReleaseProfile>true</useReleaseProfile>
 		  <goals>deploy site-deploy</goals>		  
diff --git a/maven-release-plugin/src/test/resources/mojos/perform/perform-with-flat-structure.xml b/maven-release-plugin/src/test/resources/mojos/perform/perform-with-flat-structure.xml
index 074acfe..32e25fc 100644
--- a/maven-release-plugin/src/test/resources/mojos/perform/perform-with-flat-structure.xml
+++ b/maven-release-plugin/src/test/resources/mojos/perform/perform-with-flat-structure.xml
@@ -26,6 +26,9 @@
         <configuration>
           <settings implementation="org.apache.maven.settings.Settings"/>
           <project implementation="org.apache.maven.plugins.release.stubs.FlatMultiModuleMavenProjectStub"/>
+          <reactorProjects>
+            <reactorProject implementation="org.apache.maven.plugins.release.stubs.FlatMultiModuleMavenProjectStub"/>
+          </reactorProjects>
           <workingDirectory>${basedir}/target/checkout</workingDirectory>
           <useReleaseProfile>true</useReleaseProfile>
           <connectionUrl>scm:svn:file://localhost/target/svnroot/flat-multi-module/trunk/root-project</connectionUrl>
diff --git a/maven-release-plugin/src/test/resources/mojos/perform/perform-with-multiline-goals.xml b/maven-release-plugin/src/test/resources/mojos/perform/perform-with-multiline-goals.xml
index ad13c48..f544639 100644
--- a/maven-release-plugin/src/test/resources/mojos/perform/perform-with-multiline-goals.xml
+++ b/maven-release-plugin/src/test/resources/mojos/perform/perform-with-multiline-goals.xml
@@ -26,6 +26,9 @@
         <configuration>
           <settings implementation="org.apache.maven.settings.Settings"/>
           <project implementation="org.apache.maven.plugins.release.stubs.MavenProjectStub"/>
+          <reactorProjects>
+            <reactorProject implementation="org.apache.maven.plugins.release.stubs.MavenProjectStub"/>
+          </reactorProjects>
           <workingDirectory>${basedir}/target/checkout</workingDirectory>
           <useReleaseProfile>true</useReleaseProfile>
  		  <goals>
diff --git a/maven-release-plugin/src/test/resources/mojos/perform/perform-with-scm.xml b/maven-release-plugin/src/test/resources/mojos/perform/perform-with-scm.xml
index 02849c9..cb8a866 100644
--- a/maven-release-plugin/src/test/resources/mojos/perform/perform-with-scm.xml
+++ b/maven-release-plugin/src/test/resources/mojos/perform/perform-with-scm.xml
@@ -26,6 +26,9 @@
         <configuration>
           <settings implementation="org.apache.maven.settings.Settings"/>
           <project implementation="org.apache.maven.plugins.release.stubs.MavenProjectStub"/>
+          <reactorProjects>
+            <reactorProject implementation="org.apache.maven.plugins.release.stubs.MavenProjectStub"/>
+          </reactorProjects>
           <workingDirectory>${basedir}/target/checkout</workingDirectory>
           <useReleaseProfile>true</useReleaseProfile>
           <connectionUrl>scm-url</connectionUrl>
diff --git a/maven-release-plugin/src/test/resources/mojos/perform/perform-without-site.xml b/maven-release-plugin/src/test/resources/mojos/perform/perform-without-site.xml
index c4d826a..be9fcbb 100644
--- a/maven-release-plugin/src/test/resources/mojos/perform/perform-without-site.xml
+++ b/maven-release-plugin/src/test/resources/mojos/perform/perform-without-site.xml
@@ -26,6 +26,9 @@
         <configuration>
           <settings implementation="org.apache.maven.settings.Settings"/>
           <project implementation="org.apache.maven.plugins.release.stubs.MavenProjectStub"/>
+          <reactorProjects>
+            <reactorProject implementation="org.apache.maven.plugins.release.stubs.MavenProjectStub"/>
+          </reactorProjects>
           <workingDirectory>${basedir}/target/checkout</workingDirectory>
 		  <goals>deploy</goals>
           <useReleaseProfile>true</useReleaseProfile>
diff --git a/maven-release-plugin/src/test/resources/mojos/perform/perform.xml b/maven-release-plugin/src/test/resources/mojos/perform/perform.xml
index 87b529f..0580f00 100644
--- a/maven-release-plugin/src/test/resources/mojos/perform/perform.xml
+++ b/maven-release-plugin/src/test/resources/mojos/perform/perform.xml
@@ -26,6 +26,9 @@
         <configuration>
           <settings implementation="org.apache.maven.settings.Settings"/>
           <project implementation="org.apache.maven.plugins.release.stubs.MavenProjectStub"/>
+          <reactorProjects>
+            <reactorProject implementation="org.apache.maven.plugins.release.stubs.MavenProjectStub"/>
+          </reactorProjects>
           <workingDirectory>${basedir}/target/checkout</workingDirectory>
 		  <goals>deploy site-deploy</goals>
           <useReleaseProfile>true</useReleaseProfile>
diff --git a/maven-release-plugin/src/test/resources/mojos/prepare/prepare.xml b/maven-release-plugin/src/test/resources/mojos/prepare/prepare.xml
index bec7b49..623ff2b 100644
--- a/maven-release-plugin/src/test/resources/mojos/prepare/prepare.xml
+++ b/maven-release-plugin/src/test/resources/mojos/prepare/prepare.xml
@@ -26,6 +26,9 @@
         <configuration>
           <settings implementation="org.apache.maven.settings.Settings"/>
           <project implementation="org.apache.maven.plugin.testing.stubs.MavenProjectStub"/>
+          <reactorProjects>
+            <reactorProject implementation="org.apache.maven.plugins.release.stubs.MavenProjectStub"/>
+          </reactorProjects>
           <resume>true</resume>
         </configuration>
       </plugin>
diff --git a/maven-release-plugin/src/test/resources/mojos/stage/stage.xml b/maven-release-plugin/src/test/resources/mojos/stage/stage.xml
index a8f5ea0..d1ac583 100644
--- a/maven-release-plugin/src/test/resources/mojos/stage/stage.xml
+++ b/maven-release-plugin/src/test/resources/mojos/stage/stage.xml
@@ -26,6 +26,9 @@
         <configuration>
           <settings implementation="org.apache.maven.settings.Settings"/>
           <project implementation="org.apache.maven.plugins.release.stubs.MavenProjectStub"/>
+          <reactorProjects>
+            <reactorProject implementation="org.apache.maven.plugins.release.stubs.MavenProjectStub"/>
+          </reactorProjects>
           <workingDirectory>${basedir}/target/checkout</workingDirectory>
           <stagingRepository>staging</stagingRepository>
 		  <goals>deploy site-deploy</goals>