diff --git a/docs/architecture.rst b/docs/architecture.rst
index ae772c9fec..5a785a6521 100644
--- a/docs/architecture.rst
+++ b/docs/architecture.rst
@@ -71,6 +71,7 @@ The definition of a ``BlueprintAction`` is:
       InputArtifactNames []string            `json:"inputArtifactNames"`
       OutputArtifacts    map[string]Artifact `json:"outputArtifacts"`
       Phases             []BlueprintPhase    `json:"phases"`
+      DeferPhase         *BlueprintPhase     `json:"deferPhase,omitempty"`
   }
 
 - ``Kind`` represents the type of Kubernetes object this BlueprintAction is written for.
@@ -84,6 +85,10 @@ The definition of a ``BlueprintAction`` is:
   to the ``BlueprintAction``.
 - ``Phases`` is a required list of ``BlueprintPhases``. These phases are invoked
   in order when executing this Action.
+- ``DeferPhase`` is an optional ``BlueprintPhase`` invoked after the
+  execution of ``Phases`` defined above. A ``DeferPhase``, when specified,
+  is executed regardless of the statuses of the ``Phases``.
+  A ``DeferPhase`` can be used for cleanup operations at the end of an ``Action``.
 
 .. code-block:: go
   :linenos:
diff --git a/docs/templates.rst b/docs/templates.rst
index 84227b0523..68352868ca 100644
--- a/docs/templates.rst
+++ b/docs/templates.rst
@@ -25,6 +25,7 @@ The TemplateParam struct is defined as:
     Options          map[string]string
     Object           map[string]interface{}
     Phases           map[string]*Phase
+    DeferPhase       *Phase
     PodOverride      crv1alpha1.JSONMap
   }
 
@@ -609,3 +610,28 @@ Similarly, a phase can use Secrets as arguments:
 .. code-block:: go
 
   "{{ .Phases.phase-name.Secrets.secret-name.Namespace }}"
+
+DeferPhase
+----------
+
+``DeferPhase`` is used to capture information returned from the Blueprint's ``DeferPhase``
+execution. The information is stored in the ``Phase`` struct that has the below
+definition:
+
+.. code-block:: go
+  :linenos:
+
+  type Phase struct {
+    Secrets map[string]v1.Secret
+    Output  map[string]interface{}
+  }
+
+Output artifact can be set as follows:
+
+.. code-block:: go
+
+  "{{ .DeferPhase.Output.key-name }}"
+
+
+Output artifacts that are set using ``DeferPhase`` can be consumed by other actions'
+phases using the same way other output artifacts are consumed.
diff --git a/docs/tutorial.rst b/docs/tutorial.rst
index c3b459dae8..2aebf31561 100644
--- a/docs/tutorial.rst
+++ b/docs/tutorial.rst
@@ -443,6 +443,60 @@ ConfigMap.
 If you re-execute this Kanister Action, you'll be able to see the Artifact in the
 ActionSet status.
 
+If you use a ``DeferPhase``, below is how you can set the output artifact
+from the output that is being generated from ``DeferPhase`` as shown below.
+
+.. code-block:: yaml
+
+  cat <<EOF | kubectl apply -f -
+  apiVersion: cr.kanister.io/v1alpha1
+  kind: Blueprint
+  metadata:
+    name: time-log-bp
+    namespace: kanister
+  actions:
+    backup:
+      configMapNames:
+      - location
+      secretNames:
+      - aws
+      outputArtifacts:
+        timeLog:
+          keyValue:
+            path: '{{ .ConfigMaps.location.Data.path }}/time-log/'
+        deferPhaseArt:
+          keyValue:
+            time: "{{ .DeferPhase.Output.bkpCompletedTime }}"
+      phases:
+        - func: KubeExec
+          name: backupToS3
+          args:
+            namespace: "{{ .Deployment.Namespace }}"
+            pod: "{{ index .Deployment.Pods 0 }}"
+            container: test-container
+            command:
+              - sh
+              - -c
+              - |
+                echo "Main Phase"
+      deferPhase:
+        func: KubeTask
+        name: saveBackupTime
+        args:
+          image: ghcr.io/kanisterio/mysql-sidecar:0.74.0
+          namespace: "{{ .Deployment.Namespace }}"
+          command:
+          - sh
+          - -c
+          - |
+            echo "DeferPhase"
+            kando output bkpCompletedTime "10Minutes"
+  EOF
+
+
+Output from the previous phases can also be used in the ``DeferPhase`` like it
+is used in normal scenarios.
+
 Input Artifacts
 ---------------
 
diff --git a/pkg/apis/cr/v1alpha1/types.go b/pkg/apis/cr/v1alpha1/types.go
index 6d77fce5fc..7e34e45798 100644
--- a/pkg/apis/cr/v1alpha1/types.go
+++ b/pkg/apis/cr/v1alpha1/types.go
@@ -126,6 +126,9 @@ type ActionStatus struct {
 	Phases []Phase `json:"phases,omitempty"`
 	// Artifacts created by this phase.
 	Artifacts map[string]Artifact `json:"artifacts,omitempty"`
+	// DeferPhase is the phase that is executed at the end of an action
+	// irrespective of the status of other phases in the action
+	DeferPhase Phase `json:"deferPhase,omitempty"`
 }
 
 // State is the current state of a phase of execution.
@@ -194,6 +197,7 @@ type BlueprintAction struct {
 	InputArtifactNames []string            `json:"inputArtifactNames,omitempty"`
 	OutputArtifacts    map[string]Artifact `json:"outputArtifacts,omitempty"`
 	Phases             []BlueprintPhase    `json:"phases,omitempty"`
+	DeferPhase         *BlueprintPhase     `json:"deferPhase,omitempty"`
 }
 
 // BlueprintPhase is a an individual unit of execution.
diff --git a/pkg/apis/cr/v1alpha1/zz_generated.deepcopy.go b/pkg/apis/cr/v1alpha1/zz_generated.deepcopy.go
index 8061fef28c..213f6fd00b 100644
--- a/pkg/apis/cr/v1alpha1/zz_generated.deepcopy.go
+++ b/pkg/apis/cr/v1alpha1/zz_generated.deepcopy.go
@@ -214,6 +214,7 @@ func (in *ActionStatus) DeepCopyInto(out *ActionStatus) {
 			(*out)[key] = *val.DeepCopy()
 		}
 	}
+	in.DeferPhase.DeepCopyInto(&out.DeferPhase)
 	return
 }
 
@@ -323,6 +324,10 @@ func (in *BlueprintAction) DeepCopyInto(out *BlueprintAction) {
 			(*in)[i].DeepCopyInto(&(*out)[i])
 		}
 	}
+	if in.DeferPhase != nil {
+		in, out := &in.DeferPhase, &out.DeferPhase
+		*out = (*in).DeepCopy()
+	}
 	return
 }
 
diff --git a/pkg/controller/controller.go b/pkg/controller/controller.go
index 60eae6f03d..a9080c986e 100644
--- a/pkg/controller/controller.go
+++ b/pkg/controller/controller.go
@@ -337,13 +337,23 @@ func (c *Controller) initialActionStatus(namespace string, a crv1alpha1.ActionSp
 			State: crv1alpha1.StatePending,
 		})
 	}
-	return &crv1alpha1.ActionStatus{
+
+	actionStatus := &crv1alpha1.ActionStatus{
 		Name:      a.Name,
 		Object:    a.Object,
 		Blueprint: a.Blueprint,
 		Phases:    phases,
 		Artifacts: bpa.OutputArtifacts,
-	}, nil
+	}
+
+	if bpa.DeferPhase != nil {
+		actionStatus.DeferPhase = crv1alpha1.Phase{
+			Name:  bpa.DeferPhase.Name,
+			State: crv1alpha1.StatePending,
+		}
+	}
+
+	return actionStatus, nil
 }
 
 func (c *Controller) handleActionSet(as *crv1alpha1.ActionSet) (err error) {
@@ -404,12 +414,29 @@ func (c *Controller) runAction(ctx context.Context, as *crv1alpha1.ActionSet, aI
 	if err != nil {
 		return err
 	}
+
+	// deferPhase is the phase that should be run after every successful or failed action run
+	// can be specified in blueprint using actions[name].deferPhase
+	deferPhase, err := kanister.GetDeferPhase(*bp, action.Name, action.PreferredVersion, *tp)
+	if err != nil {
+		return err
+	}
+
 	ns, name := as.GetNamespace(), as.GetName()
 	var t *tomb.Tomb
 	t, ctx = tomb.WithContext(ctx)
 	c.actionSetTombMap.Store(as.Name, t)
 	ctx = field.Context(ctx, consts.ActionsetNameKey, as.GetName())
 	t.Go(func() error {
+		var coreErr error
+		defer func() {
+			var deferErr error
+			if deferPhase != nil {
+				deferErr = c.executeDeferPhase(ctx, deferPhase, tp, bp, action.Name, aIDX, as)
+			}
+			c.renderActionsetArtifacts(ctx, as, aIDX, ns, name, action.Name, bp, tp, coreErr, deferErr)
+		}()
+
 		for i, p := range phases {
 			ctx = field.Context(ctx, consts.PhaseNameKey, p.Name())
 			c.logAndSuccessEvent(ctx, fmt.Sprintf("Executing phase %s", p.Name()), "Started Phase", as)
@@ -423,6 +450,7 @@ func (c *Controller) runAction(ctx context.Context, as *crv1alpha1.ActionSet, aI
 			}
 			var rf func(*crv1alpha1.ActionSet) error
 			if err != nil {
+				coreErr = err
 				rf = func(ras *crv1alpha1.ActionSet) error {
 					ras.Status.State = crv1alpha1.StateFailed
 					ras.Status.Error = crv1alpha1.Error{
@@ -432,77 +460,163 @@ func (c *Controller) runAction(ctx context.Context, as *crv1alpha1.ActionSet, aI
 					return nil
 				}
 			} else {
+				coreErr = nil
 				rf = func(ras *crv1alpha1.ActionSet) error {
 					ras.Status.Actions[aIDX].Phases[i].State = crv1alpha1.StateComplete
+					// this updates the phase output in the actionset status
 					ras.Status.Actions[aIDX].Phases[i].Output = output
 					return nil
 				}
 			}
+
 			if rErr := reconcile.ActionSet(ctx, c.crClient.CrV1alpha1(), ns, name, rf); rErr != nil {
 				reason := fmt.Sprintf("ActionSetFailed Action: %s", as.Spec.Actions[aIDX].Name)
 				msg := fmt.Sprintf("Failed to update phase: %#v:", as.Status.Actions[aIDX].Phases[i])
 				c.logAndErrorEvent(ctx, msg, reason, rErr, as, bp)
+				coreErr = rErr
 				return nil
 			}
+
 			if err != nil {
 				reason := fmt.Sprintf("ActionSetFailed Action: %s", as.Spec.Actions[aIDX].Name)
 				if msg == "" {
 					msg = fmt.Sprintf("Failed to execute phase: %#v:", as.Status.Actions[aIDX].Phases[i])
 				}
 				c.logAndErrorEvent(ctx, msg, reason, err, as, bp)
+				coreErr = err
 				return nil
 			}
 			param.UpdatePhaseParams(ctx, tp, p.Name(), output)
 			c.logAndSuccessEvent(ctx, fmt.Sprintf("Completed phase %s", p.Name()), "Ended Phase", as)
 		}
-		// Check if output artifacts are present
-		artTpls := as.Status.Actions[aIDX].Artifacts
-		if len(artTpls) == 0 {
-			// No artifacts, set ActionSetStatus to complete
-			if rErr := reconcile.ActionSet(ctx, c.crClient.CrV1alpha1(), ns, name, func(ras *crv1alpha1.ActionSet) error {
-				ras.Status.State = crv1alpha1.StateComplete
-				return nil
-			}); rErr != nil {
-				reason := fmt.Sprintf("ActionSetFailed Action: %s", action.Name)
-				msg := fmt.Sprintf("Failed to update ActionSet: %s", name)
-				c.logAndErrorEvent(ctx, msg, reason, rErr, as, bp)
+		return nil
+	})
+	return nil
+}
+
+// executeDeferPhase executes the phase provided as a deferPhase in the blueprint action.
+// deferPhase, if provided, must be run at the end of the blueprint action, irrespective of the
+// statuses of the other phases. ActionSet `status.state` is going to be `complete` IFF all the
+// phases and deferPhase are run successfully
+// On failure, corresponding error messages are logged and recorded as events and the
+// ActionSet's `status.state` is set to `failed`.
+func (c *Controller) executeDeferPhase(ctx context.Context,
+	deferPhase *kanister.Phase,
+	tp *param.TemplateParams,
+	bp *crv1alpha1.Blueprint,
+	actionName string,
+	aIDX int,
+	as *crv1alpha1.ActionSet,
+) error {
+	actionsetName, actionsetNS := as.GetName(), as.GetNamespace()
+	ctx = field.Context(ctx, consts.PhaseNameKey, as.Status.Actions[aIDX].DeferPhase.Name)
+	c.logAndSuccessEvent(ctx, fmt.Sprintf("Executing deferPhase %s", as.Status.Actions[aIDX].DeferPhase.Name), "Started deferPhase", as)
+
+	output, err := deferPhase.Exec(context.Background(), *bp, actionName, *tp)
+	var rf func(*crv1alpha1.ActionSet) error
+	if err != nil {
+		rf = func(as *crv1alpha1.ActionSet) error {
+			as.Status.State = crv1alpha1.StateFailed
+			as.Status.Error = crv1alpha1.Error{
+				Message: err.Error(),
 			}
+			as.Status.Actions[aIDX].DeferPhase.State = crv1alpha1.StateFailed
 			return nil
 		}
-		// Render the artifacts
-		arts, err := param.RenderArtifacts(artTpls, *tp)
-		var af func(*crv1alpha1.ActionSet) error
-		if err != nil {
-			af = func(ras *crv1alpha1.ActionSet) error {
-				ras.Status.State = crv1alpha1.StateFailed
-				ras.Status.Error = crv1alpha1.Error{
-					Message: err.Error(),
-				}
-				return nil
-			}
-		} else {
-			af = func(ras *crv1alpha1.ActionSet) error {
-				ras.Status.Actions[aIDX].Artifacts = arts
+	} else {
+		rf = func(as *crv1alpha1.ActionSet) error {
+			as.Status.Actions[aIDX].DeferPhase.State = crv1alpha1.StateComplete
+			as.Status.Actions[aIDX].DeferPhase.Output = output
+			return nil
+		}
+	}
+	var msg string
+	if rErr := reconcile.ActionSet(context.Background(), c.crClient.CrV1alpha1(), actionsetNS, actionsetName, rf); rErr != nil {
+		reason := fmt.Sprintf("ActionSetFailed Action: %s", as.Spec.Actions[aIDX].Name)
+		msg := fmt.Sprintf("Failed to update defer phase: %#v:", as.Status.Actions[aIDX].DeferPhase)
+		c.logAndErrorEvent(ctx, msg, reason, rErr, as, bp)
+		return rErr
+	}
+
+	if err != nil {
+		reason := fmt.Sprintf("ActionSetFailed Action: %s", as.Spec.Actions[aIDX].Name)
+		if msg == "" {
+			msg = fmt.Sprintf("Failed to execute defer phase: %#v:", as.Status.Actions[aIDX].DeferPhase)
+		}
+		c.logAndErrorEvent(ctx, msg, reason, err, as, bp)
+		return err
+	}
+
+	c.logAndSuccessEvent(ctx, fmt.Sprintf("Completed deferPhase %s", as.Status.Actions[aIDX].DeferPhase.Name), "Ended deferPhase", as)
+	param.UpdateDeferPhaseParams(context.Background(), tp, output)
+	return nil
+}
+
+func (c *Controller) renderActionsetArtifacts(ctx context.Context,
+	as *crv1alpha1.ActionSet,
+	aIDX int,
+	actionsetNS, actionsetName, actionName string,
+	bp *crv1alpha1.Blueprint,
+	tp *param.TemplateParams,
+	coreErr, deferErr error,
+) {
+	// Check if output artifacts are present
+	artTpls := as.Status.Actions[aIDX].Artifacts
+	if len(artTpls) == 0 {
+		// No artifacts, set ActionSetStatus to complete
+		if rErr := reconcile.ActionSet(ctx, c.crClient.CrV1alpha1(), actionsetNS, actionsetName, func(ras *crv1alpha1.ActionSet) error {
+			if coreErr == nil && deferErr == nil {
 				ras.Status.State = crv1alpha1.StateComplete
-				return nil
+			} else {
+				ras.Status.State = crv1alpha1.StateFailed
 			}
+
+			return nil
+		}); rErr != nil {
+			reason := fmt.Sprintf("ActionSetFailed Action: %s", actionName)
+			msg := fmt.Sprintf("Failed to update ActionSet: %s", actionsetName)
+			c.logAndErrorEvent(ctx, msg, reason, rErr, as, bp)
 		}
-		// Update ActionSet
-		if aErr := reconcile.ActionSet(ctx, c.crClient.CrV1alpha1(), ns, name, af); aErr != nil {
-			reason := fmt.Sprintf("ActionSetFailed Action: %s", action.Name)
-			msg := fmt.Sprintf("Failed to update Output Artifacts: %#v:", artTpls)
-			c.logAndErrorEvent(ctx, msg, reason, aErr, as, bp)
+		return
+	}
+	// Render the artifacts
+	arts, err := param.RenderArtifacts(artTpls, *tp)
+	var af func(*crv1alpha1.ActionSet) error
+	if err != nil {
+		af = func(ras *crv1alpha1.ActionSet) error {
+			ras.Status.State = crv1alpha1.StateFailed
+			ras.Status.Error = crv1alpha1.Error{
+				Message: err.Error(),
+			}
 			return nil
 		}
-		if err != nil {
-			reason := fmt.Sprintf("ActionSetFailed Action: %s", action.Name)
-			msg := "Failed to render output artifacts"
-			c.logAndErrorEvent(ctx, msg, reason, err, as, bp)
+	} else {
+		af = func(ras *crv1alpha1.ActionSet) error {
+			ras.Status.Actions[aIDX].Artifacts = arts
+			// make sure that the core phases that were run also didnt return any error
+			// and then set actionset's state to be complete
+			if coreErr == nil && deferErr == nil {
+				ras.Status.State = crv1alpha1.StateComplete
+			} else {
+				ras.Status.State = crv1alpha1.StateFailed
+			}
 			return nil
 		}
-		return nil
-	})
-	return nil
+	}
+	// Update ActionSet
+	if aErr := reconcile.ActionSet(ctx, c.crClient.CrV1alpha1(), actionsetNS, actionsetName, af); aErr != nil {
+		reason := fmt.Sprintf("ActionSetFailed Action: %s", actionName)
+		msg := fmt.Sprintf("Failed to update Output Artifacts: %#v:", artTpls)
+		c.logAndErrorEvent(ctx, msg, reason, aErr, as, bp)
+		return
+	}
+
+	if err != nil {
+		reason := fmt.Sprintf("ActionSetFailed Action: %s", actionName)
+		msg := "Failed to render output artifacts"
+		c.logAndErrorEvent(ctx, msg, reason, err, as, bp)
+		return
+	}
 }
 
 func (c *Controller) logAndErrorEvent(ctx context.Context, msg, reason string, err error, objects ...runtime.Object) {
diff --git a/pkg/controller/controller_test.go b/pkg/controller/controller_test.go
index 47179d1b3a..13172ed868 100644
--- a/pkg/controller/controller_test.go
+++ b/pkg/controller/controller_test.go
@@ -138,7 +138,7 @@ func (s *ControllerSuite) TestWatch(c *C) {
 
 // nolint:unparam
 func (s *ControllerSuite) waitOnActionSetState(c *C, as *crv1alpha1.ActionSet, state crv1alpha1.State) error {
-	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second)
 	defer cancel()
 	err := poll.Wait(ctx, func(context.Context) (bool, error) {
 		as, err := s.crCli.ActionSets(as.GetNamespace()).Get(ctx, as.GetName(), metav1.GetOptions{})
diff --git a/pkg/customresource/actionset.yaml b/pkg/customresource/actionset.yaml
index d27d2772cf..a524f306aa 100644
--- a/pkg/customresource/actionset.yaml
+++ b/pkg/customresource/actionset.yaml
@@ -219,6 +219,16 @@ spec:
                           description: Resource name of the referent.
                           type: string
                       type: object
+                    deferPhase:
+                      properties:
+                        name:
+                          type: string
+                        output:
+                          x-kubernetes-preserve-unknown-fields: true
+                          type: object
+                        state:
+                          type: string
+                      type: object
                     phases:
                       description: Phases are sub-actions an are executed sequentially.
                       items:
diff --git a/pkg/customresource/blueprint.yaml b/pkg/customresource/blueprint.yaml
index 9d2076b50f..42fced12e2 100644
--- a/pkg/customresource/blueprint.yaml
+++ b/pkg/customresource/blueprint.yaml
@@ -44,6 +44,39 @@ spec:
                         x-kubernetes-preserve-unknown-fields: true
                     type: object
                   type: object
+                deferPhase:
+                  properties:
+                    args:
+                      x-kubernetes-preserve-unknown-fields: true
+                      type: object
+                    func:
+                      type: string
+                    name:
+                      type: string
+                    objects:
+                      additionalProperties:
+                        properties:
+                          apiVersion:
+                            description: API version of the referent.
+                            type: string
+                          group:
+                            description: API Group of the referent.
+                            type: string
+                          kind:
+                            description: 'Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds'
+                            type: string
+                          name:
+                            description: 'Name of the referent. More info: http://kubernetes.io/docs/user-guide/identifiers#names'
+                            type: string
+                          namespace:
+                            description: 'Namespace of the referent. More info: http://kubernetes.io/docs/user-guide/namespaces'
+                            type: string
+                          resource:
+                            description: Resource name of the referent.
+                            type: string
+                        type: object
+                      type: object
+                  type: object
                 phases:
                   items:
                     properties:
diff --git a/pkg/param/param.go b/pkg/param/param.go
index d4823d7fee..9e05c139ca 100644
--- a/pkg/param/param.go
+++ b/pkg/param/param.go
@@ -52,6 +52,7 @@ type TemplateParams struct {
 	Options          map[string]string
 	Object           map[string]interface{}
 	Phases           map[string]*Phase
+	DeferPhase       *Phase
 	PodOverride      crv1alpha1.JSONMap
 }
 
@@ -510,6 +511,12 @@ func UpdatePhaseParams(ctx context.Context, tp *TemplateParams, phaseName string
 	tp.Phases[phaseName].Output = output
 }
 
+// UpdateDeferPhaseParams updates the TemplateParams deferPhase output with passed output
+// This output would be generated/passed by execution of the phase
+func UpdateDeferPhaseParams(ctx context.Context, tp *TemplateParams, output map[string]interface{}) {
+	tp.DeferPhase.Output = output
+}
+
 // InitPhaseParams initializes the TemplateParams with Phase information
 func InitPhaseParams(ctx context.Context, cli kubernetes.Interface, tp *TemplateParams, phaseName string, objects map[string]crv1alpha1.ObjectReference) error {
 	if tp.Phases == nil {
@@ -522,5 +529,10 @@ func InitPhaseParams(ctx context.Context, cli kubernetes.Interface, tp *Template
 	tp.Phases[phaseName] = &Phase{
 		Secrets: secrets,
 	}
+
+	tp.DeferPhase = &Phase{
+		Secrets: secrets,
+	}
+
 	return nil
 }
diff --git a/pkg/param/param_test.go b/pkg/param/param_test.go
index 5f6a2225e6..f31a4bd225 100644
--- a/pkg/param/param_test.go
+++ b/pkg/param/param_test.go
@@ -721,7 +721,10 @@ func (s *ParamsSuite) TestPhaseParams(c *C) {
 	c.Assert(tp.Phases, IsNil)
 	err = InitPhaseParams(ctx, s.cli, tp, "backup", nil)
 	c.Assert(err, IsNil)
-	UpdatePhaseParams(ctx, tp, "backup", map[string]interface{}{"version": "0.76.0"})
+	UpdatePhaseParams(ctx, tp, "backup", map[string]interface{}{"version": "0.75.0"})
+	UpdateDeferPhaseParams(ctx, tp, map[string]interface{}{"version": "0.75.0"})
+	// make sure output artifact is set in DeferPhase
+	c.Assert(tp.DeferPhase.Output, DeepEquals, map[string]interface{}{"version": "0.75.0"})
 	c.Assert(tp.Phases, HasLen, 1)
 	c.Assert(tp.Phases["backup"], NotNil)
 	c.Assert(tp.Secrets, HasLen, 1)
diff --git a/pkg/phase.go b/pkg/phase.go
index 22f12240b8..d6519fde41 100644
--- a/pkg/phase.go
+++ b/pkg/phase.go
@@ -55,7 +55,13 @@ func (p *Phase) Exec(ctx context.Context, bp crv1alpha1.Blueprint, action string
 			return nil, errors.Errorf("Action {%s} not found in action map", action)
 		}
 		// Render the argument templates for the Phase's function
-		for _, ap := range a.Phases {
+		phases := []crv1alpha1.BlueprintPhase{}
+		phases = append(phases, a.Phases...)
+		if a.DeferPhase != nil {
+			phases = append(phases, *a.DeferPhase)
+		}
+
+		for _, ap := range phases {
 			if ap.Name != p.name {
 				continue
 			}
@@ -87,35 +93,75 @@ func checkSupportedArgs(supportedArgs []string, args map[string]interface{}) err
 	return nil
 }
 
-// GetPhases renders the returns a list of Phases with pre-rendered arguments.
-func GetPhases(bp crv1alpha1.Blueprint, action, version string, tp param.TemplateParams) ([]*Phase, error) {
+func GetDeferPhase(bp crv1alpha1.Blueprint, action, version string, tp param.TemplateParams) (*Phase, error) {
 	a, ok := bp.Actions[action]
 	if !ok {
-		return nil, errors.Errorf("Action {%s} not found in action map", action)
+		return nil, errors.Errorf("Action {%s} not found in blueprint actions", action)
 	}
-	defaultVersion, funcVersion, err := getFunctionVersion(version)
+
+	if a.DeferPhase == nil {
+		return nil, nil
+	}
+
+	regVersion, err := regFuncVersion(a.DeferPhase.Func, version)
+	if err != nil {
+		return nil, err
+	}
+
+	objs, err := param.RenderObjectRefs(a.DeferPhase.ObjectRefs, tp)
 	if err != nil {
-		return nil, errors.Wrapf(err, "Failed to get function version")
+		return nil, err
 	}
+
+	return &Phase{
+		name:    a.DeferPhase.Name,
+		objects: objs,
+		f:       funcs[a.DeferPhase.Func][regVersion],
+	}, nil
+}
+
+func regFuncVersion(f, version string) (semver.Version, error) {
 	funcMu.RLock()
 	defer funcMu.RUnlock()
+
+	defaultVersion, funcVersion, err := getFunctionVersion(version)
+	if err != nil {
+		return semver.Version{}, errors.Wrapf(err, "Failed to get function version")
+	}
+
+	regVersion := *funcVersion
+	if _, ok := funcs[f]; !ok {
+		return semver.Version{}, errors.Errorf("Requested function {%s} has not been registered", f)
+	}
+	if _, ok := funcs[f][regVersion]; !ok {
+		if funcVersion.Equal(defaultVersion) {
+			return semver.Version{}, errors.Errorf("Requested function {%s} has not been registered with version {%s}", f, version)
+		}
+		if _, ok := funcs[f][*defaultVersion]; !ok {
+			return semver.Version{}, errors.Errorf("Requested function {%s} has not been registered with versions {%s} or {%s}", f, version, DefaultVersion)
+		}
+		log.Info().Print("Falling back to default version of the function", field.M{"Function": f, "PreferredVersion": version, "FallbackVersion": DefaultVersion})
+		return *defaultVersion, nil
+	}
+
+	return *funcVersion, nil
+}
+
+// GetPhases renders the returns a list of Phases with pre-rendered arguments.
+func GetPhases(bp crv1alpha1.Blueprint, action, version string, tp param.TemplateParams) ([]*Phase, error) {
+	a, ok := bp.Actions[action]
+	if !ok {
+		return nil, errors.Errorf("Action {%s} not found in action map", action)
+	}
+
 	phases := make([]*Phase, 0, len(a.Phases))
 	// Check that all requested phases are registered and render object refs
 	for _, p := range a.Phases {
-		regVersion := *funcVersion
-		if _, ok := funcs[p.Func]; !ok {
-			return nil, errors.Errorf("Requested function {%s} has not been registered", p.Func)
-		}
-		if _, ok := funcs[p.Func][regVersion]; !ok {
-			if funcVersion.Equal(defaultVersion) {
-				return nil, errors.Errorf("Requested function {%s} has not been registered with version {%s}", p.Func, version)
-			}
-			if _, ok := funcs[p.Func][*defaultVersion]; !ok {
-				return nil, errors.Errorf("Requested function {%s} has not been registered with versions {%s} or {%s}", p.Func, version, DefaultVersion)
-			}
-			log.Info().Print("Falling back to default version of the function", field.M{"Function": p.Func, "PreferredVersion": version, "FallbackVersion": DefaultVersion})
-			regVersion = *defaultVersion
+		regVersion, err := regFuncVersion(p.Func, version)
+		if err != nil {
+			return nil, err
 		}
+
 		objs, err := param.RenderObjectRefs(p.ObjectRefs, tp)
 		if err != nil {
 			return nil, err
diff --git a/pkg/phase_test.go b/pkg/phase_test.go
index 7d4b93ab55..aaef64c02c 100644
--- a/pkg/phase_test.go
+++ b/pkg/phase_test.go
@@ -35,6 +35,14 @@ type testFunc struct {
 	err    error
 }
 
+type anotherFunc struct {
+	testFunc
+}
+
+func (a *anotherFunc) Name() string {
+	return "anotherTestFunc"
+}
+
 func (*testFunc) Name() string {
 	return "mock"
 }
@@ -128,3 +136,69 @@ func (s *PhaseSuite) TestCheckSupportedArgs(c *C) {
 		c.Assert(err, tc.err)
 	}
 }
+
+func (s *PhaseSuite) TestRegFuncVersion(c *C) {
+	for _, tc := range []struct {
+		regWithVersion  string
+		expectedVersion string
+		queryVersion    string
+		f               Func
+	}{
+		{
+			f:               &testFunc{},
+			expectedVersion: "v0.0.0",
+			queryVersion:    "v0.0.0",
+		},
+		{
+			f:               &testFunc{},
+			regWithVersion:  "v0.0.1",
+			expectedVersion: "v0.0.1",
+			queryVersion:    "v0.0.1",
+		},
+		{
+			f:               &anotherFunc{},
+			expectedVersion: "v0.0.0",
+			queryVersion:    "v0.0.0",
+		},
+		{
+			f:               &anotherFunc{},
+			regWithVersion:  "v1.2.3",
+			expectedVersion: "v1.2.3",
+			queryVersion:    "v1.2.3",
+		},
+		{
+			f:               &anotherFunc{},
+			regWithVersion:  "v4.5.6",
+			expectedVersion: "v4.5.6",
+			queryVersion:    "v4.5.6",
+		},
+		{
+			f:               &anotherFunc{},
+			regWithVersion:  "v0.9.9",
+			expectedVersion: "v0.0.0",
+			// even though we are registering function version v0.9.9 we are querying the same function that is registered with version
+			// v0.0.0 that is the reason we have v0.0.0 as expectedVersion
+			queryVersion: "v0.0.0",
+		},
+		{
+			f:               &anotherFunc{},
+			regWithVersion:  "v0.1.1",
+			expectedVersion: "v0.0.0",
+			// since function anotherFunc is not registered with version v11.11.11, we will default to defaultFuncVersion (i.e., v0.0.0)
+			// that is the reason the expected version hereis v0.0.0
+			queryVersion: "v11.11.11",
+		},
+	} {
+		if tc.regWithVersion == "" {
+			err := Register(tc.f)
+			c.Assert(err, IsNil)
+		} else {
+			err := RegisterVersion(tc.f, tc.regWithVersion)
+			c.Assert(err, IsNil)
+		}
+
+		semVer, err := regFuncVersion(tc.f.Name(), tc.queryVersion)
+		c.Assert(err, IsNil)
+		c.Assert(semVer.Original(), Equals, tc.expectedVersion)
+	}
+}