diff --git a/include/Attribute.h b/include/Attribute.h
index 47438322d0..7884b86420 100644
--- a/include/Attribute.h
+++ b/include/Attribute.h
@@ -70,11 +70,10 @@ public:
     };
 
     /**
-     *  Marshall the attribute in a single string. The string MUST be freed
-     *  by the calling function.
-     *    @return a string (allocated in the heap) holding the attribute value.
+     *  Marshall the attribute in a single string.
+     *    @return a string holding the attribute value.
      */
-    virtual std::string * marshall(const char * _sep = 0) const = 0;
+    virtual std::string marshall(const char * _sep = 0) const = 0;
 
     /**
      *  Write the attribute using a simple XML format. The string MUST be freed
@@ -153,17 +152,12 @@ public:
     };
 
     /**
-     *  Marshall the attribute in a single string. The string MUST be freed
-     *  by the calling function.
-     *    @return a string (allocated in the heap) holding the attribute value.
+     *  Marshall the attribute in a single string.
+     *    @return a string holding the attribute value.
      */
-    std::string * marshall(const char * _sep = 0) const override
+    std::string marshall(const char * _sep = 0) const override
     {
-        auto rs = new std::string;
-
-        *rs = attribute_value;
-
-        return rs;
+        return attribute_value;
     };
 
     /**
@@ -391,7 +385,7 @@ public:
      *  "VAL_NAME_1=VAL_VALUE_1,...,VAL_NAME_N=VAL_VALUE_N".
      *    @return a string (allocated in the heap) holding the attribute value.
      */
-    std::string * marshall(const char * _sep = 0) const override;
+    std::string marshall(const char * _sep = 0) const override;
 
     /**
      *  Write the attribute using a simple XML format:
diff --git a/include/Cluster.h b/include/Cluster.h
index 128884ab27..4abbeca745 100644
--- a/include/Cluster.h
+++ b/include/Cluster.h
@@ -138,7 +138,8 @@ private:
     // *************************************************************************
     // Constructor
     // *************************************************************************
-    Cluster(int id, const std::string& name, ClusterTemplate*  cl_template,
+    Cluster(int id, const std::string& name,
+            std::unique_ptr<ClusterTemplate>  cl_template,
             const VectorAttribute& vnc_conf);
 
     // *************************************************************************
@@ -256,9 +257,9 @@ private:
     /**
      *  Factory method for cluster templates
      */
-    Template * get_new_template() const override
+    std::unique_ptr<Template> get_new_template() const override
     {
-        return new ClusterTemplate;
+        return std::make_unique<ClusterTemplate>();
     }
 
     /**
diff --git a/include/Datastore.h b/include/Datastore.h
index 7d1aeb984e..cc485a9c8f 100644
--- a/include/Datastore.h
+++ b/include/Datastore.h
@@ -343,7 +343,7 @@ private:
             const std::string&  uname,
             const std::string&  gname,
             int                 umask,
-            DatastoreTemplate*  ds_template,
+            std::unique_ptr<DatastoreTemplate> ds_template,
             const std::set<int> &cluster_ids);
 
     /**
@@ -398,9 +398,9 @@ private:
     /**
      *  Factory method for datastore templates
      */
-    Template * get_new_template() const override
+    std::unique_ptr<Template> get_new_template() const override
     {
-        return new DatastoreTemplate;
+        return std::make_unique<DatastoreTemplate>();
     }
 
     /**
diff --git a/include/DatastorePool.h b/include/DatastorePool.h
index 371f4da058..e56a18c74e 100644
--- a/include/DatastorePool.h
+++ b/include/DatastorePool.h
@@ -90,7 +90,7 @@ public:
             const std::string&   uname,
             const std::string&   gname,
             int                  umask,
-            DatastoreTemplate *  ds_template,
+            std::unique_ptr<DatastoreTemplate> ds_template,
             int *                oid,
             const std::set<int>& cluster_ids,
             std::string&         error_str);
diff --git a/include/Document.h b/include/Document.h
index fbdbb50092..d0a058d3bc 100644
--- a/include/Document.h
+++ b/include/Document.h
@@ -46,19 +46,18 @@ public:
     /**
      *  Factory method for document templates
      */
-    Template * get_new_template() const override
+    std::unique_ptr<Template> get_new_template() const override
     {
-        return new Template;
+        return std::make_unique<Template>();
     }
 
     /**
      *  Returns a copy of the Template
      *    @return A copy of the VirtualMachineTemplate
      */
-    Template * clone_template() const
+    std::unique_ptr<Template> clone_template() const
     {
-        return new Template(
-                *(static_cast<Template *>(obj_template)));
+        return std::make_unique<Template>(*obj_template);
     };
 
     /**
@@ -127,7 +126,7 @@ protected:
                 const std::string& gname,
                 int umask,
                 int type,
-                Template * _template_contents);
+                std::unique_ptr<Template> _template_contents);
 
     // *************************************************************************
     // DataBase implementation
diff --git a/include/DocumentPool.h b/include/DocumentPool.h
index 3d4c3bac80..ebac0af076 100644
--- a/include/DocumentPool.h
+++ b/include/DocumentPool.h
@@ -53,12 +53,13 @@ public:
                  const std::string&       gname,
                  int                      umask,
                  int                      type,
-                 Template *               template_contents,
+                 std::unique_ptr<Template> template_contents,
                  int *                    oid,
                  std::string&             error_str)
     {
         *oid = PoolSQL::allocate(
-            new Document(-1, uid, gid, uname, gname, umask, type, template_contents),
+            new Document(-1, uid, gid, uname, gname, umask, type,
+                         std::move(template_contents)),
             error_str);
 
         return *oid;
diff --git a/include/ExtendedAttribute.h b/include/ExtendedAttribute.h
index 590fe420ca..d0af57eaae 100644
--- a/include/ExtendedAttribute.h
+++ b/include/ExtendedAttribute.h
@@ -87,7 +87,7 @@ protected:
     /* ---------------------------------------------------------------------- */
     /* Attribute Interface                                                    */
     /* ---------------------------------------------------------------------- */
-    std::string * marshall(const char * _sep = 0) const
+    std::string marshall(const char * _sep = 0) const
     {
         return va->marshall(_sep);
     };
diff --git a/include/Group.h b/include/Group.h
index b3de734cae..a51d99a95d 100644
--- a/include/Group.h
+++ b/include/Group.h
@@ -132,9 +132,9 @@ public:
     /**
      *  Factory method for Group templates
      */
-    Template * get_new_template() const override
+    std::unique_ptr<Template> get_new_template() const override
     {
-        return new GroupTemplate;
+        return std::make_unique<GroupTemplate>();
     }
 
     /**
diff --git a/include/Hook.h b/include/Hook.h
index ccdc22f0a3..b72e470400 100644
--- a/include/Hook.h
+++ b/include/Hook.h
@@ -95,7 +95,7 @@ private:
     // Constructor/Destructor
     // *************************************************************************
 
-    Hook(Template * tmpl);
+    Hook(std::unique_ptr<Template> tmpl);
 
     /**
      * Set hook implementation attribute depending of the hook type.
@@ -105,9 +105,9 @@ private:
     /**
      *  Factory method for Hook templates
      */
-    Template * get_new_template() const
+    std::unique_ptr<Template> get_new_template() const
     {
-        return new Template;
+        return std::make_unique<Template>();
     }
 
 
diff --git a/include/HookPool.h b/include/HookPool.h
index 49080c9112..32d9521596 100644
--- a/include/HookPool.h
+++ b/include/HookPool.h
@@ -38,7 +38,7 @@ public:
      *    @param oid the id assigned to the Hook
      *    @return the oid assigned to the object or -1 in case of failure
      */
-    int allocate (Template * tmpl, std::string& error_str);
+    int allocate (std::unique_ptr<Template> tmpl, std::string& error_str);
 
     /**
      *  Gets an object from the pool (if needed the object is loaded from the
diff --git a/include/Host.h b/include/Host.h
index ed7bffbdd6..96da060a53 100644
--- a/include/Host.h
+++ b/include/Host.h
@@ -304,9 +304,9 @@ public:
     /**
      *  Factory method for host templates
      */
-    Template * get_new_template() const override
+    std::unique_ptr<Template> get_new_template() const override
     {
-        return new HostTemplate;
+        return std::make_unique<HostTemplate>();
     }
 
     /**
diff --git a/include/Image.h b/include/Image.h
index 8c2088a8eb..10ba2d9900 100644
--- a/include/Image.h
+++ b/include/Image.h
@@ -410,7 +410,7 @@ public:
      */
     bool is_saving()
     {
-        return (static_cast<ImageTemplate *>(obj_template))->is_saving();
+        return static_cast<ImageTemplate*>(obj_template.get())->is_saving();
     }
 
     /**
@@ -482,9 +482,9 @@ public:
     /**
      *  Factory method for image templates
      */
-    Template * get_new_template() const override
+    std::unique_ptr<Template> get_new_template() const override
     {
-        return new ImageTemplate;
+        return std::make_unique<ImageTemplate>();
     }
 
     /**
@@ -517,7 +517,7 @@ public:
      * @param new_name Value for the NAME attribute
      * @return Pointer to the new tempalte 0 in case of success
      */
-    ImageTemplate * clone_template(const std::string& new_name) const;
+    std::unique_ptr<ImageTemplate> clone_template(const std::string& new_name) const;
 
     /* ---------------------------------------------------------------------- */
     /* Snapshots functions                                                    */
@@ -718,7 +718,7 @@ protected:
           const std::string&  uname,
           const std::string&  gname,
           int                 umask,
-          ImageTemplate*      img_template);
+          std::unique_ptr<ImageTemplate> img_template);
 
     // *************************************************************************
     // DataBase implementation
diff --git a/include/ImagePool.h b/include/ImagePool.h
index 041fc90289..0828067efb 100644
--- a/include/ImagePool.h
+++ b/include/ImagePool.h
@@ -73,7 +73,7 @@ public:
         const std::string&       uname,
         const std::string&       gname,
         int                      umask,
-        ImageTemplate *          img_template,
+        std::unique_ptr<ImageTemplate> img_template,
         int                      ds_id,
         const std::string&       ds_name,
         Image::DiskType          disk_type,
diff --git a/include/ImageTemplate.h b/include/ImageTemplate.h
index bf12650247..60bd4910c3 100644
--- a/include/ImageTemplate.h
+++ b/include/ImageTemplate.h
@@ -27,7 +27,7 @@ class ImageTemplate : public Template
 public:
     ImageTemplate() : Template(true,'=',"TEMPLATE"){};
 
-    ImageTemplate(const ImageTemplate& tmpl):Template(tmpl){};
+    ImageTemplate(const Template& tmpl):Template(tmpl){};
 
     ~ImageTemplate(){};
 
diff --git a/include/MarketPlace.h b/include/MarketPlace.h
index 427cb41f8e..5d57b4affa 100644
--- a/include/MarketPlace.h
+++ b/include/MarketPlace.h
@@ -184,7 +184,7 @@ private:
             const std::string&   uname,
             const std::string&   gname,
             int                  umask,
-            MarketPlaceTemplate* mp_template);
+            std::unique_ptr<MarketPlaceTemplate> mp_template);
 
     // *************************************************************************
     // DataBase implementation (Private)
@@ -234,9 +234,9 @@ private:
     /**
      *  Factory method for marketplace templates
      */
-    Template * get_new_template() const override
+    std::unique_ptr<Template> get_new_template() const override
     {
-        return new MarketPlaceTemplate;
+        return std::make_unique<MarketPlaceTemplate>();
     }
 
     /**
diff --git a/include/MarketPlaceApp.h b/include/MarketPlaceApp.h
index 7d814ae0bd..dfc3872592 100644
--- a/include/MarketPlaceApp.h
+++ b/include/MarketPlaceApp.h
@@ -355,7 +355,7 @@ private:
             const std::string&      uname,
             const std::string&      gname,
             int                     umask,
-            MarketPlaceAppTemplate* app_template);
+            std::unique_ptr<MarketPlaceAppTemplate> app_template);
 
     // *************************************************************************
     // DataBase implementation (Private)
@@ -413,9 +413,9 @@ private:
     /**
      *  Factory method for marketplace app templates
      */
-    Template * get_new_template() const override
+    std::unique_ptr<Template> get_new_template() const override
     {
-        return new MarketPlaceAppTemplate;
+        return std::make_unique<MarketPlaceAppTemplate>();
     }
 };
 
diff --git a/include/MarketPlaceAppPool.h b/include/MarketPlaceAppPool.h
index 96d155028b..1e1c9fcee6 100644
--- a/include/MarketPlaceAppPool.h
+++ b/include/MarketPlaceAppPool.h
@@ -54,7 +54,7 @@ public:
             const std::string& uname,
             const std::string& gname,
             int                umask,
-            MarketPlaceAppTemplate * apptemplate,
+            std::unique_ptr<MarketPlaceAppTemplate> apptemplate,
             int                mp_id,
             const std::string& mp_name,
             int *              oid,
diff --git a/include/MarketPlacePool.h b/include/MarketPlacePool.h
index 778e883fcf..d59269cc9f 100644
--- a/include/MarketPlacePool.h
+++ b/include/MarketPlacePool.h
@@ -55,7 +55,7 @@ public:
             const std::string& uname,
             const std::string& gname,
             int                umask,
-            MarketPlaceTemplate * mp_template,
+            std::unique_ptr<MarketPlaceTemplate> mp_template,
             int *              oid,
             std::string&       error_str);
 
diff --git a/include/PoolObjectSQL.h b/include/PoolObjectSQL.h
index 186ea4fa55..ba038b1a57 100644
--- a/include/PoolObjectSQL.h
+++ b/include/PoolObjectSQL.h
@@ -175,7 +175,6 @@ public:
              other_u(0),
              other_m(0),
              other_a(0),
-             obj_template(0),
              locked(LockStates::ST_NONE),
              lock_owner(-1),
              lock_req_id(-1),
@@ -192,8 +191,6 @@ public:
         {
             _mutex->unlock();
         }
-
-        delete obj_template;
     };
 
     /* --------------------------------------------------------------------- */
@@ -485,9 +482,9 @@ public:
      *  by classes that uses templates
      *    @return a new template
      */
-    virtual Template * get_new_template() const
+    virtual std::unique_ptr<Template> get_new_template() const
     {
-        return 0;
+        return nullptr;
     }
 
     /**
@@ -777,7 +774,7 @@ protected:
     /**
      *  Template for this object, will be allocated if needed
      */
-    Template * obj_template;
+    std::unique_ptr<Template> obj_template;
 
     /**
      *  Flag for the DB lock
diff --git a/include/RaftManager.h b/include/RaftManager.h
index a4efa3aa09..3639470918 100644
--- a/include/RaftManager.h
+++ b/include/RaftManager.h
@@ -56,11 +56,7 @@ public:
         long long bcast, long long election, time_t xmlrpc,
         const std::string& remotes_location);
 
-    ~RaftManager()
-    {
-        delete leader_hook;
-        delete follower_hook;
-    };
+    ~RaftManager() = default;
 
     // -------------------------------------------------------------------------
     // Raft associated actions (synchronous)
@@ -414,8 +410,8 @@ private:
     // Hooks
     // -------------------------------------------------------------------------
 
-    ExecuteHook * leader_hook;
-    ExecuteHook * follower_hook;
+    std::unique_ptr<ExecuteHook> leader_hook;
+    std::unique_ptr<ExecuteHook> follower_hook;
 
     // -------------------------------------------------------------------------
     // Internal Raft functions
diff --git a/include/RequestManagerAllocate.h b/include/RequestManagerAllocate.h
index ba4ff5b647..61919ab65c 100644
--- a/include/RequestManagerAllocate.h
+++ b/include/RequestManagerAllocate.h
@@ -77,11 +77,11 @@ protected:
 
     /* -------------------------------------------------------------------- */
 
-    virtual Template * get_object_template() const { return 0; };
+    virtual std::unique_ptr<Template> get_object_template() const { return 0; };
 
     virtual Request::ErrorCode pool_allocate(
                               xmlrpc_c::paramList const& _paramList,
-                              Template * tmpl,
+                              std::unique_ptr<Template> tmpl,
                               int& id,
                               RequestAttributes& att)
     {
@@ -90,13 +90,13 @@ protected:
 
     virtual Request::ErrorCode pool_allocate(
                               xmlrpc_c::paramList const& _paramList,
-                              Template * tmpl,
+                              std::unique_ptr<Template> tmpl,
                               int& id,
                               RequestAttributes& att,
                               int cluster_id,
                               const std::string& cluster_name)
     {
-        return pool_allocate(_paramList, tmpl, id, att);
+        return pool_allocate(_paramList, move(tmpl), id, att);
     };
 
     virtual int get_cluster_id(xmlrpc_c::paramList const& paramList) const
@@ -158,13 +158,13 @@ public:
 
     /* --------------------------------------------------------------------- */
 
-    Template * get_object_template() const override
+    std::unique_ptr<Template> get_object_template() const override
     {
-        return new VirtualMachineTemplate;
+        return std::make_unique<VirtualMachineTemplate>();
     };
 
     Request::ErrorCode pool_allocate(xmlrpc_c::paramList const&  paramList,
-                                     Template *                  tmpl,
+                                     std::unique_ptr<Template>   tmpl,
                                      int&                        id,
                                      RequestAttributes&          att) override;
 
@@ -194,13 +194,13 @@ public:
 
     /* --------------------------------------------------------------------- */
 
-    Template * get_object_template() const override
+    std::unique_ptr<Template> get_object_template() const override
     {
-        return new VirtualNetworkTemplate;
+        return std::make_unique<VirtualNetworkTemplate>();
     };
 
     Request::ErrorCode pool_allocate(xmlrpc_c::paramList const& _paramList,
-                      Template * tmpl,
+                      std::unique_ptr<Template> tmpl,
                       int& id,
                       RequestAttributes& att,
                       int cluster_id,
@@ -266,13 +266,13 @@ public:
 
     /* --------------------------------------------------------------------- */
 
-    Template * get_object_template() const override
+    std::unique_ptr<Template> get_object_template() const override
     {
-        return new VirtualMachineTemplate;
+        return std::make_unique<VirtualMachineTemplate>();
     };
 
     Request::ErrorCode pool_allocate(xmlrpc_c::paramList const&  paramList,
-                                     Template *                  tmpl,
+                                     std::unique_ptr<Template>   tmpl,
                                      int&                        id,
                                      RequestAttributes&          att) override;
 
@@ -299,13 +299,13 @@ public:
 
     /* --------------------------------------------------------------------- */
 
-    Template * get_object_template() const override
+    std::unique_ptr<Template> get_object_template() const override
     {
-        return new VirtualMachineTemplate;
+        return std::make_unique<VirtualMachineTemplate>();
     };
 
     Request::ErrorCode pool_allocate(xmlrpc_c::paramList const&  paramList,
-                                     Template *                  tmpl,
+                                     std::unique_ptr<Template>   tmpl,
                                      int&                        id,
                                      RequestAttributes&          att) override;
 
@@ -336,7 +336,7 @@ public:
     /* --------------------------------------------------------------------- */
 
     Request::ErrorCode pool_allocate(xmlrpc_c::paramList const& _paramList,
-                      Template * tmpl,
+                      std::unique_ptr<Template> tmpl,
                       int& id,
                       RequestAttributes& att,
                       int cluster_id,
@@ -379,7 +379,7 @@ public:
     ~UserAllocate(){};
 
     Request::ErrorCode pool_allocate(xmlrpc_c::paramList const&  paramList,
-                                     Template *                  tmpl,
+                                     std::unique_ptr<Template>   tmpl,
                                      int&                        id,
                                      RequestAttributes&          att) override;
 
@@ -412,7 +412,7 @@ public:
     ~GroupAllocate(){};
 
     Request::ErrorCode pool_allocate(xmlrpc_c::paramList const&  paramList,
-                                     Template *                  tmpl,
+                                     std::unique_ptr<Template>   tmpl,
                                      int&                        id,
                                      RequestAttributes&          att) override;
 
@@ -441,13 +441,13 @@ public:
 
     /* -------------------------------------------------------------------- */
 
-    Template * get_object_template() const override
+    std::unique_ptr<Template> get_object_template() const override
     {
-        return new DatastoreTemplate;
+        return std::make_unique<DatastoreTemplate>();
     };
 
     Request::ErrorCode pool_allocate(xmlrpc_c::paramList const& _paramList,
-                      Template * tmpl,
+                      std::unique_ptr<Template> tmpl,
                       int& id,
                       RequestAttributes& att,
                       int cluster_id,
@@ -487,7 +487,7 @@ public:
     ~ClusterAllocate(){};
 
     Request::ErrorCode pool_allocate(xmlrpc_c::paramList const&  paramList,
-                                     Template *                  tmpl,
+                                     std::unique_ptr<Template>   tmpl,
                                      int&                        id,
                                      RequestAttributes&          att) override;
 };
@@ -513,13 +513,13 @@ public:
 
     /* --------------------------------------------------------------------- */
 
-    Template * get_object_template() const override
+    std::unique_ptr<Template> get_object_template() const override
     {
-        return new Template;
+        return std::make_unique<Template>();
     };
 
     Request::ErrorCode pool_allocate(xmlrpc_c::paramList const&  paramList,
-                                     Template *                  tmpl,
+                                     std::unique_ptr<Template>   tmpl,
                                      int&                        id,
                                      RequestAttributes&          att) override;
 };
@@ -548,13 +548,13 @@ public:
     void request_execute(xmlrpc_c::paramList const& _paramList,
                          RequestAttributes& att) override;
 
-    Template * get_object_template() const override
+    std::unique_ptr<Template> get_object_template() const override
     {
-        return new Template;
+        return std::make_unique<Template>();
     };
 
     Request::ErrorCode pool_allocate(xmlrpc_c::paramList const&  paramList,
-                                     Template *                  tmpl,
+                                     std::unique_ptr<Template>   tmpl,
                                      int&                        id,
                                      RequestAttributes&          att) override;
 };
@@ -580,13 +580,13 @@ public:
 
     /* --------------------------------------------------------------------- */
 
-    Template * get_object_template() const override
+    std::unique_ptr<Template> get_object_template() const override
     {
-        return new Template;
+        return std::make_unique<Template>();
     };
 
     Request::ErrorCode pool_allocate(xmlrpc_c::paramList const&  paramList,
-                                     Template *                  tmpl,
+                                     std::unique_ptr<Template>   tmpl,
                                      int&                        id,
                                      RequestAttributes&          att);
 };
@@ -612,13 +612,13 @@ public:
 
     /* --------------------------------------------------------------------- */
 
-    Template * get_object_template() const override
+    std::unique_ptr<Template> get_object_template() const override
     {
-        return new Template;
+        return std::make_unique<Template>();
     };
 
     Request::ErrorCode pool_allocate(xmlrpc_c::paramList const&  paramList,
-                                     Template *                  tmpl,
+                                     std::unique_ptr<Template>   tmpl,
                                      int&                        id,
                                      RequestAttributes&          att) override;
 };
@@ -645,13 +645,13 @@ public:
 
     /* --------------------------------------------------------------------- */
 
-    Template * get_object_template() const override
+    std::unique_ptr<Template> get_object_template() const override
     {
-        return new Template;
+        return std::make_unique<Template>();
     };
 
     Request::ErrorCode pool_allocate(xmlrpc_c::paramList const&  paramList,
-                                     Template *                  tmpl,
+                                     std::unique_ptr<Template>   tmpl,
                                      int&                        id,
                                      RequestAttributes&          att) override;
 
@@ -681,13 +681,13 @@ public:
 
     /* --------------------------------------------------------------------- */
 
-    Template * get_object_template() const override
+    std::unique_ptr<Template> get_object_template() const override
     {
-        return new MarketPlaceTemplate;
+        return std::make_unique<MarketPlaceTemplate>();
     };
 
     Request::ErrorCode pool_allocate(xmlrpc_c::paramList const& _paramList,
-                      Template *                 tmpl,
+                      std::unique_ptr<Template>  tmpl,
                       int&                       id,
                       RequestAttributes&         att) override;
 };
@@ -714,13 +714,13 @@ public:
 
     /* --------------------------------------------------------------------- */
 
-    Template * get_object_template() const override
+    std::unique_ptr<Template> get_object_template() const override
     {
-        return new MarketPlaceAppTemplate;
+        return std::make_unique<MarketPlaceAppTemplate>();
     };
 
     Request::ErrorCode pool_allocate(xmlrpc_c::paramList const& _paramList,
-                      Template *                 tmpl,
+                      std::unique_ptr<Template>  tmpl,
                       int&                       id,
                       RequestAttributes&         att) override;
 private:
@@ -748,13 +748,13 @@ public:
 
     /* --------------------------------------------------------------------- */
 
-    Template * get_object_template() const override
+    std::unique_ptr<Template> get_object_template() const override
     {
-        return new Template;
+        return std::make_unique<Template>();
     };
 
     Request::ErrorCode pool_allocate(xmlrpc_c::paramList const&  paramList,
-                                     Template *                  tmpl,
+                                     std::unique_ptr<Template>   tmpl,
                                      int&                        id,
                                      RequestAttributes&          att) override;
 };
@@ -781,13 +781,13 @@ public:
 
     /* --------------------------------------------------------------------- */
 
-    Template * get_object_template() const
+    std::unique_ptr<Template> get_object_template() const
     {
-        return new Template;
+        return std::make_unique<Template>();
     };
 
     Request::ErrorCode pool_allocate(xmlrpc_c::paramList const& _paramList,
-                      Template * tmpl,
+                      std::unique_ptr<Template> tmpl,
                       int& id,
                       RequestAttributes& att);
 
diff --git a/include/RequestManagerClone.h b/include/RequestManagerClone.h
index b3a812a2d4..83cb640acd 100644
--- a/include/RequestManagerClone.h
+++ b/include/RequestManagerClone.h
@@ -56,7 +56,7 @@ protected:
 	/**
      *  Function to clone the base template
      */
-    virtual Template * clone_template(PoolObjectSQL* obj) = 0;
+    virtual std::unique_ptr<Template> clone_template(PoolObjectSQL* obj) = 0;
 
 	/**
      *  Function to merge user/additional attributes in the cloned object
@@ -70,8 +70,8 @@ protected:
 	/**
      *  Function to allocated the new clone object
      */
-    virtual int pool_allocate(int source_id, Template * tmpl, int& id,
-            RequestAttributes& att) = 0;
+    virtual int pool_allocate(int source_id, std::unique_ptr<Template> tmpl,
+                              int& id, RequestAttributes& att) = 0;
 };
 
 /* ------------------------------------------------------------------------- */
@@ -107,20 +107,21 @@ protected:
                     bool recursive, const std::string& s_a,
                     RequestAttributes& att) override;
 
-    Template * clone_template(PoolObjectSQL* obj) override
+    std::unique_ptr<Template> clone_template(PoolObjectSQL* obj) override
     {
         return static_cast<VMTemplate*>(obj)->clone_template();
-    };
+    }
 
-    int pool_allocate(int sid, Template * tmpl, int& id,
+    int pool_allocate(int sid, std::unique_ptr<Template> tmpl, int& id,
                       RequestAttributes& att) override
     {
         VMTemplatePool * tpool     = static_cast<VMTemplatePool *>(pool);
-        VirtualMachineTemplate * t = static_cast<VirtualMachineTemplate*>(tmpl);
+        std::unique_ptr<VirtualMachineTemplate> t(
+            static_cast<VirtualMachineTemplate*>(tmpl.release()));
 
         return tpool->allocate(att.uid, att.gid, att.uname, att.gname, att.umask,
-                t, &id, att.resp_msg);
-    };
+                std::move(t), &id, att.resp_msg);
+    }
 
     ErrorCode merge(Template * tmpl, const std::string &s_a,
                     RequestAttributes& att) override
@@ -161,19 +162,21 @@ public:
 
 protected:
 
-    Template * clone_template(PoolObjectSQL* obj) override
+    std::unique_ptr<Template> clone_template(PoolObjectSQL* obj) override
     {
         return static_cast<VNTemplate*>(obj)->clone_template();
-    };
+    }
 
-    int pool_allocate(int sid, Template * tmpl, int& id, RequestAttributes& att) override
+    int pool_allocate(int sid, std::unique_ptr<Template> tmpl,
+                      int& id, RequestAttributes& att) override
     {
         VNTemplatePool * tpool     = static_cast<VNTemplatePool *>(pool);
-        VirtualNetworkTemplate * t = static_cast<VirtualNetworkTemplate*>(tmpl);
+        std::unique_ptr<VirtualNetworkTemplate> t(
+            static_cast<VirtualNetworkTemplate*>(tmpl.release()));
 
         return tpool->allocate(att.uid, att.gid, att.uname, att.gname, att.umask,
-                t, &id, att.resp_msg);
-    };
+                std::move(t), &id, att.resp_msg);
+    }
 
 };
 
@@ -197,12 +200,13 @@ public:
 
 protected:
 
-    Template * clone_template(PoolObjectSQL* obj) override
+    std::unique_ptr<Template> clone_template(PoolObjectSQL* obj) override
     {
         return static_cast<Document*>(obj)->clone_template();
-    };
+    }
 
-    int pool_allocate(int sid, Template * tmpl, int& id, RequestAttributes& att) override
+    int pool_allocate(int sid, std::unique_ptr<Template> tmpl,
+                      int& id, RequestAttributes& att) override
     {
         DocumentPool * docpool = static_cast<DocumentPool *>(pool);
         auto           doc     = docpool->get_ro(sid);
@@ -215,8 +219,8 @@ protected:
         int dtype = doc->get_document_type();
 
         return docpool->allocate(att.uid, att.gid, att.uname, att.gname,
-            att.umask, dtype, tmpl, &id, att.resp_msg);
-    };
+            att.umask, dtype, std::move(tmpl), &id, att.resp_msg);
+    }
 };
 
 /* ------------------------------------------------------------------------- */
@@ -239,18 +243,19 @@ public:
 
 protected:
 
-    Template * clone_template(PoolObjectSQL* obj) override
+    std::unique_ptr<Template> clone_template(PoolObjectSQL* obj) override
     {
         return static_cast<SecurityGroup*>(obj)->clone_template();
-    };
+    }
 
-    int pool_allocate(int sid, Template * tmpl, int& id, RequestAttributes& att) override
+    int pool_allocate(int sid, std::unique_ptr<Template> tmpl,
+                      int& id, RequestAttributes& att) override
     {
         SecurityGroupPool * sg = static_cast<SecurityGroupPool *>(pool);
 
         return sg->allocate(att.uid, att.gid, att.uname, att.gname, att.umask,
-                tmpl, &id, att.resp_msg);
-    };
+                std::move(tmpl), &id, att.resp_msg);
+    }
 };
 
 /* -------------------------------------------------------------------------- */
diff --git a/include/SecurityGroup.h b/include/SecurityGroup.h
index 0a751f013c..0c57092bd4 100644
--- a/include/SecurityGroup.h
+++ b/include/SecurityGroup.h
@@ -48,10 +48,10 @@ public:
      *  Returns a copy of the Template
      *    @return A copy of the Template
      */
-    Template * clone_template() const
+    std::unique_ptr<Template> clone_template() const
     {
-        return new Template(*obj_template);
-    };
+        return std::make_unique<Template>(*obj_template);
+    }
 
     /* ---------------------------------------------------------------------- */
     /*   Access VM Counter                                                    */
@@ -171,7 +171,7 @@ private:
                     const std::string& _uname,
                     const std::string& _gname,
                     int                _umask,
-                    Template*          sgroup_template);
+                    std::unique_ptr<Template> sgroup_template);
 
     /**
      *  Check that a rule is valid
@@ -228,9 +228,9 @@ private:
     /**
      *  Factory method for SecurityGroup templates
      */
-    Template * get_new_template() const override
+    std::unique_ptr<Template> get_new_template() const override
     {
-        return new Template;
+        return std::make_unique<Template>();
     }
 
     /**
diff --git a/include/SecurityGroupPool.h b/include/SecurityGroupPool.h
index eb7ac1d1f6..a26954e29d 100644
--- a/include/SecurityGroupPool.h
+++ b/include/SecurityGroupPool.h
@@ -55,7 +55,7 @@ public:
             const std::string& uname,
             const std::string& gname,
             int                umask,
-            Template *         sgroup_template,
+            std::unique_ptr<Template> sgroup_template,
             int *              oid,
             std::string&       error_str);
 
diff --git a/include/User.h b/include/User.h
index a7577484f9..c764ebd1c4 100644
--- a/include/User.h
+++ b/include/User.h
@@ -156,9 +156,9 @@ public:
     /**
      *  Factory method for image templates
      */
-    Template * get_new_template() const override
+    std::unique_ptr<Template> get_new_template() const override
     {
-        return new UserTemplate;
+        return std::make_unique<UserTemplate>();
     }
 
     /**
@@ -392,7 +392,7 @@ protected:
         groups("GROUPS"),
         session(0)
     {
-        obj_template = new UserTemplate;
+        obj_template = std::make_unique<UserTemplate>();
     }
 
     // *************************************************************************
diff --git a/include/VMGroup.h b/include/VMGroup.h
index 1c04dc3018..5462dc1371 100644
--- a/include/VMGroup.h
+++ b/include/VMGroup.h
@@ -114,7 +114,7 @@ private:
     // -------------------------------------------------------------------------
     VMGroup(int _uid, int _gid,
             const std::string& _uname, const std::string& _gname,
-            int _umask, Template * group_template);
+            int _umask, std::unique_ptr<Template> group_template);
 
     // -------------------------------------------------------------------------
     // Role Management
@@ -188,9 +188,9 @@ private:
     /**
      *  Factory method for VMGroup templates
      */
-    Template * get_new_template() const override
+    std::unique_ptr<Template> get_new_template() const override
     {
-        return new Template;
+        return std::make_unique<Template>();
     }
 
     // -------------------------------------------------------------------------
diff --git a/include/VMGroupPool.h b/include/VMGroupPool.h
index f9b4900807..255ea349c3 100644
--- a/include/VMGroupPool.h
+++ b/include/VMGroupPool.h
@@ -49,7 +49,8 @@ public:
      *   @return the oid assigned to the object, -1 in case of failure
      */
     int allocate(int uid, int gid, const std::string& uname,
-        const std::string& gname, int umask, Template * vmgrp_tmpl, int * oid,
+        const std::string& gname, int umask,
+        std::unique_ptr<Template> vmgrp_tmpl, int * oid,
         std::string& error_str);
 
     /**
diff --git a/include/VMTemplate.h b/include/VMTemplate.h
index d2cff6ff58..a089aed8f1 100644
--- a/include/VMTemplate.h
+++ b/include/VMTemplate.h
@@ -57,20 +57,19 @@ public:
     /**
      *  Factory method for virtual machine templates
      */
-    Template * get_new_template() const override
+    std::unique_ptr<Template> get_new_template() const override
     {
-        return new VirtualMachineTemplate;
+        return std::make_unique<VirtualMachineTemplate>();
     }
 
     /**
      *  Returns a copy of the VirtualMachineTemplate
      *    @return A copy of the VirtualMachineTemplate
      */
-    VirtualMachineTemplate * clone_template() const
+    std::unique_ptr<VirtualMachineTemplate> clone_template() const
     {
-        return new VirtualMachineTemplate(
-                *(static_cast<VirtualMachineTemplate *>(obj_template)));
-    };
+        return std::make_unique<VirtualMachineTemplate>(*obj_template);
+    }
 
     /**
      * Returns a copy of the DISK attributes of this template, the attributes
@@ -179,7 +178,7 @@ protected:
                const std::string& uname,
                const std::string& gname,
                int umask,
-               VirtualMachineTemplate * _template_contents);
+               std::unique_ptr<Template> _template_contents);
 
     // *************************************************************************
     // DataBase implementation
diff --git a/include/VMTemplatePool.h b/include/VMTemplatePool.h
index 1d77910d85..a55f370968 100644
--- a/include/VMTemplatePool.h
+++ b/include/VMTemplatePool.h
@@ -51,7 +51,7 @@ public:
                  const std::string&       uname,
                  const std::string&       gname,
                  int                      umask,
-                 VirtualMachineTemplate * template_contents,
+                 std::unique_ptr<VirtualMachineTemplate> template_contents,
                  int *                    oid,
                  std::string&             error_str);
 
diff --git a/include/VNTemplate.h b/include/VNTemplate.h
index b6d307891e..78f66180f0 100644
--- a/include/VNTemplate.h
+++ b/include/VNTemplate.h
@@ -46,20 +46,19 @@ public:
     /**
      *  Factory method for virtual machine templates
      */
-    Template * get_new_template() const override
+    std::unique_ptr<Template> get_new_template() const override
     {
-        return new VirtualNetworkTemplate;
+        return std::make_unique<VirtualNetworkTemplate>();
     }
 
     /**
      *  Returns a copy of the VirtualNetworkTemplate
      *    @return A copy of the VirtualNetworkTemplate
      */
-    VirtualNetworkTemplate * clone_template() const
+    std::unique_ptr<VirtualNetworkTemplate> clone_template() const
     {
-        return new VirtualNetworkTemplate(
-                *(static_cast<VirtualNetworkTemplate *>(obj_template)));
-    };
+        return std::make_unique<VirtualNetworkTemplate>(*obj_template);
+    }
 
 private:
     // -------------------------------------------------------------------------
@@ -115,7 +114,7 @@ protected:
                const std::string& uname,
                const std::string& gname,
                int umask,
-               VirtualNetworkTemplate * _template_contents);
+               std::unique_ptr<VirtualNetworkTemplate> _template_contents);
 
     // *************************************************************************
     // DataBase implementation
diff --git a/include/VNTemplatePool.h b/include/VNTemplatePool.h
index 83a9f80cc9..efc8a12c58 100644
--- a/include/VNTemplatePool.h
+++ b/include/VNTemplatePool.h
@@ -51,7 +51,7 @@ public:
                  const std::string&       uname,
                  const std::string&       gname,
                  int                      umask,
-                 VirtualNetworkTemplate * template_contents,
+                 std::unique_ptr<VirtualNetworkTemplate> template_contents,
                  int *                    oid,
                  std::string&             error_str);
 
diff --git a/include/Vdc.h b/include/Vdc.h
index fb78171d47..3cad751502 100644
--- a/include/Vdc.h
+++ b/include/Vdc.h
@@ -322,7 +322,7 @@ private:
     // Constructor
     // *************************************************************************
 
-    Vdc(int id, Template* vdc_template);
+    Vdc(int id, std::unique_ptr<Template> vdc_template);
 
     // *************************************************************************
     // Attributes (Private)
@@ -382,9 +382,9 @@ private:
     /**
      *  Factory method for Vdc templates
      */
-    Template * get_new_template() const override
+    std::unique_ptr<Template> get_new_template() const override
     {
-        return new Template;
+        return std::make_unique<Template>();
     }
 };
 
diff --git a/include/VdcPool.h b/include/VdcPool.h
index a4fd550fde..2967f76643 100644
--- a/include/VdcPool.h
+++ b/include/VdcPool.h
@@ -43,7 +43,7 @@ public:
      *
      *    @return the oid assigned to the object, -1 in case of failure
      */
-    int allocate(Template *   vdc_template,
+    int allocate(std::unique_ptr<Template> vdc_template,
                  int *        oid,
                  std::string& error_str);
 
diff --git a/include/VirtualMachine.h b/include/VirtualMachine.h
index 0b170c04c4..0a827cba27 100644
--- a/include/VirtualMachine.h
+++ b/include/VirtualMachine.h
@@ -891,20 +891,19 @@ public:
     /**
      *  Factory method for virtual machine templates
      */
-    Template * get_new_template() const override
+    std::unique_ptr<Template> get_new_template() const override
     {
-        return new VirtualMachineTemplate;
+        return std::make_unique<VirtualMachineTemplate>();
     }
 
     /**
      *  Returns a copy of the VirtualMachineTemplate
      *    @return A copy of the VirtualMachineTemplate
      */
-    VirtualMachineTemplate * clone_template() const
+    std::unique_ptr<VirtualMachineTemplate> clone_template() const
     {
-        return new VirtualMachineTemplate(
-                *(static_cast<VirtualMachineTemplate *>(obj_template)));
-    };
+        return std::make_unique<VirtualMachineTemplate>(*obj_template);
+    }
 
     /**
      *  This function replaces the *user template*.
@@ -1171,7 +1170,7 @@ public:
      *    @param err description if any
      *    @return template with the attributes
      */
-    VirtualMachineTemplate * get_updateconf_template() const;
+    std::unique_ptr<VirtualMachineTemplate> get_updateconf_template() const;
 
     // -------------------------------------------------------------------------
     // "Save as" Disk related functions (save_as hot)
@@ -1751,7 +1750,7 @@ private:
     /**
      *  User template to store custom metadata. This template can be updated
      */
-    VirtualMachineTemplate * user_obj_template;
+    std::unique_ptr<VirtualMachineTemplate> user_obj_template;
 
     /**
      *  Monitoring information for the VM
@@ -2129,12 +2128,12 @@ private:
     /**
      *  Encrypt all secret attributes
      */
-    virtual void encrypt() override;
+    void encrypt() override;
 
     /**
      *  Decrypt all secret attributes
      */
-    virtual void decrypt() override;
+    void decrypt() override;
 
 protected:
 
@@ -2148,7 +2147,7 @@ protected:
                    const std::string& uname,
                    const std::string& gname,
                    int umask,
-                   VirtualMachineTemplate * _vm_template);
+                   std::unique_ptr<VirtualMachineTemplate> _vm_template);
 
     // *************************************************************************
     // DataBase implementation
diff --git a/include/VirtualMachineDisk.h b/include/VirtualMachineDisk.h
index 2d4ee9bc26..d8d30de6d3 100644
--- a/include/VirtualMachineDisk.h
+++ b/include/VirtualMachineDisk.h
@@ -494,7 +494,7 @@ public:
      *    @param ds_quotas templates for quota updates
      */
     static void image_ds_quotas(Template * tmpl,
-                                std::vector<Template *>& ds_quotas);
+                                std::vector<std::unique_ptr<Template>>& ds_quotas);
 
     /**
      *  Sets Datastore information on volatile disks
diff --git a/include/VirtualMachinePool.h b/include/VirtualMachinePool.h
index da172bbf1d..f9de184983 100644
--- a/include/VirtualMachinePool.h
+++ b/include/VirtualMachinePool.h
@@ -61,7 +61,7 @@ public:
         const std::string&       uname,
         const std::string&       gname,
         int                      umask,
-        VirtualMachineTemplate * vm_template,
+        std::unique_ptr<VirtualMachineTemplate> vm_template,
         int *                    oid,
         std::string&             error_str,
         bool                     on_hold = false);
diff --git a/include/VirtualMachineTemplate.h b/include/VirtualMachineTemplate.h
index a3adf0f342..89cefd06d0 100644
--- a/include/VirtualMachineTemplate.h
+++ b/include/VirtualMachineTemplate.h
@@ -37,7 +37,7 @@ public:
 
     ~VirtualMachineTemplate(){};
 
-    VirtualMachineTemplate(VirtualMachineTemplate& vmt):Template(vmt){};
+    VirtualMachineTemplate(const Template& vmt):Template(vmt){};
 
     VirtualMachineTemplate& operator=(const VirtualMachineTemplate& t)
     {
diff --git a/include/VirtualNetwork.h b/include/VirtualNetwork.h
index 5560656047..daa647f116 100644
--- a/include/VirtualNetwork.h
+++ b/include/VirtualNetwork.h
@@ -202,9 +202,9 @@ public:
     /**
      *  Factory method for virtual network templates
      */
-    Template * get_new_template() const override
+    std::unique_ptr<Template> get_new_template() const override
     {
-        return new VirtualNetworkTemplate;
+        return std::make_unique<VirtualNetworkTemplate>();
     }
 
     /**
@@ -555,10 +555,9 @@ public:
     /**
      *    @return A copy of the VNET Template
      */
-    VirtualNetworkTemplate * clone_template() const
+    std::unique_ptr<VirtualNetworkTemplate> clone_template() const
     {
-        VirtualNetworkTemplate * new_vn = new VirtualNetworkTemplate(
-                *(static_cast<VirtualNetworkTemplate *>(obj_template)));
+        auto new_vn = std::make_unique<VirtualNetworkTemplate>(*obj_template);
 
         //Clone non-template attributes
         //  AUTOMATIC_VLAN_ID
@@ -587,12 +586,12 @@ public:
     /**
      *  Encrypt all secret attributes
      */
-    virtual void encrypt() override;
+    void encrypt() override;
 
     /**
      *  Decrypt all secret attributes
      */
-    virtual void decrypt() override;
+    void decrypt() override;
 
 private:
 
@@ -808,7 +807,7 @@ private:
                    int                      _umask,
                    int                      _parent_vid,
                    const std::set<int>      &_cluster_ids,
-                   VirtualNetworkTemplate * _vn_template = 0);
+                   std::unique_ptr<VirtualNetworkTemplate> _vn_template = 0);
 
     // *************************************************************************
     // DataBase implementation
diff --git a/include/VirtualNetworkPool.h b/include/VirtualNetworkPool.h
index c41460f4d6..b522aca39e 100644
--- a/include/VirtualNetworkPool.h
+++ b/include/VirtualNetworkPool.h
@@ -66,7 +66,7 @@ public:
         const std::string&          gname,
         int                         umask,
         int                         parent_vid,
-        VirtualNetworkTemplate *    vn_template,
+        std::unique_ptr<VirtualNetworkTemplate> vn_template,
         int *                       oid,
         const std::set<int>         &cluster_ids,
         std::string&                error_str);
diff --git a/include/VirtualNetworkTemplate.h b/include/VirtualNetworkTemplate.h
index d45f384569..f5eadeef57 100644
--- a/include/VirtualNetworkTemplate.h
+++ b/include/VirtualNetworkTemplate.h
@@ -34,7 +34,7 @@ public:
 
     ~VirtualNetworkTemplate(){};
 
-    VirtualNetworkTemplate(VirtualNetworkTemplate& vnt):Template(vnt){};
+    VirtualNetworkTemplate(const Template& vnt):Template(vnt){};
 
     // -------------------------------------------------------------------------
     // Restricted attributes interface implementation
diff --git a/include/VirtualRouter.h b/include/VirtualRouter.h
index b72c0262b7..c581035696 100644
--- a/include/VirtualRouter.h
+++ b/include/VirtualRouter.h
@@ -72,19 +72,19 @@ public:
     /**
      *  Factory method for VirtualRouter templates
      */
-    Template * get_new_template() const override
+    std::unique_ptr<Template> get_new_template() const override
     {
-        return new Template;
+        return std::make_unique<Template>();
     }
 
     /**
      *  Returns a copy of the Template
      *    @return A copy of the VirtualMachineTemplate
      */
-    Template * clone_template() const
+    std::unique_ptr<Template> clone_template() const
     {
-        return new Template(obj_template);
-    };
+        return std::make_unique<Template>(obj_template.get());
+    }
 
     Template * get_vm_template() const;
 
@@ -225,7 +225,7 @@ private:
                   const std::string& uname,
                   const std::string& gname,
                   int umask,
-                  Template * _template_contents);
+                  std::unique_ptr<Template> _template_contents);
 
     // *************************************************************************
     // DataBase implementation
diff --git a/include/VirtualRouterPool.h b/include/VirtualRouterPool.h
index b127e60465..45fccd7f26 100644
--- a/include/VirtualRouterPool.h
+++ b/include/VirtualRouterPool.h
@@ -51,12 +51,12 @@ public:
                  const std::string&       uname,
                  const std::string&       gname,
                  int                      umask,
-                 Template *               template_contents,
+                 std::unique_ptr<Template> template_contents,
                  int *                    oid,
                  std::string&             error_str)
     {
         *oid = PoolSQL::allocate(
-            new VirtualRouter(-1, uid, gid, uname, gname, umask, template_contents),
+            new VirtualRouter(-1, uid, gid, uname, gname, umask, move(template_contents)),
             error_str);
 
         return *oid;
diff --git a/include/Zone.h b/include/Zone.h
index 30e0e25c6f..afeb1f933e 100644
--- a/include/Zone.h
+++ b/include/Zone.h
@@ -94,7 +94,7 @@ private:
     // -------------------------------------------------------------------------
     // Constructor
     // -------------------------------------------------------------------------
-    Zone(int id, Template* zone_template);
+    Zone(int id, std::unique_ptr<Template> zone_template);
 
     // -------------------------------------------------------------------------
     // Zone servers
@@ -143,9 +143,9 @@ private:
     /**
      *  Factory method for Zone templates
      */
-    Template * get_new_template() const override
+    std::unique_ptr<Template> get_new_template() const override
     {
-        return new Template;
+        return std::make_unique<Template>();
     }
 
     /**
diff --git a/include/ZonePool.h b/include/ZonePool.h
index b5f2a1e193..0068bde3aa 100644
--- a/include/ZonePool.h
+++ b/include/ZonePool.h
@@ -43,7 +43,7 @@ public:
      *
      *    @return the oid assigned to the object, -1 in case of failure
      */
-    int allocate(Template *   zone_template,
+    int allocate(std::unique_ptr<Template> zone_template,
                  int *        oid,
                  std::string& error_str);
 
diff --git a/src/acl/AclManager.cc b/src/acl/AclManager.cc
index 88440e74fc..06e80e121b 100644
--- a/src/acl/AclManager.cc
+++ b/src/acl/AclManager.cc
@@ -133,7 +133,7 @@ int AclManager::start()
 
     if (is_federation_slave)
     {
-        timer_thread.reset(new Timer(timer_period, [this](){timer_action();}));
+        timer_thread = make_unique<Timer>(timer_period, [this](){timer_action();});
     }
 
     NebulaLog::log("ACL",Log::INFO,"ACL Manager started.");
diff --git a/src/cluster/Cluster.cc b/src/cluster/Cluster.cc
index 9e7aa2b75c..f1fd30639e 100644
--- a/src/cluster/Cluster.cc
+++ b/src/cluster/Cluster.cc
@@ -31,7 +31,7 @@ using namespace std;
 Cluster::Cluster(
         int id,
         const string& name,
-        ClusterTemplate*  cl_template,
+        std::unique_ptr<ClusterTemplate>  cl_template,
         const VectorAttribute& vnc_conf):
             PoolObjectSQL(id,CLUSTER,name,-1,-1,"","",one_db::cluster_table),
             hosts("HOSTS"),
@@ -39,13 +39,13 @@ Cluster::Cluster(
             vnets("VNETS"),
             vnc_bitmap(vnc_conf, id, one_db::cluster_bitmap_table)
 {
-    if (cl_template != 0)
+    if (cl_template)
     {
-        obj_template = cl_template;
+        obj_template = move(cl_template);
     }
     else
     {
-        obj_template = new ClusterTemplate;
+        obj_template = make_unique<ClusterTemplate>();
     }
 
     add_template_attribute("RESERVED_CPU", "");
diff --git a/src/common/Attribute.cc b/src/common/Attribute.cc
index 2eff38cb95..485335669e 100644
--- a/src/common/Attribute.cc
+++ b/src/common/Attribute.cc
@@ -26,10 +26,9 @@ using namespace std;
 const char * VectorAttribute::magic_sep      = "@^_^@";
 const int    VectorAttribute::magic_sep_size = 5;
 
-string * VectorAttribute::marshall(const char * _sep) const
+string VectorAttribute::marshall(const char * _sep) const
 {
     ostringstream os;
-    string *      rs;
     const char *  my_sep;
 
     map<string,string>::const_iterator it;
@@ -57,11 +56,7 @@ string * VectorAttribute::marshall(const char * _sep) const
         os << my_sep << it->first << "=" << it->second;
     }
 
-    rs = new string;
-
-    *rs = os.str();
-
-    return rs;
+    return os.str();
 }
 
 /* -------------------------------------------------------------------------- */
diff --git a/src/datastore/Datastore.cc b/src/datastore/Datastore.cc
index 24a38ddb1e..8c61e8a96f 100644
--- a/src/datastore/Datastore.cc
+++ b/src/datastore/Datastore.cc
@@ -34,7 +34,7 @@ Datastore::Datastore(
         const string&       uname,
         const string&       gname,
         int                 umask,
-        DatastoreTemplate*  ds_template,
+        unique_ptr<DatastoreTemplate>  ds_template,
         const set<int>      &cluster_ids):
             PoolObjectSQL(-1,DATASTORE,"",uid,gid,uname,gname,one_db::ds_table),
             Clusterable(cluster_ids),
@@ -49,13 +49,13 @@ Datastore::Datastore(
             state(READY),
             images("IMAGES")
 {
-    if (ds_template != 0)
+    if (ds_template)
     {
-        obj_template = ds_template;
+        obj_template = move(ds_template);
     }
     else
     {
-        obj_template = new DatastoreTemplate;
+        obj_template = make_unique<DatastoreTemplate>();
     }
 
     set_umask(umask);
diff --git a/src/datastore/DatastorePool.cc b/src/datastore/DatastorePool.cc
index 0e36e1d2b9..d34ed2e209 100644
--- a/src/datastore/DatastorePool.cc
+++ b/src/datastore/DatastorePool.cc
@@ -62,7 +62,6 @@ DatastorePool::DatastorePool(
 
     if (get_lastOID() == -1) //lastOID is set in PoolSQL::init_cb
     {
-        DatastoreTemplate * ds_tmpl;
         int      rc;
         set<int> cluster_ids;
 
@@ -76,7 +75,7 @@ DatastorePool::DatastorePool(
             << "TYPE   = SYSTEM_DS" << endl
             << "TM_MAD = ssh";
 
-        ds_tmpl = new DatastoreTemplate;
+        auto ds_tmpl = make_unique<DatastoreTemplate>();
         rc = ds_tmpl->parse_str_or_xml(oss.str(), error_str);
 
         if( rc < 0 )
@@ -89,7 +88,7 @@ DatastorePool::DatastorePool(
                 UserPool::oneadmin_name,
                 GroupPool::ONEADMIN_NAME,
                 0137,
-                ds_tmpl,
+                move(ds_tmpl),
                 &rc,
                 cluster_ids,
                 error_str);
@@ -109,7 +108,7 @@ DatastorePool::DatastorePool(
             << "DS_MAD = fs" << endl
             << "TM_MAD = ssh";
 
-        ds_tmpl = new DatastoreTemplate;
+        ds_tmpl = make_unique<DatastoreTemplate>();
         rc = ds_tmpl->parse_str_or_xml(oss.str(), error_str);
 
         if( rc < 0 )
@@ -122,7 +121,7 @@ DatastorePool::DatastorePool(
                 UserPool::oneadmin_name,
                 GroupPool::ONEADMIN_NAME,
                 0137,
-                ds_tmpl,
+                move(ds_tmpl),
                 &rc,
                 cluster_ids,
                 error_str);
@@ -142,7 +141,7 @@ DatastorePool::DatastorePool(
             << "DS_MAD = fs" << endl
             << "TM_MAD = ssh";
 
-        ds_tmpl = new DatastoreTemplate;
+        ds_tmpl = make_unique<DatastoreTemplate>();
         rc = ds_tmpl->parse_str_or_xml(oss.str(), error_str);
 
         if( rc < 0 )
@@ -155,7 +154,7 @@ DatastorePool::DatastorePool(
                 UserPool::oneadmin_name,
                 GroupPool::ONEADMIN_NAME,
                 0137,
-                ds_tmpl,
+                move(ds_tmpl),
                 &rc,
                 cluster_ids,
                 error_str);
@@ -191,7 +190,7 @@ int DatastorePool::allocate(
         const string&       uname,
         const string&       gname,
         int                 umask,
-        DatastoreTemplate * ds_template,
+        std::unique_ptr<DatastoreTemplate> ds_template,
         int *               oid,
         const set<int>      &cluster_ids,
         string&             error_str)
@@ -204,7 +203,7 @@ int DatastorePool::allocate(
     ostringstream oss;
 
     ds = new Datastore(uid, gid, uname, gname, umask,
-            ds_template, cluster_ids);
+            move(ds_template), cluster_ids);
 
     // -------------------------------------------------------------------------
     // Check name & duplicates
diff --git a/src/dm/DispatchManagerActions.cc b/src/dm/DispatchManagerActions.cc
index d1deb79dc7..f16268152e 100644
--- a/src/dm/DispatchManagerActions.cc
+++ b/src/dm/DispatchManagerActions.cc
@@ -286,8 +286,6 @@ void DispatchManager::free_vm_resources(unique_ptr<VirtualMachine> vm,
 {
     vector<Template *> ds_quotas;
 
-    Template * quota_tmpl;
-
     int vmid;
     int uid;
     int gid;
@@ -295,7 +293,7 @@ void DispatchManager::free_vm_resources(unique_ptr<VirtualMachine> vm,
     int vrid = -1;
     unsigned int port;
 
-    quota_tmpl = vm->clone_template();
+    auto quota_tmpl = vm->clone_template();
 
     if ( (vm->get_state() == VirtualMachine::ACTIVE) ||
          (vm->get_state() == VirtualMachine::PENDING) ||
@@ -352,9 +350,7 @@ void DispatchManager::free_vm_resources(unique_ptr<VirtualMachine> vm,
 
     vm.reset(); //force unlock of vm mutex
 
-    Quotas::vm_del(uid, gid, quota_tmpl);
-
-    delete quota_tmpl;
+    Quotas::vm_del(uid, gid, quota_tmpl.get());
 
     if ( !ds_quotas.empty() )
     {
diff --git a/src/document/Document.cc b/src/document/Document.cc
index 3a9a6ead4f..9fdc143f42 100644
--- a/src/document/Document.cc
+++ b/src/document/Document.cc
@@ -30,17 +30,17 @@ Document::Document( int id,
                     const string& _gname,
                     int _umask,
                     int _type,
-                    Template * _template_contents)
+                    std::unique_ptr<Template> _template_contents)
     : PoolObjectSQL(id,DOCUMENT,"",_uid,_gid,_uname,_gname,one_db::doc_table)
     , type(_type)
 {
-    if (_template_contents != 0)
+    if (_template_contents)
     {
-        obj_template = _template_contents;
+        obj_template = move(_template_contents);
     }
     else
     {
-        obj_template = new Template;
+        obj_template = make_unique<Template>();
     }
 
     set_umask(_umask);
diff --git a/src/group/Group.cc b/src/group/Group.cc
index fd18fa831b..c83375df1f 100644
--- a/src/group/Group.cc
+++ b/src/group/Group.cc
@@ -34,7 +34,7 @@ Group::Group(int id, const string& name):
     // Allow users in this group to see it
     group_u = 1;
 
-    obj_template = new GroupTemplate;
+    obj_template = make_unique<GroupTemplate>();
 }
 
 /* ************************************************************************ */
diff --git a/src/hm/Hook.cc b/src/hm/Hook.cc
index 50a662519e..6077b80f1b 100644
--- a/src/hm/Hook.cc
+++ b/src/hm/Hook.cc
@@ -30,19 +30,19 @@ using namespace std;
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 
-Hook::Hook(Template * tmpl):
+Hook::Hook(unique_ptr<Template> tmpl):
     PoolObjectSQL(-1, HOOK, "", -1, -1, "", "", one_db::hook_table),
     type(HookType::UNDEFINED), cmd(""), remote(false), _hook(0)
 {
-    if (tmpl != 0)
+    if (tmpl)
     {
-        obj_template = tmpl;
+        obj_template = move(tmpl);
     }
     else
     {
-        obj_template = new Template();
+        obj_template = make_unique<Template>();
     }
-};
+}
 
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
@@ -130,7 +130,7 @@ int Hook::from_xml(const std::string& xml)
         return -1;
     }
 
-    rc += _hook->from_template(obj_template, error_msg);
+    rc += _hook->from_template(obj_template.get(), error_msg);
 
     get_template_attribute("COMMAND", cmd);
     get_template_attribute("REMOTE",  remote);
@@ -176,7 +176,7 @@ int Hook::post_update_template(string& error)
         replace_template_attribute("REMOTE", remote);
     }
 
-    return _hook->post_update_template(obj_template, error);
+    return _hook->post_update_template(obj_template.get(), error);
 }
 
 /* -------------------------------------------------------------------------- */
@@ -234,7 +234,7 @@ int Hook::insert(SqlDB *db, std::string& error_str)
         goto error_common;
     }
 
-    rc = _hook->parse_template(obj_template, error_str);
+    rc = _hook->parse_template(obj_template.get(), error_str);
 
     if (rc == -1)
     {
diff --git a/src/hm/HookPool.cc b/src/hm/HookPool.cc
index bde9a8031f..e82d47e5b8 100644
--- a/src/hm/HookPool.cc
+++ b/src/hm/HookPool.cc
@@ -21,7 +21,7 @@
 using namespace std;
 
 
-int HookPool::allocate (Template * tmpl, string& error_str)
+int HookPool::allocate(unique_ptr<Template> tmpl, string& error_str)
 {
     Hook * hook;
     int db_oid;
@@ -45,7 +45,7 @@ int HookPool::allocate (Template * tmpl, string& error_str)
         goto error_duplicated;
     }
 
-    hook = new Hook(tmpl);
+    hook = new Hook(move(tmpl));
 
     oid = PoolSQL::allocate(hook, error_str);
 
diff --git a/src/host/Host.cc b/src/host/Host.cc
index 678d51d2ab..f7c6a2ab70 100644
--- a/src/host/Host.cc
+++ b/src/host/Host.cc
@@ -44,7 +44,7 @@ Host::Host(
         vmm_mad_name(_vmm_mad_name),
         vm_collection("VMS")
 {
-    obj_template = new HostTemplate;
+    obj_template = make_unique<HostTemplate>();
 
     add_template_attribute("RESERVED_CPU", "");
     add_template_attribute("RESERVED_MEM", "");
diff --git a/src/image/Image.cc b/src/image/Image.cc
index b61f214fa2..36ed41116d 100644
--- a/src/image/Image.cc
+++ b/src/image/Image.cc
@@ -39,7 +39,7 @@ Image::Image(int             _uid,
              const string&   _uname,
              const string&   _gname,
              int             _umask,
-             ImageTemplate * _image_template):
+             unique_ptr<ImageTemplate> _image_template):
         PoolObjectSQL(-1,IMAGE,"",_uid,_gid,_uname,_gname,one_db::image_table),
         type(OS),
         disk_type(FILE),
@@ -60,13 +60,13 @@ Image::Image(int             _uid,
         snapshots(-1, Snapshots::DENY),
         target_snapshot(-1)
     {
-        if (_image_template != 0)
+        if (_image_template)
         {
-            obj_template = _image_template;
+            obj_template = move(_image_template);
         }
         else
         {
-            obj_template = new ImageTemplate;
+            obj_template = make_unique<ImageTemplate>();
         }
 
         set_umask(_umask);
@@ -716,11 +716,10 @@ int Image::set_type(string& _type, string& error)
 /* ------------------------------------------------------------------------ */
 /* ------------------------------------------------------------------------ */
 
-ImageTemplate * Image::clone_template(const string& new_name) const
+std::unique_ptr<ImageTemplate> Image::clone_template(const string& new_name) const
 {
 
-    ImageTemplate * tmpl = new ImageTemplate(
-            *(static_cast<ImageTemplate *>(obj_template)));
+    auto tmpl = make_unique<ImageTemplate>(*obj_template);
 
     tmpl->replace("NAME",   new_name);
     tmpl->replace("TYPE",   type_to_str(type));
diff --git a/src/image/ImagePool.cc b/src/image/ImagePool.cc
index 83925f2b13..8242772408 100644
--- a/src/image/ImagePool.cc
+++ b/src/image/ImagePool.cc
@@ -82,7 +82,7 @@ int ImagePool::allocate (
         const string&            uname,
         const string&            gname,
         int                      umask,
-        ImageTemplate *          img_template,
+        unique_ptr<ImageTemplate> img_template,
         int                      ds_id,
         const string&            ds_name,
         Image::DiskType          disk_type,
@@ -108,7 +108,7 @@ int ImagePool::allocate (
     int db_oid;
     int rc;
 
-    img = new Image(uid, gid, uname, gname, umask, img_template);
+    img = new Image(uid, gid, uname, gname, umask, move(img_template));
 
     // -------------------------------------------------------------------------
     // Check name & duplicates
diff --git a/src/market/MarketPlace.cc b/src/market/MarketPlace.cc
index f4a96b8c1d..453d7ddc61 100644
--- a/src/market/MarketPlace.cc
+++ b/src/market/MarketPlace.cc
@@ -33,7 +33,7 @@ MarketPlace::MarketPlace(
     const std::string&    uname,
     const std::string&    gname,
     int                   umask,
-    MarketPlaceTemplate * mp_template):
+    unique_ptr<MarketPlaceTemplate> mp_template):
         PoolObjectSQL(-1, MARKETPLACE, "", uid, gid, uname, gname, one_db::mp_table),
         market_mad(""),
         total_mb(0),
@@ -42,13 +42,13 @@ MarketPlace::MarketPlace(
         zone_id(-1),
         marketapps("MARKETPLACEAPPS")
 {
-    if (mp_template != 0)
+    if (mp_template)
     {
-        obj_template = mp_template;
+        obj_template = move(mp_template);
     }
     else
     {
-        obj_template = new MarketPlaceTemplate;
+        obj_template = make_unique<MarketPlaceTemplate>();
     }
 
     set_umask(umask);
diff --git a/src/market/MarketPlaceApp.cc b/src/market/MarketPlaceApp.cc
index 12f61195fc..221d43f593 100644
--- a/src/market/MarketPlaceApp.cc
+++ b/src/market/MarketPlaceApp.cc
@@ -33,7 +33,7 @@ MarketPlaceApp::MarketPlaceApp(
     const std::string&       uname,
     const std::string&       gname,
     int                      umask,
-    MarketPlaceAppTemplate * app_template):
+    unique_ptr<MarketPlaceAppTemplate> app_template):
         PoolObjectSQL(-1, MARKETPLACEAPP, "", uid, gid, uname, gname, one_db::mp_app_table),
         source(""),
         md5(""),
@@ -47,17 +47,17 @@ MarketPlaceApp::MarketPlaceApp(
         type(IMAGE),
         zone_id(-1)
 {
-    if (app_template != 0)
+    if (app_template)
     {
-        obj_template = app_template;
+        obj_template = move(app_template);
     }
     else
     {
-        obj_template = new MarketPlaceAppTemplate;
+        obj_template = make_unique<MarketPlaceAppTemplate>();
     }
 
     set_umask(umask);
-};
+}
 
 /* ************************************************************************ */
 /* MartketPlaceApp:: Database Access Functions                              */
diff --git a/src/market/MarketPlaceAppPool.cc b/src/market/MarketPlaceAppPool.cc
index e34b77b176..a09aaeafb2 100644
--- a/src/market/MarketPlaceAppPool.cc
+++ b/src/market/MarketPlaceAppPool.cc
@@ -73,7 +73,7 @@ int MarketPlaceAppPool:: allocate(
             const std::string& uname,
             const std::string& gname,
             int                umask,
-            MarketPlaceAppTemplate * apptemplate,
+            std::unique_ptr<MarketPlaceAppTemplate> apptemplate,
             int                mp_id,
             const std::string& mp_name,
             int *              oid,
@@ -90,7 +90,7 @@ int MarketPlaceAppPool:: allocate(
     // -------------------------------------------------------------------------
     // Build the marketplace app object
     // -------------------------------------------------------------------------
-    mp = new MarketPlaceApp(uid, gid, uname, gname, umask, apptemplate);
+    mp = new MarketPlaceApp(uid, gid, uname, gname, umask, move(apptemplate));
 
     mp->market_id   = mp_id;
     mp->market_name = mp_name;
diff --git a/src/market/MarketPlacePool.cc b/src/market/MarketPlacePool.cc
index a1b9880dd2..3a9dbc94f5 100644
--- a/src/market/MarketPlacePool.cc
+++ b/src/market/MarketPlacePool.cc
@@ -65,10 +65,10 @@ MarketPlacePool::MarketPlacePool(SqlDB * db, bool is_federation_slave)
 
         string error;
 
-        MarketPlaceTemplate * default_tmpl = new MarketPlaceTemplate;
-        MarketPlaceTemplate * lxc_tmpl     = new MarketPlaceTemplate;
-        MarketPlaceTemplate * tk_tmpl      = new MarketPlaceTemplate;
-        MarketPlaceTemplate * dh_tmpl      = new MarketPlaceTemplate;
+        auto default_tmpl = make_unique<MarketPlaceTemplate>();
+        auto lxc_tmpl     = make_unique<MarketPlaceTemplate>();
+        auto tk_tmpl      = make_unique<MarketPlaceTemplate>();
+        auto dh_tmpl      = make_unique<MarketPlaceTemplate>();
 
         char * error_parse;
 
@@ -83,7 +83,7 @@ MarketPlacePool::MarketPlacePool(SqlDB * db, bool is_federation_slave)
                 oneadmin->get_uname(),
                 oneadmin->get_gname(),
                 oneadmin->get_umask(),
-                default_tmpl);
+                move(default_tmpl));
 
         MarketPlace * lxc_marketplace = new MarketPlace(
                 oneadmin->get_uid(),
@@ -91,7 +91,7 @@ MarketPlacePool::MarketPlacePool(SqlDB * db, bool is_federation_slave)
                 oneadmin->get_uname(),
                 oneadmin->get_gname(),
                 oneadmin->get_umask(),
-                lxc_tmpl);
+                move(lxc_tmpl));
 
         MarketPlace * tk_marketplace = new MarketPlace(
                 oneadmin->get_uid(),
@@ -99,7 +99,7 @@ MarketPlacePool::MarketPlacePool(SqlDB * db, bool is_federation_slave)
                 oneadmin->get_uname(),
                 oneadmin->get_gname(),
                 oneadmin->get_umask(),
-                tk_tmpl);
+                move(tk_tmpl));
 
         MarketPlace * dh_marketplace = new MarketPlace(
                 oneadmin->get_uid(),
@@ -107,7 +107,7 @@ MarketPlacePool::MarketPlacePool(SqlDB * db, bool is_federation_slave)
                 oneadmin->get_uname(),
                 oneadmin->get_gname(),
                 oneadmin->get_umask(),
-                dh_tmpl);
+                move(dh_tmpl));
 
         marketplace->set_permissions(1,1,1, 1,0,0, 1,0,0, error);
         lxc_marketplace->set_permissions(1,1,1, 1,0,0, 1,0,0, error);
@@ -156,7 +156,7 @@ int MarketPlacePool::allocate(
         const std::string&    uname,
         const std::string&    gname,
         int                   umask,
-        MarketPlaceTemplate * mp_template,
+        unique_ptr<MarketPlaceTemplate> mp_template,
         int *                 oid,
         std::string&          error_str)
 {
@@ -170,7 +170,7 @@ int MarketPlacePool::allocate(
     // -------------------------------------------------------------------------
     // Build the marketplace object
     // -------------------------------------------------------------------------
-    mp = new MarketPlace(uid, gid, uname, gname, umask, mp_template);
+    mp = new MarketPlace(uid, gid, uname, gname, umask, move(mp_template));
 
     mp->get_template_attribute("NAME", name);
 
diff --git a/src/monitor/include/HostMonitorManager.h b/src/monitor/include/HostMonitorManager.h
index 4c41f29e14..e8ba135981 100644
--- a/src/monitor/include/HostMonitorManager.h
+++ b/src/monitor/include/HostMonitorManager.h
@@ -51,7 +51,7 @@ public:
 
     ~HostMonitorManager();
 
-    OneMonitorDriver* get_oned_driver() const { return oned_driver; }
+    OneMonitorDriver* get_oned_driver() const { return oned_driver.get(); }
 
     //--------------------------------------------------------------------------
     //  Driver Interface
@@ -165,13 +165,13 @@ public:
 private:
     using driver_manager_t = DriverManager<MonitorDriver>;
 
-    driver_manager_t* driver_manager;
+    std::unique_ptr<driver_manager_t> driver_manager;
 
-    OneMonitorDriver* oned_driver;
+    std::unique_ptr<OneMonitorDriver> oned_driver;
 
-    UDPMonitorDriver* udp_driver;
+    std::unique_ptr<UDPMonitorDriver> udp_driver;
 
-    TCPMonitorDriver* tcp_driver;
+    std::unique_ptr<TCPMonitorDriver> tcp_driver;
 
     HostRPCPool* hpool;
 
diff --git a/src/monitor/include/VirtualMachineBase.h b/src/monitor/include/VirtualMachineBase.h
index 32c015fd4e..b5770850df 100644
--- a/src/monitor/include/VirtualMachineBase.h
+++ b/src/monitor/include/VirtualMachineBase.h
@@ -44,11 +44,7 @@ public:
         init_attributes();
     }
 
-    virtual ~VirtualMachineBase()
-    {
-        delete vm_template;
-        delete user_template;
-    }
+    virtual ~VirtualMachineBase() = default;
 
     /**
      * Rebuilds the object from an xml formatted string
@@ -125,8 +121,8 @@ protected:
 
     // std::map<int, VirtualMachineNicXML *> nics;
 
-    VirtualMachineTemplate * vm_template = nullptr;
-    VirtualMachineTemplate * user_template = nullptr;
+    std::unique_ptr<VirtualMachineTemplate> vm_template;
+    std::unique_ptr<VirtualMachineTemplate> user_template;
 };
 
 #endif // VIRTUAL_MACHINE_BASE_H_
diff --git a/src/monitor/src/data_model/VirtualMachineBase.cc b/src/monitor/src/data_model/VirtualMachineBase.cc
index a90618c250..c491cd0885 100644
--- a/src/monitor/src/data_model/VirtualMachineBase.cc
+++ b/src/monitor/src/data_model/VirtualMachineBase.cc
@@ -96,7 +96,7 @@ int VirtualMachineBase::init_attributes()
     /**************************************************************************/
     if (get_nodes("/VM/TEMPLATE", nodes) > 0)
     {
-        vm_template = new VirtualMachineTemplate;
+        vm_template = make_unique<VirtualMachineTemplate>();
 
         vm_template->from_xml_node(nodes[0]);
 
@@ -111,7 +111,7 @@ int VirtualMachineBase::init_attributes()
 
     if (get_nodes("/VM/USER_TEMPLATE", nodes) > 0)
     {
-        user_template = new VirtualMachineTemplate;
+        user_template = make_unique<VirtualMachineTemplate>();
 
         user_template->from_xml_node(nodes[0]);
 
diff --git a/src/monitor/src/monitor/HostMonitorManager.cc b/src/monitor/src/monitor/HostMonitorManager.cc
index c05fb6419c..a0c6b0266f 100644
--- a/src/monitor/src/monitor/HostMonitorManager.cc
+++ b/src/monitor/src/monitor/HostMonitorManager.cc
@@ -52,10 +52,10 @@ HostMonitorManager::HostMonitorManager(
     , monitor_interval_host(monitor_interval_host)
     , is_leader(false)
 {
-    oned_driver    = new OneMonitorDriver(this);
-    udp_driver     = new UDPMonitorDriver(addr, port);
-    tcp_driver     = new TCPMonitorDriver(addr, port);
-    driver_manager = new driver_manager_t(driver_path);
+    oned_driver    = make_unique<OneMonitorDriver>(this);
+    udp_driver     = make_unique<UDPMonitorDriver>(addr, port);
+    tcp_driver     = make_unique<TCPMonitorDriver>(addr, port);
+    driver_manager = make_unique<driver_manager_t>(driver_path);
 };
 
 /* -------------------------------------------------------------------------- */
@@ -63,10 +63,6 @@ HostMonitorManager::HostMonitorManager(
 
 HostMonitorManager::~HostMonitorManager()
 {
-    delete oned_driver;
-    delete udp_driver;
-    delete tcp_driver;
-    delete driver_manager;
 }
 
 /* -------------------------------------------------------------------------- */
diff --git a/src/monitor/src/monitor/Monitor.cc b/src/monitor/src/monitor/Monitor.cc
index fe02f0e788..e5b201fa30 100644
--- a/src/monitor/src/monitor/Monitor.cc
+++ b/src/monitor/src/monitor/Monitor.cc
@@ -44,8 +44,8 @@ void Monitor::start()
             oned_filename);
     }
 
-    config.reset(new MonitorConfigTemplate(get_defaults_location(),
-                conf_filename));
+    config = make_unique<MonitorConfigTemplate>(get_defaults_location(),
+                conf_filename);
 
     if (config->load_configuration() != 0)
     {
@@ -104,7 +104,7 @@ void Monitor::start()
         int    timeout;
         _db->vector_value("TIMEOUT", timeout, 2500);
 
-        sqlDB.reset(new SqliteDB(get_var_location() + "one.db", timeout));
+        sqlDB = make_unique<SqliteDB>(get_var_location() + "one.db", timeout);
     }
     else
     {
@@ -129,13 +129,13 @@ void Monitor::start()
 
         if ( db_backend == "postgresql" )
         {
-            sqlDB.reset(new PostgreSqlDB(server, port, user, passwd, db_name,
-                    connections));
+            sqlDB = make_unique<PostgreSqlDB>(server, port, user, passwd, db_name,
+                    connections);
         }
         else if ( db_backend == "mysql" )
         {
-            sqlDB.reset(new MySqlDB(server, port, user, passwd, db_name,
-                        encoding, connections, compare_binary));
+            sqlDB = make_unique<MySqlDB>(server, port, user, passwd, db_name,
+                        encoding, connections, compare_binary);
         }
         else
         {
@@ -152,8 +152,8 @@ void Monitor::start()
     config->get("HOST_MONITORING_EXPIRATION_TIME", host_exp);
     config->get("VM_MONITORING_EXPIRATION_TIME", vm_exp);
 
-    hpool.reset(new HostRPCPool(sqlDB.get(), host_exp));
-    vmpool.reset(new VMRPCPool(sqlDB.get(), vm_exp));
+    hpool = make_unique<HostRPCPool>(sqlDB.get(), host_exp);
+    vmpool = make_unique<VMRPCPool>(sqlDB.get(), vm_exp);
 
     // -------------------------------------------------------------------------
     // Close stds in drivers
@@ -201,11 +201,11 @@ void Monitor::start()
         udp_conf->replace("PUBKEY", buffer.str());
     }
 
-    hm.reset(new HostMonitorManager(hpool.get(), vmpool.get(),
+    hm = make_unique<HostMonitorManager>(hpool.get(), vmpool.get(),
                 addr, port, threads,
                 get_mad_location(),
                 timer_period,
-                monitor_interval_host));
+                monitor_interval_host);
 
     if (hm->load_monitor_drivers(drivers_conf) != 0)
     {
diff --git a/src/monitor/src/monitor/MonitorDriverProtocol.cc b/src/monitor/src/monitor/MonitorDriverProtocol.cc
index 4e8ec07d1c..84876486ae 100644
--- a/src/monitor/src/monitor/MonitorDriverProtocol.cc
+++ b/src/monitor/src/monitor/MonitorDriverProtocol.cc
@@ -355,7 +355,7 @@ void MonitorDriverProtocol::_start_monitor(unique_ptr<monitor_msg_t> msg)
 
         ssl_util::base64_decode(payload64, payload);
 
-        unique_ptr<monitor_msg_t> m(new monitor_msg_t);
+        auto m = make_unique<monitor_msg_t>();
 
         m->type(it);
 
diff --git a/src/nebula/Nebula.cc b/src/nebula/Nebula.cc
index e459e09061..77772d8661 100644
--- a/src/nebula/Nebula.cc
+++ b/src/nebula/Nebula.cc
@@ -1164,6 +1164,8 @@ void Nebula::start(bool bootstrap_only)
     // Stop the managers & free resources
     // -----------------------------------------------------------
 
+    rm->finalize();
+
     if (!cache)
     {
         vmm->finalize();
@@ -1193,7 +1195,6 @@ void Nebula::start(bool bootstrap_only)
     raftm->finalize();
     aclm->finalize();
 
-    rm->finalize();
     authm->finalize();
 
     authm->join_thread();
diff --git a/src/pool/PoolObjectSQL.cc b/src/pool/PoolObjectSQL.cc
index 235ea09f86..4b68bfa923 100644
--- a/src/pool/PoolObjectSQL.cc
+++ b/src/pool/PoolObjectSQL.cc
@@ -259,10 +259,10 @@ int PoolObjectSQL::replace_template(
 {
     string ra;
 
-    Template * old_tmpl = 0;
-    Template * new_tmpl = get_new_template();
+    unique_ptr<Template> old_tmpl = 0;
+    unique_ptr<Template> new_tmpl = get_new_template();
 
-    if ( new_tmpl == 0 )
+    if ( !new_tmpl )
     {
         error = "Cannot allocate a new template";
         return -1;
@@ -270,52 +270,44 @@ int PoolObjectSQL::replace_template(
 
     if ( new_tmpl->parse_str_or_xml(tmpl_str, error) != 0 )
     {
-        delete new_tmpl;
         return -1;
     }
 
-    if (obj_template != 0)
+    if (obj_template)
     {
-        if ( keep_restricted &&  new_tmpl->check_restricted(ra, obj_template) )
+        if ( keep_restricted &&
+             new_tmpl->check_restricted(ra, obj_template.get()) )
         {
             error = "Tried to change restricted attribute: " + ra;
 
-            delete new_tmpl;
             return -1;
         }
 
-        old_tmpl = new Template(*obj_template);
+        old_tmpl = std::make_unique<Template>(*obj_template);
     }
     else if ( keep_restricted && new_tmpl->check_restricted(ra) )
     {
         error = "Tried to set restricted attribute: " + ra;
 
-        delete new_tmpl;
         return -1;
     }
 
-    delete obj_template;
-
-    obj_template = new_tmpl;
+    obj_template = move(new_tmpl);
 
     if (post_update_template(error) == -1)
     {
-        delete obj_template;
-
-        if (old_tmpl != 0)
+        if (old_tmpl)
         {
-            obj_template = old_tmpl;
+            obj_template = move(old_tmpl);
         }
         else
         {
-            obj_template = 0;
+            obj_template = nullptr;
         }
 
         return -1;
     }
 
-    delete old_tmpl;
-
     encrypt();
 
     return 0;
@@ -327,11 +319,11 @@ int PoolObjectSQL::replace_template(
 int PoolObjectSQL::append_template(
         const string& tmpl_str, bool keep_restricted, string& error)
 {
-    Template * old_tmpl = 0;
-    Template * new_tmpl = get_new_template();
+    unique_ptr<Template> old_tmpl;
+    unique_ptr<Template> new_tmpl = get_new_template();
     string rname;
 
-    if ( new_tmpl == 0 )
+    if ( !new_tmpl )
     {
         error = "Cannot allocate a new template";
         return -1;
@@ -339,51 +331,43 @@ int PoolObjectSQL::append_template(
 
     if ( new_tmpl->parse_str_or_xml(tmpl_str, error) != 0 )
     {
-        delete new_tmpl;
         return -1;
     }
 
-    if ( obj_template != 0 )
+    if ( obj_template )
     {
-        if (keep_restricted && new_tmpl->check_restricted(rname, obj_template))
+        if (keep_restricted &&
+            new_tmpl->check_restricted(rname, obj_template.get()))
         {
             error ="User Template includes a restricted attribute " + rname;
-            delete new_tmpl;
             return -1;
         }
-        obj_template->merge(new_tmpl);
-
-        delete new_tmpl;
+        obj_template->merge(new_tmpl.get());
     }
     else
     {
         if (keep_restricted && new_tmpl->check_restricted(rname))
         {
             error ="User Template includes a restricted attribute " + rname;
-            delete new_tmpl;
             return -1;
         }
-        obj_template = new_tmpl;
+        obj_template = move(new_tmpl);
     }
 
     if (post_update_template(error) == -1)
     {
-        delete obj_template;
-
-        if (old_tmpl != 0)
+        if (old_tmpl)
         {
-            obj_template = old_tmpl;
+            obj_template = move(old_tmpl);
         }
         else
         {
-            obj_template = 0;
+            obj_template = nullptr;
         }
 
         return -1;
     }
 
-    delete old_tmpl;
-
     encrypt();
 
     return 0;
diff --git a/src/raft/RaftManager.cc b/src/raft/RaftManager.cc
index 6f74165c7c..2592fccb6a 100644
--- a/src/raft/RaftManager.cc
+++ b/src/raft/RaftManager.cc
@@ -63,8 +63,6 @@ RaftManager::RaftManager(int id, const VectorAttribute * leader_hook_mad,
     , timer_thread()
     , purge_thread(log_purge, [this](){purge_action();})
     , commit(0)
-    , leader_hook(0)
-    , follower_hook(0)
 {
     Nebula& nd    = Nebula::instance();
     LogDB * logdb = nd.get_logdb();
@@ -154,8 +152,8 @@ RaftManager::RaftManager(int id, const VectorAttribute * leader_hook_mad,
         }
         else
         {
-            leader_hook = new ExecuteHook("RAFT_LEADER_HOOK", cmd, arg,
-                    remotes_location);
+            leader_hook = make_unique<ExecuteHook>("RAFT_LEADER_HOOK",
+                            cmd, arg, remotes_location);
         }
     }
 
@@ -175,12 +173,12 @@ RaftManager::RaftManager(int id, const VectorAttribute * leader_hook_mad,
         }
         else
         {
-            follower_hook = new ExecuteHook("RAFT_FOLLOWER_HOOK", cmd, arg,
-                    remotes_location);
+            follower_hook = make_unique<ExecuteHook>("RAFT_FOLLOWER_HOOK",
+                                cmd, arg, remotes_location);
         }
     }
 
-    if ( state == FOLLOWER && follower_hook != 0 )
+    if ( state == FOLLOWER && follower_hook )
     {
         follower_hook->execute();
     }
@@ -364,7 +362,7 @@ void RaftManager::leader()
 
         requests.clear();
 
-        if ( leader_hook != 0 )
+        if ( leader_hook )
         {
             leader_hook->execute();
         }
@@ -460,7 +458,7 @@ void RaftManager::follower(unsigned int _term)
     {
         std::lock_guard<mutex> lock(raft_mutex);
 
-        if ( state == LEADER && follower_hook != 0 )
+        if ( state == LEADER && follower_hook )
         {
             follower_hook->execute();
         }
diff --git a/src/rm/RequestManagerAllocate.cc b/src/rm/RequestManagerAllocate.cc
index c5bafbb463..e88ab92289 100644
--- a/src/rm/RequestManagerAllocate.cc
+++ b/src/rm/RequestManagerAllocate.cc
@@ -133,23 +133,22 @@ bool VirtualMachineAllocate::allocate_authorization(
         return false;
     }
 
-    vector<Template *> ds_quotas;
-    vector<Template *> applied;
-    vector<Template *>::iterator it;
+    vector<unique_ptr<Template>> ds_quotas;
+    vector<unique_ptr<Template>> applied;
 
     bool ds_quota_auth = true;
 
     VirtualMachineDisks::image_ds_quotas(&aux_tmpl, ds_quotas);
 
-    for ( it = ds_quotas.begin() ; it != ds_quotas.end() ; ++it )
+    for (auto& quota : ds_quotas)
     {
-        if ( quota_authorization(*it, Quotas::DATASTORE, att) == false )
+        if ( quota_authorization(quota.get(), Quotas::DATASTORE, att) == false )
         {
             ds_quota_auth = false;
         }
         else
         {
-            applied.push_back(*it);
+            applied.push_back(move(quota));
         }
     }
 
@@ -157,17 +156,12 @@ bool VirtualMachineAllocate::allocate_authorization(
     {
         quota_rollback(&aux_tmpl, Quotas::VIRTUALMACHINE, att);
 
-        for ( it = applied.begin() ; it != applied.end() ; ++it )
+        for (auto& quota : applied)
         {
-            quota_rollback(*it, Quotas::DATASTORE, att);
+            quota_rollback(quota.get(), Quotas::DATASTORE, att);
         }
     }
 
-    for ( it = ds_quotas.begin() ; it != ds_quotas.end() ; ++it )
-    {
-        delete *it;
-    }
-
     return ds_quota_auth;
 }
 
@@ -177,7 +171,7 @@ bool VirtualMachineAllocate::allocate_authorization(
 void RequestManagerAllocate::request_execute(xmlrpc_c::paramList const& params,
                                              RequestAttributes& att)
 {
-    Template * tmpl = 0;
+    unique_ptr<Template> tmpl;
 
     int    rc, id;
 
@@ -196,7 +190,6 @@ void RequestManagerAllocate::request_execute(xmlrpc_c::paramList const& params,
         if ( rc != 0 )
         {
             failure_response(INTERNAL, att);
-            delete tmpl;
 
             return;
         }
@@ -211,7 +204,6 @@ void RequestManagerAllocate::request_execute(xmlrpc_c::paramList const& params,
 
         if ( rc != 0 )
         {
-            delete tmpl;
             return;
         }
     }
@@ -220,13 +212,12 @@ void RequestManagerAllocate::request_execute(xmlrpc_c::paramList const& params,
         cluster_perms.oid = ClusterPool::NONE_CLUSTER_ID;
     }
 
-    if ( allocate_authorization(params, tmpl, att, &cluster_perms) == false )
+    if ( allocate_authorization(params, tmpl.get(), att, &cluster_perms) == false )
     {
-        delete tmpl;
         return;
     }
 
-    ErrorCode ec = pool_allocate(params, tmpl, id, att, cluster_id, cluster_name);
+    ErrorCode ec = pool_allocate(params, move(tmpl), id, att, cluster_id, cluster_name);
 
     if ( ec != SUCCESS )
     {
@@ -277,7 +268,7 @@ void RequestManagerAllocate::request_execute(xmlrpc_c::paramList const& params,
 
 Request::ErrorCode VirtualMachineAllocate::pool_allocate(
         xmlrpc_c::paramList const&  paramList,
-        Template *                  tmpl,
+        unique_ptr<Template>        tmpl,
         int&                        id,
         RequestAttributes&          att)
 {
@@ -288,18 +279,18 @@ Request::ErrorCode VirtualMachineAllocate::pool_allocate(
         on_hold = xmlrpc_c::value_boolean(paramList.getBoolean(2));
     }
 
-    VirtualMachineTemplate * ttmpl= static_cast<VirtualMachineTemplate *>(tmpl);
-    VirtualMachinePool * vmpool   = static_cast<VirtualMachinePool *>(pool);
-
     Template tmpl_back(*tmpl);
 
+    unique_ptr<VirtualMachineTemplate> ttmpl(
+        static_cast<VirtualMachineTemplate*>(tmpl.release()));
+    VirtualMachinePool * vmpool   = static_cast<VirtualMachinePool *>(pool);
+
     int rc = vmpool->allocate(att.uid, att.gid, att.uname, att.gname, att.umask,
-            ttmpl, &id, att.resp_msg, on_hold);
+            move(ttmpl), &id, att.resp_msg, on_hold);
 
     if ( rc < 0 )
     {
-        vector<Template *> ds_quotas;
-        vector<Template *>::iterator it;
+        vector<unique_ptr<Template>> ds_quotas;
 
         quota_rollback(&tmpl_back, Quotas::VIRTUALMACHINE, att);
 
@@ -307,10 +298,9 @@ Request::ErrorCode VirtualMachineAllocate::pool_allocate(
 
         VirtualMachineDisks::image_ds_quotas(&tmpl_back, ds_quotas);
 
-        for ( it = ds_quotas.begin() ; it != ds_quotas.end() ; ++it )
+        for (auto& quota : ds_quotas)
         {
-            quota_rollback(*it, Quotas::DATASTORE, att);
-            delete *it;
+            quota_rollback(quota.get(), Quotas::DATASTORE, att);
         }
 
         return Request::INTERNAL;
@@ -325,14 +315,15 @@ Request::ErrorCode VirtualMachineAllocate::pool_allocate(
 
 Request::ErrorCode VirtualNetworkAllocate::pool_allocate(
         xmlrpc_c::paramList const&  paramList,
-        Template *                  tmpl,
+        unique_ptr<Template>        tmpl,
         int&                        id,
         RequestAttributes&          att,
         int                         cluster_id,
         const string&               cluster_name)
 {
     VirtualNetworkPool * vpool = static_cast<VirtualNetworkPool *>(pool);
-    VirtualNetworkTemplate * vtmpl=static_cast<VirtualNetworkTemplate *>(tmpl);
+    unique_ptr<VirtualNetworkTemplate> vtmpl(
+        static_cast<VirtualNetworkTemplate*>(tmpl.release()));
 
     set<int> cluster_ids;
 
@@ -342,7 +333,7 @@ Request::ErrorCode VirtualNetworkAllocate::pool_allocate(
     }
 
     int rc = vpool->allocate(att.uid, att.gid, att.uname, att.gname, att.umask,-1,
-            vtmpl, &id, cluster_ids, att.resp_msg);
+            move(vtmpl), &id, cluster_ids, att.resp_msg);
 
     if (rc < 0)
     {
@@ -396,7 +387,6 @@ void ImageAllocate::request_execute(xmlrpc_c::paramList const& params,
     MarketPlacePool *     marketpool = nd.get_marketpool();
     MarketPlaceAppPool *  apppool    = nd.get_apppool();
 
-    ImageTemplate * tmpl;
     Template        img_usage;
 
     Image::DiskType ds_disk_type;
@@ -413,7 +403,7 @@ void ImageAllocate::request_execute(xmlrpc_c::paramList const& params,
 
     // ------------------------- Parse image template --------------------------
 
-    tmpl = new ImageTemplate;
+    auto tmpl = make_unique<ImageTemplate>();
 
     rc = tmpl->parse_str_or_xml(str_tmpl, att.resp_msg);
 
@@ -421,7 +411,6 @@ void ImageAllocate::request_execute(xmlrpc_c::paramList const& params,
     {
         failure_response(INTERNAL, att);
 
-        delete tmpl;
         return;
     }
 
@@ -436,7 +425,6 @@ void ImageAllocate::request_execute(xmlrpc_c::paramList const& params,
             att.resp_msg = "New images cannot be allocated in a system datastore.";
             failure_response(ALLOCATE, att);
 
-            delete tmpl;
             return;
         }
 
@@ -459,7 +447,6 @@ void ImageAllocate::request_execute(xmlrpc_c::paramList const& params,
         att.resp_obj = PoolObjectSQL::DATASTORE;
         failure_response(NO_EXISTS, att);
 
-        delete tmpl;
         return;
     }
 
@@ -472,7 +459,7 @@ void ImageAllocate::request_execute(xmlrpc_c::paramList const& params,
         // the size.
         if ( auto app = apppool->get_ro(app_id) )
         {
-            app->to_template(tmpl);
+            app->to_template(tmpl.get());
 
             size_mb   = app->get_size();
             market_id = app->get_market_id();
@@ -482,7 +469,6 @@ void ImageAllocate::request_execute(xmlrpc_c::paramList const& params,
             att.resp_msg = "Cannot determine image SIZE.";
             failure_response(INTERNAL, att);
 
-            delete tmpl;
             return;
         }
 
@@ -504,20 +490,18 @@ void ImageAllocate::request_execute(xmlrpc_c::paramList const& params,
             att.resp_msg = "Could not get the appliance's market.";
             failure_response(INTERNAL, att);
 
-            delete tmpl;
             return;
         }
     }
     else
     {
-        rc = imagem->stat_image(tmpl, ds_data, size_str);
+        rc = imagem->stat_image(tmpl.get(), ds_data, size_str);
 
         if ( rc == -1 )
         {
             att.resp_msg = "Cannot parse image SIZE: " + size_str;
             failure_response(INTERNAL, att);
 
-            delete tmpl;
             return;
         }
 
@@ -529,7 +513,6 @@ void ImageAllocate::request_execute(xmlrpc_c::paramList const& params,
             att.resp_msg = "Cannot parse image SIZE: " + size_str;
             failure_response(INTERNAL, att);
 
-            delete tmpl;
             return;
         }
     }
@@ -539,7 +522,6 @@ void ImageAllocate::request_execute(xmlrpc_c::paramList const& params,
         att.resp_msg = "Not enough space in datastore";
         failure_response(ACTION, att);
 
-        delete tmpl;
         return;
     }
 
@@ -564,7 +546,6 @@ void ImageAllocate::request_execute(xmlrpc_c::paramList const& params,
             att.resp_msg = "Template includes a restricted attribute "+aname;
             failure_response(AUTHORIZATION, att);
 
-            delete tmpl;
             return;
         }
     }
@@ -581,7 +562,6 @@ void ImageAllocate::request_execute(xmlrpc_c::paramList const& params,
         att.resp_msg = ar.message;
         failure_response(AUTHORIZATION, att);
 
-        delete tmpl;
         return;
     }
 
@@ -589,20 +569,18 @@ void ImageAllocate::request_execute(xmlrpc_c::paramList const& params,
 
     if ( quota_authorization(&img_usage, Quotas::DATASTORE, att) == false )
     {
-        delete tmpl;
         return;
     }
 
     // ------------------------- Check persistent only -------------------------
 
-    persistent_attr = Image::test_set_persistent(tmpl, att.uid, att.gid, true);
+    persistent_attr = Image::test_set_persistent(tmpl.get(), att.uid, att.gid, true);
 
     if ( ds_persistent_only && persistent_attr == false )
     {
         att.resp_msg = "This Datastore only accepts persistent images.";
         failure_response(ALLOCATE, att);
 
-        delete tmpl;
         return;
     }
 
@@ -613,7 +591,7 @@ void ImageAllocate::request_execute(xmlrpc_c::paramList const& params,
                          att.uname,
                          att.gname,
                          att.umask,
-                         tmpl,
+                         move(tmpl),
                          ds_id,
                          ds_name,
                          ds_disk_type,
@@ -655,16 +633,17 @@ void ImageAllocate::request_execute(xmlrpc_c::paramList const& params,
 
 Request::ErrorCode TemplateAllocate::pool_allocate(
         xmlrpc_c::paramList const&  paramList,
-        Template *                  tmpl,
+        unique_ptr<Template>        tmpl,
         int&                        id,
         RequestAttributes&          att)
 {
     VMTemplatePool * tpool = static_cast<VMTemplatePool *>(pool);
 
-    VirtualMachineTemplate * ttmpl=static_cast<VirtualMachineTemplate *>(tmpl);
+    unique_ptr<VirtualMachineTemplate> ttmpl(
+        static_cast<VirtualMachineTemplate *>(tmpl.release()));
 
     int rc = tpool->allocate(att.uid, att.gid, att.uname, att.gname, att.umask,
-        ttmpl, &id, att.resp_msg);
+        move(ttmpl), &id, att.resp_msg);
 
     if (rc < 0)
     {
@@ -715,16 +694,17 @@ bool TemplateAllocate::allocate_authorization(
 
 Request::ErrorCode VirtualNetworkTemplateAllocate::pool_allocate(
         xmlrpc_c::paramList const&  paramList,
-        Template *                  tmpl,
+        unique_ptr<Template>        tmpl,
         int&                        id,
         RequestAttributes&          att)
 {
     VNTemplatePool * vnpool = static_cast<VNTemplatePool *>(pool);
 
-    VirtualNetworkTemplate * ttmpl=static_cast<VirtualNetworkTemplate *>(tmpl);
+    unique_ptr<VirtualNetworkTemplate> ttmpl(
+        static_cast<VirtualNetworkTemplate *>(tmpl.release()));
 
     int rc = vnpool->allocate(att.uid, att.gid, att.uname, att.gname, att.umask,
-        ttmpl, &id, att.resp_msg);
+        move(ttmpl), &id, att.resp_msg);
 
     if (rc < 0)
     {
@@ -774,7 +754,7 @@ bool VirtualNetworkTemplateAllocate::allocate_authorization(
 
 Request::ErrorCode HostAllocate::pool_allocate(
         xmlrpc_c::paramList const&  paramList,
-        Template *                  tmpl,
+        unique_ptr<Template>        tmpl,
         int&                        id,
         RequestAttributes&          att,
         int                         cluster_id,
@@ -862,7 +842,7 @@ bool UserAllocate::allocate_authorization(
 
 Request::ErrorCode UserAllocate::pool_allocate(
         xmlrpc_c::paramList const&  paramList,
-        Template *                  tmpl,
+        unique_ptr<Template>        tmpl,
         int&                        id,
         RequestAttributes&          att)
 {
@@ -933,7 +913,7 @@ Request::ErrorCode UserAllocate::pool_allocate(
 
 Request::ErrorCode GroupAllocate::pool_allocate(
         xmlrpc_c::paramList const&  paramList,
-        Template *                  tmpl,
+        unique_ptr<Template>        tmpl,
         int&                        id,
         RequestAttributes&          att)
 {
@@ -970,14 +950,15 @@ Request::ErrorCode GroupAllocate::pool_allocate(
 
 Request::ErrorCode DatastoreAllocate::pool_allocate(
         xmlrpc_c::paramList const&  paramList,
-        Template *                  tmpl,
+        unique_ptr<Template>        tmpl,
         int&                        id,
         RequestAttributes&          att,
         int                         cluster_id,
         const string&               cluster_name)
 {
     DatastorePool * dspool      = static_cast<DatastorePool *>(pool);
-    DatastoreTemplate * ds_tmpl = static_cast<DatastoreTemplate *>(tmpl);
+    unique_ptr<DatastoreTemplate> ds_tmpl(
+        static_cast<DatastoreTemplate *>(tmpl.release()));
 
     set<int> cluster_ids;
 
@@ -987,7 +968,7 @@ Request::ErrorCode DatastoreAllocate::pool_allocate(
     }
 
     int rc = dspool->allocate(att.uid, att.gid, att.uname, att.gname, att.umask,
-            ds_tmpl, &id, cluster_ids, att.resp_msg);
+            move(ds_tmpl), &id, cluster_ids, att.resp_msg);
 
     if (rc < 0)
     {
@@ -1002,7 +983,7 @@ Request::ErrorCode DatastoreAllocate::pool_allocate(
 
 Request::ErrorCode ClusterAllocate::pool_allocate(
         xmlrpc_c::paramList const&  paramList,
-        Template *                  tmpl,
+        unique_ptr<Template>        tmpl,
         int&                        id,
         RequestAttributes&          att)
 {
@@ -1025,7 +1006,7 @@ Request::ErrorCode ClusterAllocate::pool_allocate(
 
 Request::ErrorCode DocumentAllocate::pool_allocate(
         xmlrpc_c::paramList const&  paramList,
-        Template *                  tmpl,
+        unique_ptr<Template>        tmpl,
         int&                        id,
         RequestAttributes&          att)
 {
@@ -1034,7 +1015,7 @@ Request::ErrorCode DocumentAllocate::pool_allocate(
     DocumentPool * docpool = static_cast<DocumentPool *>(pool);
 
     int rc = docpool->allocate(att.uid, att.gid, att.uname, att.gname, att.umask,
-            type, tmpl, &id, att.resp_msg);
+            type, move(tmpl), &id, att.resp_msg);
 
     if (rc < 0)
     {
@@ -1048,7 +1029,7 @@ Request::ErrorCode DocumentAllocate::pool_allocate(
 /* -------------------------------------------------------------------------- */
 
 void ZoneAllocate::request_execute(xmlrpc_c::paramList const& params,
-                                             RequestAttributes& att)
+                                   RequestAttributes& att)
 {
     if(!Nebula::instance().is_federation_master())
     {
@@ -1065,7 +1046,7 @@ void ZoneAllocate::request_execute(xmlrpc_c::paramList const& params,
 
 Request::ErrorCode ZoneAllocate::pool_allocate(
         xmlrpc_c::paramList const&  paramList,
-        Template *                  tmpl,
+        unique_ptr<Template>        tmpl,
         int&                        id,
         RequestAttributes&          att)
 {
@@ -1073,7 +1054,7 @@ Request::ErrorCode ZoneAllocate::pool_allocate(
 
     ZonePool * zonepool = static_cast<ZonePool *>(pool);
 
-    int rc = zonepool->allocate(tmpl, &id, att.resp_msg);
+    int rc = zonepool->allocate(move(tmpl), &id, att.resp_msg);
 
     if (rc < 0)
     {
@@ -1090,14 +1071,14 @@ Request::ErrorCode ZoneAllocate::pool_allocate(
 
 Request::ErrorCode SecurityGroupAllocate::pool_allocate(
         xmlrpc_c::paramList const&  paramList,
-        Template *                  tmpl,
+        unique_ptr<Template>        tmpl,
         int&                        id,
         RequestAttributes&          att)
 {
     SecurityGroupPool * sgpool = static_cast<SecurityGroupPool *>(pool);
 
     int rc = sgpool->allocate(att.uid, att.gid, att.uname, att.gname, att.umask,
-        tmpl, &id, att.resp_msg);
+        move(tmpl), &id, att.resp_msg);
 
     if (rc < 0)
     {
@@ -1112,7 +1093,7 @@ Request::ErrorCode SecurityGroupAllocate::pool_allocate(
 
 Request::ErrorCode VdcAllocate::pool_allocate(
         xmlrpc_c::paramList const&  paramList,
-        Template *                  tmpl,
+        unique_ptr<Template>        tmpl,
         int&                        id,
         RequestAttributes&          att)
 {
@@ -1120,7 +1101,7 @@ Request::ErrorCode VdcAllocate::pool_allocate(
 
     VdcPool * vdcpool = static_cast<VdcPool *>(pool);
 
-    int rc = vdcpool->allocate(tmpl, &id, att.resp_msg);
+    int rc = vdcpool->allocate(move(tmpl), &id, att.resp_msg);
 
     if (rc < 0)
     {
@@ -1135,14 +1116,14 @@ Request::ErrorCode VdcAllocate::pool_allocate(
 
 Request::ErrorCode VirtualRouterAllocate::pool_allocate(
         xmlrpc_c::paramList const&  paramList,
-        Template *                  tmpl,
+        unique_ptr<Template>        tmpl,
         int&                        id,
         RequestAttributes&          att)
 {
     VirtualRouterPool * vrpool = static_cast<VirtualRouterPool *>(pool);
 
     int rc = vrpool->allocate(att.uid, att.gid, att.uname, att.gname, att.umask,
-        tmpl, &id, att.resp_msg);
+        move(tmpl), &id, att.resp_msg);
 
     if (rc < 0)
     {
@@ -1193,15 +1174,16 @@ bool VirtualRouterAllocate::allocate_authorization(
 
 Request::ErrorCode MarketPlaceAllocate::pool_allocate(
         xmlrpc_c::paramList const&  paramList,
-        Template *                  tmpl,
+        unique_ptr<Template>        tmpl,
         int&                        id,
         RequestAttributes&          att)
 {
     MarketPlacePool *     mppool = static_cast<MarketPlacePool *>(pool);
-    MarketPlaceTemplate * ttmpl  = static_cast<MarketPlaceTemplate *>(tmpl);
+    unique_ptr<MarketPlaceTemplate> ttmpl(
+        static_cast<MarketPlaceTemplate*>(tmpl.release()));
 
     int rc = mppool->allocate(att.uid, att.gid, att.uname, att.gname, att.umask,
-        ttmpl, &id, att.resp_msg);
+        move(ttmpl), &id, att.resp_msg);
 
     if (rc < 0)
     {
@@ -1216,14 +1198,15 @@ Request::ErrorCode MarketPlaceAllocate::pool_allocate(
 
 Request::ErrorCode MarketPlaceAppAllocate::pool_allocate(
         xmlrpc_c::paramList const&  paramList,
-        Template *                  tmpl,
+        unique_ptr<Template>        tmpl,
         int&                        id,
         RequestAttributes&          att)
 {
     MarketPlaceManager*    marketm = Nebula::instance().get_marketm();
 
     MarketPlaceAppPool*     appool = static_cast<MarketPlaceAppPool *>(pool);
-    MarketPlaceAppTemplate* ttmpl  = static_cast<MarketPlaceAppTemplate *>(tmpl);
+    unique_ptr<MarketPlaceAppTemplate> ttmpl(
+        static_cast<MarketPlaceAppTemplate *>(tmpl.release()));
 
     int         mp_id = xmlrpc_c::value_int(paramList.getInt(2));
     std::string mp_data;
@@ -1262,7 +1245,7 @@ Request::ErrorCode MarketPlaceAppAllocate::pool_allocate(
     // Allocate MarketPlaceApp request is forwarded to master for slaves      //
     // ---------------------------------------------------------------------- //
     int rc = appool->allocate(att.uid, att.gid, att.uname, att.gname, att.umask,
-                ttmpl, mp_id, mp_name, &id, att.resp_msg);
+                move(ttmpl), mp_id, mp_name, &id, att.resp_msg);
 
     if (rc < 0)
     {
@@ -1305,14 +1288,14 @@ Request::ErrorCode MarketPlaceAppAllocate::pool_allocate(
 
 Request::ErrorCode VMGroupAllocate::pool_allocate(
         xmlrpc_c::paramList const&  paramList,
-        Template *                  tmpl,
+        unique_ptr<Template>        tmpl,
         int&                        id,
         RequestAttributes&          att)
 {
     VMGroupPool * vmgpool = static_cast<VMGroupPool *>(pool);
 
-    int rc = vmgpool->allocate(att.uid, att.gid, att.uname, att.gname, att.umask
-        ,tmpl, &id, att.resp_msg);
+    int rc = vmgpool->allocate(att.uid, att.gid, att.uname, att.gname,
+                               att.umask, move(tmpl), &id, att.resp_msg);
 
     if (rc < 0)
     {
@@ -1327,7 +1310,7 @@ Request::ErrorCode VMGroupAllocate::pool_allocate(
 
 Request::ErrorCode HookAllocate::pool_allocate(
         xmlrpc_c::paramList const&  paramList,
-        Template *                  tmpl,
+        unique_ptr<Template>        tmpl,
         int&                        id,
         RequestAttributes&          att)
 {
@@ -1347,7 +1330,7 @@ Request::ErrorCode HookAllocate::pool_allocate(
         return Request::INTERNAL;
     }
 
-    id = hkpool->allocate(tmpl, att.resp_msg);
+    id = hkpool->allocate(move(tmpl), att.resp_msg);
 
     if (id < 0)
     {
diff --git a/src/rm/RequestManagerChown.cc b/src/rm/RequestManagerChown.cc
index f91ec22d80..0e373a6fe7 100644
--- a/src/rm/RequestManagerChown.cc
+++ b/src/rm/RequestManagerChown.cc
@@ -33,10 +33,8 @@ unique_ptr<PoolObjectSQL> RequestManagerChown::get_and_quota(
     PoolSQL *                 pool,
     PoolObjectSQL::ObjectType auth_object)
 {
-    std::map<Quotas::QuotaType, Template *> quota_map;
-    std::map<Quotas::QuotaType, Template *> quota_to_rback;
-
-    std::map<Quotas::QuotaType, Template *>::iterator it;
+    std::map<Quotas::QuotaType, std::unique_ptr<Template>> quota_map;
+    std::map<Quotas::QuotaType, std::unique_ptr<Template>> quota_to_rback;
 
     int old_uid;
     int old_gid;
@@ -56,8 +54,7 @@ unique_ptr<PoolObjectSQL> RequestManagerChown::get_and_quota(
     {
         VirtualMachine * vm = static_cast<VirtualMachine*>(object.get());
 
-        vector<Template *> ds_quotas;
-        vector<Template *>::iterator it;
+        vector<unique_ptr<Template>> ds_quotas;
 
         if ( vm->get_state() == VirtualMachine::DONE )
         {
@@ -66,7 +63,7 @@ unique_ptr<PoolObjectSQL> RequestManagerChown::get_and_quota(
             return 0;
         }
 
-        Template * tmpl = vm->clone_template();
+        auto tmpl = vm->clone_template();
 
         if ( (vm->get_state() == VirtualMachine::ACTIVE) ||
          (vm->get_state() == VirtualMachine::PENDING) ||
@@ -82,24 +79,24 @@ unique_ptr<PoolObjectSQL> RequestManagerChown::get_and_quota(
             tmpl->add("RUNNING_VMS", 1);
         }
 
-        quota_map.insert(make_pair(Quotas::VIRTUALMACHINE, tmpl));
+        VirtualMachineDisks::image_ds_quotas(tmpl.get(), ds_quotas);
 
-        VirtualMachineDisks::image_ds_quotas(tmpl, ds_quotas);
+        quota_map.insert(make_pair(Quotas::VIRTUALMACHINE, move(tmpl)));
 
-        for ( it = ds_quotas.begin() ; it != ds_quotas.end() ; ++it )
+        for (auto& quota : ds_quotas)
         {
-            quota_map.insert(make_pair(Quotas::DATASTORE, *it));
+            quota_map.insert(make_pair(Quotas::DATASTORE, move(quota)));
         }
     }
     else if (auth_object == PoolObjectSQL::IMAGE)
     {
         Image * img     = static_cast<Image *>(object.get());
-        Template * tmpl = new Template;
+        auto tmpl = make_unique<Template>();
 
         tmpl->add("DATASTORE", img->get_ds_id());
         tmpl->add("SIZE",img->get_size()+img->get_snapshots().get_total_size());
 
-        quota_map.insert(make_pair(Quotas::DATASTORE, tmpl));
+        quota_map.insert(make_pair(Quotas::DATASTORE, move(tmpl)));
     }
     else if (auth_object == PoolObjectSQL::NET)
     {
@@ -115,7 +112,7 @@ unique_ptr<PoolObjectSQL> RequestManagerChown::get_and_quota(
             return object;
         }
 
-        Template * tmpl = new Template;
+        auto tmpl = make_unique<Template>();
 
         for (unsigned int i= 0 ; i < total ; i++)
         {
@@ -124,7 +121,7 @@ unique_ptr<PoolObjectSQL> RequestManagerChown::get_and_quota(
 
         tmpl->parse_str_or_xml(oss.str(), att.resp_msg);
 
-        quota_map.insert(make_pair(Quotas::NETWORK, tmpl));
+        quota_map.insert(make_pair(Quotas::NETWORK, move(tmpl)));
     }
     else
     {
@@ -159,19 +156,19 @@ unique_ptr<PoolObjectSQL> RequestManagerChown::get_and_quota(
     // -------------------------------------------------------------------------
     // Apply quotas to new owner free old owner
     // -------------------------------------------------------------------------
-    for ( it = quota_map.begin(); it != quota_map.end() ; )
+    for ( auto it = quota_map.begin(); it != quota_map.end() ; )
     {
         Quotas::QuotaType qtype = it->first;
-        Template *        tmpl  = it->second;
+        auto&             tmpl  = it->second;
 
-        if ( quota_authorization(tmpl, qtype, att_new, att.resp_msg) == false )
+        if ( quota_authorization(tmpl.get(), qtype, att_new, att.resp_msg) == false )
         {
             error = true;
             break;
         }
         else
         {
-            quota_to_rback.insert(make_pair(qtype, tmpl));
+            quota_to_rback.insert(make_pair(qtype, move(tmpl)));
 
             it = quota_map.erase(it);
         }
@@ -179,9 +176,9 @@ unique_ptr<PoolObjectSQL> RequestManagerChown::get_and_quota(
 
     if (!error)
     {
-        for (it = quota_to_rback.begin(); it != quota_to_rback.end(); ++it)
+        for (auto& it : quota_to_rback)
         {
-            quota_rollback(it->second, it->first, att_old);
+            quota_rollback(it.second.get(), it.first, att_old);
         }
 
         object = pool->get<PoolObjectSQL>(oid);
@@ -193,14 +190,14 @@ unique_ptr<PoolObjectSQL> RequestManagerChown::get_and_quota(
     // -------------------------------------------------------------------------
     if ( object == nullptr || error )
     {
-        for (it = quota_to_rback.begin(); it != quota_to_rback.end(); ++it)
+        for (auto& it : quota_to_rback)
         {
             if ( object == nullptr )
             {
-                quota_authorization(it->second, it->first,att_old,att.resp_msg);
+                quota_authorization(it.second.get(), it.first, att_old, att.resp_msg);
             }
 
-            quota_rollback(it->second, it->first, att_new);
+            quota_rollback(it.second.get(), it.first, att_new);
         }
 
         if ( object == 0 )
@@ -216,19 +213,6 @@ unique_ptr<PoolObjectSQL> RequestManagerChown::get_and_quota(
         object = nullptr;
     }
 
-    // -------------------------------------------------------------------------
-    // Clean up memory for templates
-    // -------------------------------------------------------------------------
-    for ( it = quota_map.begin(); it != quota_map.end() ; ++it)
-    {
-        delete it->second;
-    }
-
-    for (it = quota_to_rback.begin(); it != quota_to_rback.end(); ++it)
-    {
-        delete it->second;
-    }
-
     return object;
 }
 
diff --git a/src/rm/RequestManagerClone.cc b/src/rm/RequestManagerClone.cc
index cd8d0bcad7..e9b56ac442 100644
--- a/src/rm/RequestManagerClone.cc
+++ b/src/rm/RequestManagerClone.cc
@@ -63,7 +63,7 @@ Request::ErrorCode RequestManagerClone::clone(int source_id, const string &name,
     int rc;
     PoolObjectAuth perms;
 
-    Template * tmpl;
+    unique_ptr<Template> tmpl;
 
     if ( auto source_obj = pool->get_ro<PoolObjectSQL>(source_id) )
     {
@@ -77,11 +77,10 @@ Request::ErrorCode RequestManagerClone::clone(int source_id, const string &name,
         return NO_EXISTS;
     }
 
-    ErrorCode ec = merge(tmpl, s_uattr, att);
+    ErrorCode ec = merge(tmpl.get(), s_uattr, att);
 
     if (ec != SUCCESS)
     {
-        delete tmpl;
         return ec;
     }
 
@@ -102,11 +101,10 @@ Request::ErrorCode RequestManagerClone::clone(int source_id, const string &name,
     {
         att.resp_msg = ar.message;
 
-        delete tmpl;
         return AUTHORIZATION;
     }
 
-    rc = pool_allocate(source_id, tmpl, new_id, att);
+    rc = pool_allocate(source_id, move(tmpl), new_id, att);
 
     if ( rc < 0 )
     {
diff --git a/src/rm/RequestManagerImage.cc b/src/rm/RequestManagerImage.cc
index cd009f9cee..46276a5ccb 100644
--- a/src/rm/RequestManagerImage.cc
+++ b/src/rm/RequestManagerImage.cc
@@ -304,7 +304,7 @@ Request::ErrorCode ImageClone::request_execute(
     Image::DiskType disk_type;
     PoolObjectAuth  perms, ds_perms, ds_perms_orig;
 
-    ImageTemplate * tmpl;
+    unique_ptr<ImageTemplate> tmpl;
     Template        img_usage;
 
     Nebula&  nd = Nebula::instance();
@@ -365,7 +365,7 @@ Request::ErrorCode ImageClone::request_execute(
     }
     else //Update from base image
     {
-        Image::test_set_persistent(tmpl, att.uid, att.gid, false);
+        Image::test_set_persistent(tmpl.get(), att.uid, att.gid, false);
     }
 
     // ----------------------- Get target Datastore info -----------------------
@@ -376,7 +376,6 @@ Request::ErrorCode ImageClone::request_execute(
         {
             att.resp_msg = "Clone only supported for IMAGE_DS Datastores";
 
-            delete tmpl;
             return ACTION;
         }
 
@@ -396,7 +395,6 @@ Request::ErrorCode ImageClone::request_execute(
         att.resp_obj = PoolObjectSQL::DATASTORE;
         att.resp_id  = ds_id;
 
-        delete tmpl;
         return NO_EXISTS;
     }
 
@@ -409,7 +407,6 @@ Request::ErrorCode ImageClone::request_execute(
             att.resp_obj = PoolObjectSQL::DATASTORE;
             att.resp_id  = ds_id_orig;
 
-            delete tmpl;
             return NO_EXISTS;
         }
 
@@ -417,7 +414,6 @@ Request::ErrorCode ImageClone::request_execute(
         {
             att.resp_msg = "Clone only supported for IMAGE_DS Datastores";
 
-            delete tmpl;
             return ACTION;
         }
 
@@ -425,7 +421,6 @@ Request::ErrorCode ImageClone::request_execute(
         {
             att.resp_msg = "Clone only supported to same DS_MAD Datastores";
 
-            delete tmpl;
             return ACTION;
         }
 
@@ -441,7 +436,6 @@ Request::ErrorCode ImageClone::request_execute(
     {
         att.resp_msg = "Not enough space in datastore";
 
-        delete tmpl;
         return ACTION;
     }
 
@@ -471,7 +465,6 @@ Request::ErrorCode ImageClone::request_execute(
     {
         att.resp_msg = ar.message;
 
-        delete tmpl;
         return AUTHORIZATION;
     }
 
@@ -480,7 +473,6 @@ Request::ErrorCode ImageClone::request_execute(
     if ( quota_authorization(&img_usage, Quotas::DATASTORE, att,
                 att.resp_msg) == false )
     {
-        delete tmpl;
         return AUTHORIZATION;
     }
 
@@ -489,7 +481,7 @@ Request::ErrorCode ImageClone::request_execute(
                          att.uname,
                          att.gname,
                          att.umask,
-                         tmpl,
+                         move(tmpl),
                          ds_id,
                          ds_name,
                          disk_type,
diff --git a/src/rm/RequestManagerInfo.cc b/src/rm/RequestManagerInfo.cc
index d5a45a9c1e..62357b1aff 100644
--- a/src/rm/RequestManagerInfo.cc
+++ b/src/rm/RequestManagerInfo.cc
@@ -86,7 +86,7 @@ void TemplateInfo::request_execute(xmlrpc_c::paramList const& paramList,
 {
     VMTemplatePool * tpool   = static_cast<VMTemplatePool *>(pool);
 
-    VirtualMachineTemplate * extended_tmpl = nullptr;
+    unique_ptr<VirtualMachineTemplate> extended_tmpl;
 
     PoolObjectAuth perms;
 
@@ -122,9 +122,9 @@ void TemplateInfo::request_execute(xmlrpc_c::paramList const& paramList,
 
     if (extended)
     {
-        VirtualMachine::set_auth_request(att.uid, ar, extended_tmpl, false);
+        VirtualMachine::set_auth_request(att.uid, ar, extended_tmpl.get(), false);
 
-        VirtualMachineDisks::extended_info(att.uid, extended_tmpl);
+        VirtualMachineDisks::extended_info(att.uid, extended_tmpl.get());
     }
 
     if (UserPool::authorize(ar) == -1)
@@ -132,7 +132,6 @@ void TemplateInfo::request_execute(xmlrpc_c::paramList const& paramList,
         att.resp_msg = ar.message;
         failure_response(AUTHORIZATION, att);
 
-        delete extended_tmpl;
         return;
     }
 
@@ -151,15 +150,13 @@ void TemplateInfo::request_execute(xmlrpc_c::paramList const& paramList,
 
     if (extended)
     {
-        vm_tmpl->to_xml(str, extended_tmpl);
+        vm_tmpl->to_xml(str, extended_tmpl.get());
     }
     else
     {
         vm_tmpl->to_xml(str);
     }
 
-    delete extended_tmpl;
-
     success_response(str, att);
 
     return;
diff --git a/src/rm/RequestManagerVMTemplate.cc b/src/rm/RequestManagerVMTemplate.cc
index 8f68f238f6..eebb5c88eb 100644
--- a/src/rm/RequestManagerVMTemplate.cc
+++ b/src/rm/RequestManagerVMTemplate.cc
@@ -136,13 +136,10 @@ Request::ErrorCode VMTemplateInstantiate::request_execute(int id, string name,
     VirtualMachinePool* vmpool  = nd.get_vmpool();
     VMTemplatePool *    tpool   = nd.get_tpool();
 
-    VirtualMachineTemplate * tmpl;
+    unique_ptr<VirtualMachineTemplate> tmpl;
     VirtualMachineTemplate extended_tmpl;
     VirtualMachineTemplate uattrs;
 
-    vector<Template *> ds_quotas;
-    vector<Template *> applied;
-
     string aname;
     string tmpl_name;
 
@@ -162,11 +159,10 @@ Request::ErrorCode VMTemplateInstantiate::request_execute(int id, string name,
         return NO_EXISTS;
     }
 
-    ErrorCode ec = merge(tmpl, str_uattrs, att);
+    ErrorCode ec = merge(tmpl.get(), str_uattrs, att);
 
     if (ec != SUCCESS)
     {
-        delete tmpl;
         return ec;
     }
 
@@ -175,11 +171,10 @@ Request::ErrorCode VMTemplateInstantiate::request_execute(int id, string name,
         tmpl->merge(extra_attrs);
     }
 
-    ec = as_uid_gid(tmpl, att);
+    ec = as_uid_gid(tmpl.get(), att);
 
     if ( ec != SUCCESS )
     {
-        delete tmpl;
         return ec;
     }
 
@@ -200,9 +195,8 @@ Request::ErrorCode VMTemplateInstantiate::request_execute(int id, string name,
         tmpl->set(new SingleAttribute("NAME",name));
     }
 
-    if (VirtualMachine::parse_topology(tmpl, att.resp_msg) != 0)
+    if (VirtualMachine::parse_topology(tmpl.get(), att.resp_msg) != 0)
     {
-        delete tmpl;
         return ALLOCATE;
     }
 
@@ -233,7 +227,6 @@ Request::ErrorCode VMTemplateInstantiate::request_execute(int id, string name,
     {
         att.resp_msg = ar.message;
 
-        delete tmpl;
         return AUTHORIZATION;
     }
 
@@ -248,17 +241,19 @@ Request::ErrorCode VMTemplateInstantiate::request_execute(int id, string name,
     if (quota_authorization(&extended_tmpl, Quotas::VIRTUALMACHINE, att,
                 att.resp_msg) == false)
     {
-        delete tmpl;
         return AUTHORIZATION;
     }
 
     bool ds_quota_auth = true;
 
+    vector<unique_ptr<Template>> ds_quotas;
+    vector<unique_ptr<Template>> applied;
+
     VirtualMachineDisks::image_ds_quotas(&extended_tmpl, ds_quotas);
 
-    for ( auto ds : ds_quotas )
+    for ( auto& ds : ds_quotas )
     {
-        if ( quota_authorization(ds, Quotas::DATASTORE, att, att.resp_msg)
+        if ( quota_authorization(ds.get(), Quotas::DATASTORE, att, att.resp_msg)
                 == false )
         {
             ds_quota_auth = false;
@@ -266,7 +261,7 @@ Request::ErrorCode VMTemplateInstantiate::request_execute(int id, string name,
         }
         else
         {
-            applied.push_back(ds);
+            applied.push_back(move(ds));
         }
     }
 
@@ -274,42 +269,29 @@ Request::ErrorCode VMTemplateInstantiate::request_execute(int id, string name,
     {
         quota_rollback(&extended_tmpl, Quotas::VIRTUALMACHINE, att);
 
-        for ( auto ds : applied )
+        for ( auto& ds : applied )
         {
-            quota_rollback(ds, Quotas::DATASTORE, att);
+            quota_rollback(ds.get(), Quotas::DATASTORE, att);
         }
 
-        for ( auto ds : ds_quotas )
-        {
-            delete ds;
-        }
-
-        delete tmpl;
-
         return AUTHORIZATION;
     }
 
     rc = vmpool->allocate(att.uid, att.gid, att.uname, att.gname, att.umask,
-            tmpl, &vid, att.resp_msg, on_hold);
+            move(tmpl), &vid, att.resp_msg, on_hold);
 
     if ( rc < 0 )
     {
         quota_rollback(&extended_tmpl, Quotas::VIRTUALMACHINE, att);
 
-        for ( auto ds : ds_quotas )
+        for ( auto& ds : ds_quotas )
         {
-            quota_rollback(ds, Quotas::DATASTORE, att);
-            delete ds;
+            quota_rollback(ds.get(), Quotas::DATASTORE, att);
         }
 
         return ALLOCATE;
     }
 
-    for ( auto ds : ds_quotas )
-    {
-        delete ds;
-    }
-
     return SUCCESS;
 }
 
diff --git a/src/rm/RequestManagerVNTemplate.cc b/src/rm/RequestManagerVNTemplate.cc
index a621d8b8d4..58c37179a5 100644
--- a/src/rm/RequestManagerVNTemplate.cc
+++ b/src/rm/RequestManagerVNTemplate.cc
@@ -94,7 +94,7 @@ Request::ErrorCode VNTemplateInstantiate::request_execute(int id, string name,
     VNTemplatePool*     vntpool = nd.get_vntpool();
     ClusterPool*        clpool  = nd.get_clpool();
 
-    VirtualNetworkTemplate * tmpl;
+    unique_ptr<VirtualNetworkTemplate> tmpl;
     VirtualNetworkTemplate extended_tmpl;
 
     string tmpl_name;
@@ -131,11 +131,10 @@ Request::ErrorCode VNTemplateInstantiate::request_execute(int id, string name,
         cluster_ids.insert(0);
     }
 
-    ErrorCode ec = merge(tmpl, str_uattrs, att);
+    ErrorCode ec = merge(tmpl.get(), str_uattrs, att);
 
     if (ec != SUCCESS)
     {
-        delete tmpl;
         return ec;
     }
 
@@ -144,11 +143,10 @@ Request::ErrorCode VNTemplateInstantiate::request_execute(int id, string name,
         tmpl->merge(extra_attrs);
     }
 
-    ec = as_uid_gid(tmpl, att);
+    ec = as_uid_gid(tmpl.get(), att);
 
     if ( ec != SUCCESS )
     {
-        delete tmpl;
         return ec;
     }
 
@@ -174,12 +172,11 @@ Request::ErrorCode VNTemplateInstantiate::request_execute(int id, string name,
     {
         att.resp_msg = ar.message;
 
-        delete tmpl;
         return AUTHORIZATION;
     }
 
     rc = vnpool->allocate(att.uid, att.gid, att.uname, att.gname, att.umask,
-            -1, tmpl, &vid, cluster_ids, att.resp_msg);
+            -1, move(tmpl), &vid, cluster_ids, att.resp_msg);
 
     if ( rc < 0 )
     {
diff --git a/src/rm/RequestManagerVirtualMachine.cc b/src/rm/RequestManagerVirtualMachine.cc
index 5a3a8663d6..42f9e2a275 100644
--- a/src/rm/RequestManagerVirtualMachine.cc
+++ b/src/rm/RequestManagerVirtualMachine.cc
@@ -1400,7 +1400,7 @@ void VirtualMachineDiskSaveas::request_execute(
     Image::ImageType type;
     Image::DiskType  ds_disk_type;
 
-    ImageTemplate * itemplate;
+    unique_ptr<ImageTemplate> itemplate;
     Template        img_usage;
 
     int    rc;
@@ -1499,7 +1499,7 @@ void VirtualMachineDiskSaveas::request_execute(
     // -------------------------------------------------------------------------
     // Create a template for the new Image
     // -------------------------------------------------------------------------
-    itemplate = new ImageTemplate;
+    itemplate = make_unique<ImageTemplate>();
 
     itemplate->add("NAME", img_name);
     itemplate->add("SIZE", size);
@@ -1533,7 +1533,7 @@ void VirtualMachineDiskSaveas::request_execute(
         itemplate->add("DEV_PREFIX", dev_prefix);
     }
 
-    Image::test_set_persistent(itemplate, att.uid, att.gid, false);
+    Image::test_set_persistent(itemplate.get(), att.uid, att.gid, false);
 
     img_usage.add("SIZE",      size);
     img_usage.add("DATASTORE", ds_id);
@@ -1541,7 +1541,7 @@ void VirtualMachineDiskSaveas::request_execute(
     // -------------------------------------------------------------------------
     // Authorize the operation & check quotas
     // -------------------------------------------------------------------------
-    rc_auth = vm_authorization(id, itemplate, 0, att, 0, &ds_perms, 0);
+    rc_auth = vm_authorization(id, itemplate.get(), 0, att, 0, &ds_perms, 0);
 
     if ( rc_auth == true )
     {
@@ -1561,7 +1561,7 @@ void VirtualMachineDiskSaveas::request_execute(
                          att.uname,
                          att.gname,
                          att.umask,
-                         itemplate,
+                         move(itemplate),
                          ds_id,
                          ds_name,
                          ds_disk_type,
@@ -1617,7 +1617,6 @@ error_size:
     goto error_common;
 
 error_auth:
-    delete itemplate;
     goto error_common;
 
 error_allocate:
@@ -2970,11 +2969,9 @@ void VirtualMachineUpdateConf::request_execute(
     {
         string aname;
 
-        VirtualMachineTemplate * conf_tmpl = vm->get_updateconf_template();
+        auto conf_tmpl = vm->get_updateconf_template();
 
-        bool has_restricted = tmpl.check_restricted(aname, conf_tmpl);
-
-        delete conf_tmpl;
+        bool has_restricted = tmpl.check_restricted(aname, conf_tmpl.get());
 
         if (has_restricted)
         {
diff --git a/src/rm/RequestManagerVirtualNetwork.cc b/src/rm/RequestManagerVirtualNetwork.cc
index d38286c8f6..93caf13ee4 100644
--- a/src/rm/RequestManagerVirtualNetwork.cc
+++ b/src/rm/RequestManagerVirtualNetwork.cc
@@ -186,7 +186,7 @@ void VirtualNetworkReserve::request_execute(
     int rc;
     set<int> cluster_ids;
 
-    VirtualNetworkTemplate * vtmpl;
+    unique_ptr<VirtualNetworkTemplate> vtmpl;
 
     PoolObjectAuth reserv_perms;
 
@@ -352,8 +352,6 @@ void VirtualNetworkReserve::request_execute(
         att.resp_msg = ar.message;
         failure_response(AUTHORIZATION, att);
 
-        delete vtmpl;
-
         return;
     }
 
@@ -365,7 +363,7 @@ void VirtualNetworkReserve::request_execute(
         vtmpl->replace("NAME", name);
 
         rc = vnpool->allocate(att.uid, att.gid, att.uname, att.gname, att.umask,
-                id, vtmpl, &rid, cluster_ids, att.resp_msg);
+                id, move(vtmpl), &rid, cluster_ids, att.resp_msg);
 
         if (rc < 0)
         {
diff --git a/src/scheduler/include/VirtualMachineXML.h b/src/scheduler/include/VirtualMachineXML.h
index bbba401ccc..63788ccb72 100644
--- a/src/scheduler/include/VirtualMachineXML.h
+++ b/src/scheduler/include/VirtualMachineXML.h
@@ -119,16 +119,6 @@ public:
 
     ~VirtualMachineXML()
     {
-        if (vm_template != 0)
-        {
-            delete vm_template;
-        }
-
-        if (user_template != 0)
-        {
-            delete user_template;
-        }
-
         for (auto nic : nics)
         {
             delete nic.second;
@@ -410,13 +400,13 @@ public:
     }
 
     /**
-     * Removes (but does not delete) the scheduled actions of the VM
+     * Get scheduled actions of the VM
      *
      * @param attributes to hold the VM actions
      */
-    SchedActions * get_actions() const
+    SchedActions get_actions() const
     {
-        return new SchedActions(user_template);
+        return SchedActions(user_template.get());
     }
 
     /**
@@ -508,8 +498,8 @@ protected:
 
     std::map<int, VirtualMachineNicXML *> nics;
 
-    VirtualMachineTemplate * vm_template;   /**< The VM template */
-    VirtualMachineTemplate * user_template; /**< The VM user template */
+    std::unique_ptr<VirtualMachineTemplate> vm_template;   /**< The VM template */
+    std::unique_ptr<VirtualMachineTemplate> user_template; /**< The VM user template */
 };
 
 #endif /* VM_XML_H_ */
diff --git a/src/scheduler/src/pool/VirtualMachineXML.cc b/src/scheduler/src/pool/VirtualMachineXML.cc
index c9ad16bed9..d8b98da0ed 100644
--- a/src/scheduler/src/pool/VirtualMachineXML.cc
+++ b/src/scheduler/src/pool/VirtualMachineXML.cc
@@ -154,23 +154,22 @@ void VirtualMachineXML::init_attributes()
 
         for (auto it_nodes = nodes.begin(); it_nodes != nodes.end(); ++it_nodes)
         {
-            VirtualMachineTemplate * nic_template = new VirtualMachineTemplate;
+            VirtualMachineTemplate nic_template;
 
-            nic_template->from_xml_node(*it_nodes);
+            nic_template.from_xml_node(*it_nodes);
 
-            bool rc = nic_template->get("NETWORK_MODE", net_mode);
+            bool rc = nic_template.get("NETWORK_MODE", net_mode);
             one_util::toupper(net_mode);
 
             if ( !rc || net_mode != "AUTO" )
             {
-                delete nic_template;
                 continue;
             }
 
             std::string reqs, rank;
             int nic_id;
 
-            nic_template->get("NIC_ID", nic_id);
+            nic_template.get("NIC_ID", nic_id);
 
             nics_ids_auto.insert(nic_id);
 
@@ -178,7 +177,7 @@ void VirtualMachineXML::init_attributes()
 
             nics.insert(make_pair(nic_id, the_nic));
 
-            if ( nic_template->get("SCHED_REQUIREMENTS", reqs) )
+            if ( nic_template.get("SCHED_REQUIREMENTS", reqs) )
             {
                 if ( !automatic_nic_requirements.empty() )
                 {
@@ -192,12 +191,10 @@ void VirtualMachineXML::init_attributes()
                 the_nic->set_requirements(reqs);
             }
 
-            if ( nic_template->get("SCHED_RANK", rank) )
+            if ( nic_template.get("SCHED_RANK", rank) )
             {
                 the_nic->set_rank(rank);
             }
-
-            delete nic_template;
         }
 
         free_nodes(nodes);
@@ -210,7 +207,7 @@ void VirtualMachineXML::init_attributes()
     /**************************************************************************/
     if (get_nodes("/VM/TEMPLATE", nodes) > 0)
     {
-        vm_template = new VirtualMachineTemplate;
+        vm_template = make_unique<VirtualMachineTemplate>();
 
         vm_template->from_xml_node(nodes[0]);
 
@@ -218,14 +215,14 @@ void VirtualMachineXML::init_attributes()
     }
     else
     {
-        vm_template = 0;
+        vm_template = nullptr;
     }
 
     nodes.clear();
 
     if (get_nodes("/VM/USER_TEMPLATE", nodes) > 0)
     {
-        user_template = new VirtualMachineTemplate;
+        user_template = make_unique<VirtualMachineTemplate>();
 
         user_template->from_xml_node(nodes[0]);
 
diff --git a/src/scheduler/src/sched/Scheduler.cc b/src/scheduler/src/sched/Scheduler.cc
index 75aa82e67c..ab552efbec 100644
--- a/src/scheduler/src/sched/Scheduler.cc
+++ b/src/scheduler/src/sched/Scheduler.cc
@@ -1702,9 +1702,9 @@ int Scheduler::do_scheduled_actions()
 
         vm = static_cast<VirtualMachineXML *>(vm_it->second);
 
-        SchedActions * sas = vm->get_actions();
+        SchedActions sas = vm->get_actions();
 
-        for ( action = sas->begin(); action != sas->end(); ++action)
+        for ( action = sas.begin(); action != sas.end(); ++action)
         {
             ostringstream oss;
 
@@ -1761,12 +1761,10 @@ int Scheduler::do_scheduled_actions()
             NebulaLog::log("VM", Log::INFO, oss);
         }
 
-        if ( !sas->empty() ) //Do not update VMs without SCHED_ACTION
+        if ( !sas.empty() ) //Do not update VMs without SCHED_ACTION
         {
             vmpool->update(vm);
         }
-
-        delete sas;
     }
 
     return 0;
diff --git a/src/secgroup/SecurityGroup.cc b/src/secgroup/SecurityGroup.cc
index 4394fd53b5..39e80597d7 100644
--- a/src/secgroup/SecurityGroup.cc
+++ b/src/secgroup/SecurityGroup.cc
@@ -32,20 +32,20 @@ SecurityGroup::SecurityGroup(
         const string&   _uname,
         const string&   _gname,
         int             _umask,
-        Template*       sgroup_template):
+        unique_ptr<Template> sgroup_template):
     PoolObjectSQL(-1, SECGROUP, "", _uid,_gid,_uname,_gname,one_db::sg_table),
     updated("UPDATED_VMS"),
     outdated("OUTDATED_VMS"),
     updating("UPDATING_VMS"),
     error("ERROR_VMS")
 {
-    if (sgroup_template != 0)
+    if (sgroup_template)
     {
-        obj_template = sgroup_template;
+        obj_template = move(sgroup_template);
     }
     else
     {
-        obj_template = new Template;
+        obj_template = make_unique<Template>();
     }
 
     set_umask(_umask);
diff --git a/src/secgroup/SecurityGroupPool.cc b/src/secgroup/SecurityGroupPool.cc
index 498c44c7f3..e2f4982209 100644
--- a/src/secgroup/SecurityGroupPool.cc
+++ b/src/secgroup/SecurityGroupPool.cc
@@ -46,7 +46,7 @@ SecurityGroupPool::SecurityGroupPool(SqlDB * db)
 
         string error;
 
-        Template * default_tmpl = new Template;
+        auto default_tmpl = make_unique<Template>();
         char * error_parse;
 
         default_tmpl->parse(default_sg, &error_parse);
@@ -57,7 +57,7 @@ SecurityGroupPool::SecurityGroupPool(SqlDB * db)
                 oneadmin->get_uname(),
                 oneadmin->get_gname(),
                 oneadmin->get_umask(),
-                default_tmpl);
+                move(default_tmpl));
 
         secgroup->set_permissions(1,1,1,1,0,0,1,0,0,error);
 
@@ -87,18 +87,17 @@ int SecurityGroupPool::allocate(
         const string&   uname,
         const string&   gname,
         int             umask,
-        Template *      sgroup_template,
+        unique_ptr<Template> sgroup_template,
         int *           oid,
         string&         error_str)
 {
-    SecurityGroup * secgroup;
-
     int    db_oid;
     string name;
 
     ostringstream oss;
 
-    secgroup = new SecurityGroup(uid, gid, uname, gname, umask, sgroup_template);
+    auto secgroup = new SecurityGroup(uid, gid, uname, gname, umask,
+                                      move(sgroup_template));
 
     // -------------------------------------------------------------------------
     // Check name & duplicates
@@ -118,7 +117,7 @@ int SecurityGroupPool::allocate(
         goto error_duplicated;
     }
 
-    *oid = PoolSQL::allocate(secgroup, error_str);
+    *oid = PoolSQL::allocate(move(secgroup), error_str);
 
     return *oid;
 
diff --git a/src/template/Template.cc b/src/template/Template.cc
index 79b3fbc5c8..58f470c483 100644
--- a/src/template/Template.cc
+++ b/src/template/Template.cc
@@ -171,21 +171,18 @@ int Template::parse_str_or_xml(const string &parse_str, string& error_msg)
 
 void Template::marshall(string &str, const char delim)
 {
-    multimap<string,Attribute *>::iterator  it;
-    string *                                attr;
+    str = "";
 
-    for(it=attributes.begin(),str="";it!=attributes.end();it++)
+    for(auto it = attributes.begin(); it != attributes.end(); it++)
     {
-        attr = it->second->marshall();
+        string attr = it->second->marshall();
 
-        if ( attr == 0 )
+        if ( attr.empty() )
         {
             continue;
         }
 
-        str += it->first + "=" + *attr + delim;
-
-        delete attr;
+        str += it->first + "=" + attr + delim;
     }
 }
 
@@ -487,16 +484,12 @@ string& Template::to_token(string& str) const
 string& Template::to_str(string& str) const
 {
     ostringstream os;
-    multimap<string,Attribute *>::const_iterator  it;
-    string *                                s;
 
-    for ( it = attributes.begin(); it!=attributes.end(); it++)
+    for ( auto it = attributes.begin(); it!=attributes.end(); it++)
     {
-        s = it->second->marshall(",");
+        string s = it->second->marshall(",");
 
-        os << it->first << separator << *s << endl;
-
-        delete s;
+        os << it->first << separator << s << endl;
     }
 
     str = os.str();
diff --git a/src/um/Quota.cc b/src/um/Quota.cc
index cb716b9d9f..b64be36a8f 100644
--- a/src/um/Quota.cc
+++ b/src/um/Quota.cc
@@ -132,11 +132,9 @@ error_limits:
 
     oss <<  "Negative limits or bad format in quota " << template_name;
 
-    string * quota_str = (*it)->marshall(",");
+    string quota_str = (*it)->marshall(",");
 
-    oss << " = [ " << *quota_str << " ]";
-
-    delete quota_str;
+    oss << " = [ " << quota_str << " ]";
 
     error = oss.str();
 
diff --git a/src/vdc/Vdc.cc b/src/vdc/Vdc.cc
index c93337d60a..f99ed3d813 100644
--- a/src/vdc/Vdc.cc
+++ b/src/vdc/Vdc.cc
@@ -26,7 +26,7 @@ const int    Vdc::ALL_RESOURCES = -10;
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 
-Vdc::Vdc(int id, Template* vdc_template):
+Vdc::Vdc(int id, unique_ptr<Template> vdc_template):
         PoolObjectSQL(id, VDC, "", -1, -1, "", "", one_db::vdc_table),
         clusters(PoolObjectSQL::CLUSTER),
         hosts(PoolObjectSQL::HOST),
@@ -34,13 +34,13 @@ Vdc::Vdc(int id, Template* vdc_template):
         vnets(PoolObjectSQL::NET)
 
 {
-    if (vdc_template != 0)
+    if (vdc_template)
     {
-        obj_template = vdc_template;
+        obj_template = move(vdc_template);
     }
     else
     {
-        obj_template = new Template;
+        obj_template = make_unique<Template>();
     }
 }
 
diff --git a/src/vdc/VdcPool.cc b/src/vdc/VdcPool.cc
index 92cd213710..de01961f7b 100644
--- a/src/vdc/VdcPool.cc
+++ b/src/vdc/VdcPool.cc
@@ -42,7 +42,7 @@ VdcPool::VdcPool(SqlDB * db, bool is_federation_slave)
     if (get_lastOID() == -1)
     {
         ostringstream vdc_tmpl;
-        Template *    tmpl = new Template;
+        auto tmpl = make_unique<Template>();
 
         // Build the default vdc
         vdc_tmpl << "NAME=" << DEFAULT_NAME << endl
@@ -57,7 +57,7 @@ VdcPool::VdcPool(SqlDB * db, bool is_federation_slave)
             goto error_bootstrap;
         }
 
-        allocate(tmpl, &rc, error_str);
+        allocate(move(tmpl), &rc, error_str);
 
         if( rc < 0 )
         {
@@ -90,12 +90,10 @@ error_bootstrap:
 /* -------------------------------------------------------------------------- */
 
 int VdcPool::allocate(
-        Template *  vdc_template,
+        unique_ptr<Template> vdc_template,
         int *       oid,
         string&     error_str)
 {
-    Vdc * vdc;
-
     int    db_oid;
     string name;
 
@@ -110,7 +108,7 @@ int VdcPool::allocate(
         return -1;
     }
 
-    vdc = new Vdc(-1, vdc_template);
+    auto vdc = new Vdc(-1, move(vdc_template));
 
     // -------------------------------------------------------------------------
     // Check name & duplicates
diff --git a/src/vm/VirtualMachine.cc b/src/vm/VirtualMachine.cc
index bf83c239fa..39d08273d7 100644
--- a/src/vm/VirtualMachine.cc
+++ b/src/vm/VirtualMachine.cc
@@ -45,7 +45,7 @@ VirtualMachine::VirtualMachine(int           id,
                                const string& _uname,
                                const string& _gname,
                                int           umask,
-                               VirtualMachineTemplate * _vm_template):
+                               unique_ptr<VirtualMachineTemplate> _vm_template):
         PoolObjectSQL(id,VM,"",_uid,_gid,_uname,_gname,one_db::vm_table),
         state(INIT),
         prev_state(INIT),
@@ -66,14 +66,14 @@ VirtualMachine::VirtualMachine(int           id,
         // This is a VM Template, with the root TEMPLATE.
         _vm_template->set_xml_root("USER_TEMPLATE");
 
-        user_obj_template = _vm_template;
+        user_obj_template = move(_vm_template);
     }
     else
     {
-        user_obj_template = new VirtualMachineTemplate(false,'=',"USER_TEMPLATE");
+        user_obj_template = make_unique<VirtualMachineTemplate>(false,'=',"USER_TEMPLATE");
     }
 
-    obj_template = new VirtualMachineTemplate;
+    obj_template = make_unique<VirtualMachineTemplate>();
 
     set_umask(umask);
 }
@@ -86,7 +86,6 @@ VirtualMachine::~VirtualMachine()
     }
 
     delete _log;
-    delete user_obj_template;
 }
 
 /* -------------------------------------------------------------------------- */
@@ -893,12 +892,12 @@ int VirtualMachine::insert(SqlDB * db, string& error_str)
     // ------------------------------------------------------------------------
     // Check the CPU Model attribute
     // ------------------------------------------------------------------------
-    parse_cpu_model(user_obj_template);
+    parse_cpu_model(user_obj_template.get());
 
     // ------------------------------------------------------------------------
     // Validate RAW attribute
     // ------------------------------------------------------------------------
-    rc = Nebula::instance().get_vmm()->validate_raw(obj_template, error_str);
+    rc = Nebula::instance().get_vmm()->validate_raw(obj_template.get(), error_str);
 
     if (rc != 0)
     {
@@ -908,7 +907,7 @@ int VirtualMachine::insert(SqlDB * db, string& error_str)
     // ------------------------------------------------------------------------
     // PCI Devices (Needs to be parsed before network)
     // ------------------------------------------------------------------------
-    rc = parse_pci(error_str, user_obj_template);
+    rc = parse_pci(error_str, user_obj_template.get());
 
     if ( rc != 0 )
     {
@@ -918,7 +917,7 @@ int VirtualMachine::insert(SqlDB * db, string& error_str)
     // ------------------------------------------------------------------------
     // Parse the defaults to merge
     // ------------------------------------------------------------------------
-    rc = parse_defaults(error_str, user_obj_template);
+    rc = parse_defaults(error_str, user_obj_template.get());
 
     if ( rc != 0 )
     {
@@ -928,7 +927,7 @@ int VirtualMachine::insert(SqlDB * db, string& error_str)
     // ------------------------------------------------------------------------
     // Parse the virtual router attributes
     // ------------------------------------------------------------------------
-    rc = parse_vrouter(error_str, user_obj_template);
+    rc = parse_vrouter(error_str, user_obj_template.get());
 
     if ( rc != 0 )
     {
@@ -974,7 +973,7 @@ int VirtualMachine::insert(SqlDB * db, string& error_str)
     // -------------------------------------------------------------------------
     // Set boot order
     // -------------------------------------------------------------------------
-    rc = set_boot_order(obj_template, error_str);
+    rc = set_boot_order(obj_template.get(), error_str);
 
     if ( rc != 0 )
     {
@@ -1005,7 +1004,7 @@ int VirtualMachine::insert(SqlDB * db, string& error_str)
         goto error_requirements;
     }
 
-    if ( parse_graphics(error_str, user_obj_template) != 0 )
+    if ( parse_graphics(error_str, user_obj_template.get()) != 0 )
     {
         goto error_graphics;
     }
@@ -1530,14 +1529,14 @@ int VirtualMachine::automatic_requirements(set<int>& cluster_ids,
     obj_template->erase("AUTOMATIC_DS_REQUIREMENTS");
     obj_template->erase("AUTOMATIC_NIC_REQUIREMENTS");
 
-    int rc = get_cluster_requirements(obj_template, cluster_ids, error_str);
+    int rc = get_cluster_requirements(obj_template.get(), cluster_ids, error_str);
 
     if (rc != 0)
     {
         return -1;
     }
 
-    rc = get_datastore_requirements(obj_template, datastore_ids, error_str);
+    rc = get_datastore_requirements(obj_template.get(), datastore_ids, error_str);
 
     if (rc == -1)
     {
@@ -1984,7 +1983,7 @@ int VirtualMachine::resize(float cpu, long int memory, unsigned int vcpu,
 
     remove_template_attribute("NUMA_NODE");
 
-    return parse_topology(obj_template, error);
+    return parse_topology(obj_template.get(), error);
 }
 
 /* -------------------------------------------------------------------------- */
@@ -2519,8 +2518,8 @@ int VirtualMachine::replace_template(
 {
     string ra;
 
-    VirtualMachineTemplate * new_tmpl =
-            new VirtualMachineTemplate(false,'=',"USER_TEMPLATE");
+    auto new_tmpl =
+        make_unique<VirtualMachineTemplate>(false,'=',"USER_TEMPLATE");
 
     if ( new_tmpl == 0 )
     {
@@ -2530,7 +2529,6 @@ int VirtualMachine::replace_template(
 
     if ( new_tmpl->parse_str_or_xml(tmpl_str, error) != 0 )
     {
-        delete new_tmpl;
         return -1;
     }
 
@@ -2538,11 +2536,10 @@ int VirtualMachine::replace_template(
     /*  Parse attributes in USER_TEMPLATE:                                    */
     /*  - SCHED_ACTION                                                        */
     /* ---------------------------------------------------------------------- */
-    SchedActions sactions(new_tmpl);
+    SchedActions sactions(new_tmpl.get());
 
     if ( sactions.parse(error, false) == -1 )
     {
-        delete new_tmpl;
         return -1;
     }
 
@@ -2550,13 +2547,13 @@ int VirtualMachine::replace_template(
     /* Replace new_tmpl to the current user_template                          */
     /* ---------------------------------------------------------------------- */
 
-    if (user_obj_template != 0)
+    if (user_obj_template)
     {
-        if (keep_restricted && new_tmpl->check_restricted(ra, user_obj_template))
+        if (keep_restricted &&
+            new_tmpl->check_restricted(ra, user_obj_template.get()))
         {
             error = "Tried to change restricted attribute: " + ra;
 
-            delete new_tmpl;
             return -1;
         }
     }
@@ -2564,24 +2561,19 @@ int VirtualMachine::replace_template(
     {
         error = "Tried to set restricted attribute: " + ra;
 
-        delete new_tmpl;
         return -1;
     }
 
-    auto old_user_tmpl = user_obj_template;
-    user_obj_template  = new_tmpl;
+    auto old_user_tmpl = move(user_obj_template);
+    user_obj_template  = move(new_tmpl);
 
     if (post_update_template(error) == -1)
     {
-        delete user_obj_template;
-
-        user_obj_template = old_user_tmpl;
+        user_obj_template = move(old_user_tmpl);
 
         return -1;
     }
 
-    delete old_user_tmpl;
-
     encrypt();
 
     return 0;
@@ -2595,8 +2587,8 @@ int VirtualMachine::append_template(
         bool            keep_restricted,
         string&         error)
 {
-    VirtualMachineTemplate * new_tmpl =
-            new VirtualMachineTemplate(false,'=',"USER_TEMPLATE");
+    auto new_tmpl =
+        make_unique<VirtualMachineTemplate>(false,'=',"USER_TEMPLATE");
     string rname;
 
     if ( new_tmpl == 0 )
@@ -2607,7 +2599,6 @@ int VirtualMachine::append_template(
 
     if ( new_tmpl->parse_str_or_xml(tmpl_str, error) != 0 )
     {
-        delete new_tmpl;
         return -1;
     }
 
@@ -2615,34 +2606,29 @@ int VirtualMachine::append_template(
     /*  Parse attributes in USER_TEMPLATE:                                    */
     /*  - SCHED_ACTION                                                        */
     /* ---------------------------------------------------------------------- */
-    SchedActions sactions(new_tmpl);
+    SchedActions sactions(new_tmpl.get());
 
     if ( sactions.parse(error, false) == -1 )
     {
-        delete new_tmpl;
         return -1;
     }
 
     /* ---------------------------------------------------------------------- */
     /* Append new_tmpl to the current user_template                           */
     /* ---------------------------------------------------------------------- */
-    auto old_user_tmpl = new VirtualMachineTemplate(*user_obj_template);
+    auto old_user_tmpl = make_unique<VirtualMachineTemplate>(*user_obj_template);
 
     if (user_obj_template != 0)
     {
-        if (keep_restricted && new_tmpl->check_restricted(rname, user_obj_template))
+        if (keep_restricted &&
+            new_tmpl->check_restricted(rname, user_obj_template.get()))
         {
             error ="User Template includes a restricted attribute " + rname;
 
-            delete new_tmpl;
-            delete old_user_tmpl;
-
             return -1;
         }
 
-        user_obj_template->merge(new_tmpl);
-
-        delete new_tmpl;
+        user_obj_template->merge(new_tmpl.get());
     }
     else
     {
@@ -2650,26 +2636,19 @@ int VirtualMachine::append_template(
         {
             error ="User Template includes a restricted attribute " + rname;
 
-            delete new_tmpl;
-            delete old_user_tmpl;
-
             return -1;
         }
 
-        user_obj_template = new_tmpl;
+        user_obj_template = move(new_tmpl);
     }
 
     if (post_update_template(error) == -1)
     {
-        delete user_obj_template;
-
-        user_obj_template = old_user_tmpl;
+        user_obj_template = move(old_user_tmpl);
 
         return -1;
     }
 
-    delete old_user_tmpl;
-
     encrypt();
 
     return 0;
@@ -2895,22 +2874,22 @@ int VirtualMachine::updateconf(VirtualMachineTemplate& tmpl, string &err)
     // -------------------------------------------------------------------------
     // Update OS, FEATURES, INPUT, GRAPHICS, RAW, CPU_MODEL
     // -------------------------------------------------------------------------
-    replace_vector_values(obj_template, &tmpl, "OS");
+    replace_vector_values(obj_template.get(), &tmpl, "OS");
 
-    if ( set_boot_order(obj_template, err) != 0 )
+    if ( set_boot_order(obj_template.get(), err) != 0 )
     {
         return -1;
     }
 
-    replace_vector_values(obj_template, &tmpl, "FEATURES");
+    replace_vector_values(obj_template.get(), &tmpl, "FEATURES");
 
-    replace_vector_values(obj_template, &tmpl, "INPUT");
+    replace_vector_values(obj_template.get(), &tmpl, "INPUT");
 
-    replace_vector_values(obj_template, &tmpl, "GRAPHICS");
+    replace_vector_values(obj_template.get(), &tmpl, "GRAPHICS");
 
-    replace_vector_values(obj_template, &tmpl, "RAW");
+    replace_vector_values(obj_template.get(), &tmpl, "RAW");
 
-    replace_vector_values(obj_template, &tmpl, "CPU_MODEL");
+    replace_vector_values(obj_template.get(), &tmpl, "CPU_MODEL");
 
     // -------------------------------------------------------------------------
     // Update CONTEXT: any value
@@ -2959,7 +2938,7 @@ int VirtualMachine::updateconf(VirtualMachineTemplate& tmpl, string &err)
     // -------------------------------------------------------------------------
     // Parse graphics attribute
     // -------------------------------------------------------------------------
-    if ( parse_graphics(err, obj_template) != 0 )
+    if ( parse_graphics(err, obj_template.get()) != 0 )
     {
         NebulaLog::log("ONE",Log::ERROR, err);
         return -1;
@@ -2971,19 +2950,19 @@ int VirtualMachine::updateconf(VirtualMachineTemplate& tmpl, string &err)
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 
-VirtualMachineTemplate * VirtualMachine::get_updateconf_template() const
+unique_ptr<VirtualMachineTemplate> VirtualMachine::get_updateconf_template() const
 {
-    VirtualMachineTemplate * conf_tmpl = new VirtualMachineTemplate();
+    auto conf_tmpl = make_unique<VirtualMachineTemplate>();
 
-    copy_vector_values(obj_template, conf_tmpl, "OS");
+    copy_vector_values(obj_template.get(), conf_tmpl.get(), "OS");
 
-    copy_vector_values(obj_template, conf_tmpl, "FEATURES");
+    copy_vector_values(obj_template.get(), conf_tmpl.get(), "FEATURES");
 
-    copy_vector_values(obj_template, conf_tmpl, "INPUT");
+    copy_vector_values(obj_template.get(), conf_tmpl.get(), "INPUT");
 
-    copy_vector_values(obj_template, conf_tmpl, "GRAPHICS");
+    copy_vector_values(obj_template.get(), conf_tmpl.get(), "GRAPHICS");
 
-    copy_vector_values(obj_template, conf_tmpl, "RAW");
+    copy_vector_values(obj_template.get(), conf_tmpl.get(), "RAW");
 
 	VectorAttribute * context = obj_template->get("CONTEXT");
 
@@ -3564,7 +3543,7 @@ void VirtualMachine::release_vmgroup()
 
 int VirtualMachine::parse_sched_action(string& error_str)
 {
-    SchedActions sactions(user_obj_template);
+    SchedActions sactions(user_obj_template.get());
 
     return sactions.parse(error_str, false);
 }
diff --git a/src/vm/VirtualMachineContext.cc b/src/vm/VirtualMachineContext.cc
index d4231145be..10899191ec 100644
--- a/src/vm/VirtualMachineContext.cc
+++ b/src/vm/VirtualMachineContext.cc
@@ -312,7 +312,6 @@ int VirtualMachine::generate_network_context(VectorAttribute* context,
     int rc;
 
     string  parsed;
-    string* str;
 
     VectorAttribute tmp_context("TMP_CONTEXT");
 
@@ -394,17 +393,15 @@ int VirtualMachine::generate_network_context(VectorAttribute* context,
         return 0;
     }
 
-    str = tmp_context.marshall();
+    string str = tmp_context.marshall();
 
-    if (str == 0)
+    if (str.empty())
     {
         error_str = "Internal error generating network context";
         return -1;
     }
 
-    rc = parse_template_attribute(*str, parsed, error_str);
-
-    delete str;
+    rc = parse_template_attribute(str, parsed, error_str);
 
     if (rc != 0)
     {
@@ -661,17 +658,15 @@ int VirtualMachine::parse_context_variables(VectorAttribute ** context,
 {
     int rc;
 
-    string   parsed;
-    string * str = (*context)->marshall();
+    string parsed;
+    string str = (*context)->marshall();
 
-    if (str == 0)
+    if (str.empty())
     {
         return -1;
     }
 
-    rc = parse_template_attribute(*str, parsed, error_str);
-
-    delete str;
+    rc = parse_template_attribute(str, parsed, error_str);
 
     if (rc != 0)
     {
diff --git a/src/vm/VirtualMachineDisk.cc b/src/vm/VirtualMachineDisk.cc
index 938d47d9af..e648dfc7aa 100644
--- a/src/vm/VirtualMachineDisk.cc
+++ b/src/vm/VirtualMachineDisk.cc
@@ -618,7 +618,7 @@ long long VirtualMachineDisks::system_ds_size(Template * ds_tmpl)
 /* -------------------------------------------------------------------------- */
 
 void VirtualMachineDisks::image_ds_quotas(Template * tmpl,
-        vector<Template *>& ds_quotas)
+        vector<unique_ptr<Template>>& ds_quotas)
 {
     VirtualMachineDisks disks(tmpl, false);
 
@@ -628,13 +628,13 @@ void VirtualMachineDisks::image_ds_quotas(Template * tmpl,
 
         if ( ds_size != 0 )
         {
-            Template * d_ds = new Template();
+            auto d_ds = make_unique<Template>();
 
             d_ds->add("DATASTORE", (*it)->vector_value("DATASTORE_ID"));
             d_ds->add("SIZE", ds_size);
             d_ds->add("IMAGES", 0);
 
-            ds_quotas.push_back(d_ds);
+            ds_quotas.push_back(move(d_ds));
         }
     }
 }
diff --git a/src/vm/VirtualMachineParser.cc b/src/vm/VirtualMachineParser.cc
index 8ead12d305..89577bae81 100644
--- a/src/vm/VirtualMachineParser.cc
+++ b/src/vm/VirtualMachineParser.cc
@@ -658,19 +658,17 @@ int VirtualMachine::parse_file_attribute(string       attribute,
 int VirtualMachine::parse_public_clouds(const char * pname, string& error)
 {
     vector<VectorAttribute *>           attrs;
-    vector<VectorAttribute *>::iterator it;
 
-    string * str;
     string p_vatt;
 
     int rc  = 0;
     int num = user_obj_template->remove(pname, attrs);
 
-    for (it = attrs.begin(); it != attrs.end(); it++)
+    for (auto attr : attrs)
     {
-        str = (*it)->marshall();
+        string str = attr->marshall();
 
-        if ( str == 0 )
+        if ( str.empty() )
         {
             ostringstream oss;
             oss << "Internal error processing " << pname;
@@ -679,9 +677,7 @@ int VirtualMachine::parse_public_clouds(const char * pname, string& error)
             break;
         }
 
-        rc = parse_template_attribute(*str, p_vatt, error);
-
-        delete str;
+        rc = parse_template_attribute(str, p_vatt, error);
 
         if ( rc != 0 )
         {
diff --git a/src/vm/VirtualMachinePool.cc b/src/vm/VirtualMachinePool.cc
index 88880e935b..c375194006 100644
--- a/src/vm/VirtualMachinePool.cc
+++ b/src/vm/VirtualMachinePool.cc
@@ -131,19 +131,17 @@ int VirtualMachinePool::allocate(
     const string&  uname,
     const string&  gname,
     int            umask,
-    VirtualMachineTemplate * vm_template,
+    unique_ptr<VirtualMachineTemplate> vm_template,
     int *          oid,
     string&        error_str,
     bool           on_hold)
 {
-    VirtualMachine * vm;
-
     string deploy_id;
 
     // ------------------------------------------------------------------------
     // Build a new Virtual Machine object
     // ------------------------------------------------------------------------
-    vm = new VirtualMachine(-1, uid, gid, uname, gname, umask, vm_template);
+    auto vm = new VirtualMachine(-1, uid, gid, uname, gname, umask, move(vm_template));
 
     if ( _submit_on_hold == true || on_hold )
     {
diff --git a/src/vm_group/VMGroup.cc b/src/vm_group/VMGroup.cc
index 146405be0c..80bceafe8f 100644
--- a/src/vm_group/VMGroup.cc
+++ b/src/vm_group/VMGroup.cc
@@ -28,16 +28,16 @@ using namespace std;
 /* -------------------------------------------------------------------------- */
 
 VMGroup::VMGroup(int _uid, int _gid, const string& _uname, const string& _gname,
-        int _umask, Template * group_template):
+        int _umask, unique_ptr<Template> group_template):
     PoolObjectSQL(-1, VMGROUP, "", _uid, _gid, _uname, _gname, one_db::vm_group_table)
 {
-    if (group_template != 0)
+    if (group_template)
     {
-        obj_template = group_template;
+        obj_template = move(group_template);
     }
     else
     {
-        obj_template = new Template;
+        obj_template = make_unique<Template>();
     }
 
     set_umask(_umask);
diff --git a/src/vm_group/VMGroupPool.cc b/src/vm_group/VMGroupPool.cc
index bc680dae48..811572a70c 100644
--- a/src/vm_group/VMGroupPool.cc
+++ b/src/vm_group/VMGroupPool.cc
@@ -20,8 +20,8 @@
 using namespace std;
 
 int VMGroupPool::allocate(int uid, int gid, const string& uname,
-        const string& gname, int umask, Template * vmgroup_template, int * oid,
-        string& error_str)
+        const string& gname, int umask, unique_ptr<Template> vmgroup_template,
+        int * oid, string& error_str)
 {
     VMGroup * vmgrp;
 
@@ -30,7 +30,7 @@ int VMGroupPool::allocate(int uid, int gid, const string& uname,
 
     ostringstream os;
 
-    vmgrp = new VMGroup(uid, gid, uname, gname, umask, vmgroup_template);
+    vmgrp = new VMGroup(uid, gid, uname, gname, umask, move(vmgroup_template));
 
     vmgrp->get_template_attribute("NAME", name);
 
diff --git a/src/vm_template/VMTemplate.cc b/src/vm_template/VMTemplate.cc
index c971295186..fb9e97e392 100644
--- a/src/vm_template/VMTemplate.cc
+++ b/src/vm_template/VMTemplate.cc
@@ -32,17 +32,17 @@ VMTemplate::VMTemplate(int id,
                        const string& _uname,
                        const string& _gname,
                        int umask,
-                       VirtualMachineTemplate * _template_contents):
+                       unique_ptr<Template> _template_contents):
     PoolObjectSQL(id,TEMPLATE,"",_uid,_gid,_uname,_gname,one_db::vm_template_table),
     regtime(time(0))
 {
-    if (_template_contents != 0)
+    if (_template_contents)
     {
-        obj_template = _template_contents;
+        obj_template = move(_template_contents);
     }
     else
     {
-        obj_template = new VirtualMachineTemplate;
+        obj_template = make_unique<VirtualMachineTemplate>();
     }
 
     set_umask(umask);
@@ -72,7 +72,7 @@ int VMTemplate::insert(SqlDB *db, string& error_str)
     // ------------------------------------------------------------------------
     // Validate RAW attribute
     // ------------------------------------------------------------------------
-    rc = Nebula::instance().get_vmm()->validate_raw(obj_template, error_str);
+    rc = Nebula::instance().get_vmm()->validate_raw(obj_template.get(), error_str);
 
     if (rc != 0)
     {
@@ -188,7 +188,7 @@ int VMTemplate::bootstrap(SqlDB * db)
 
 int VMTemplate::parse_sched_action(string& error_str)
 {
-    SchedActions sactions(obj_template);
+    SchedActions sactions(obj_template.get());
 
     return sactions.parse(error_str, true);
 }
@@ -207,7 +207,7 @@ int VMTemplate::post_update_template(string& error)
         return rc;
     }
 
-    rc = Nebula::instance().get_vmm()->validate_raw(obj_template, error);
+    rc = Nebula::instance().get_vmm()->validate_raw(obj_template.get(), error);
 
     if (rc != 0)
     {
@@ -223,7 +223,7 @@ int VMTemplate::post_update_template(string& error)
 
 string& VMTemplate::to_xml(string& xml) const
 {
-    return to_xml(xml, obj_template);
+    return to_xml(xml, obj_template.get());
 }
 
 /* ------------------------------------------------------------------------ */
diff --git a/src/vm_template/VMTemplatePool.cc b/src/vm_template/VMTemplatePool.cc
index 1940f13633..867bd90fd2 100644
--- a/src/vm_template/VMTemplatePool.cc
+++ b/src/vm_template/VMTemplatePool.cc
@@ -31,12 +31,10 @@ int VMTemplatePool::allocate (
         const string&            uname,
         const string&            gname,
         int                      umask,
-        VirtualMachineTemplate * template_contents,
+        unique_ptr<VirtualMachineTemplate> template_contents,
         int *                    oid,
         string&                  error_str)
 {
-    VMTemplate *  vm_template;
-
     int     db_oid;
     string  name;
 
@@ -45,7 +43,8 @@ int VMTemplatePool::allocate (
     // ------------------------------------------------------------------------
     // Build a new VMTemplate object
     // ------------------------------------------------------------------------
-    vm_template = new VMTemplate(-1, uid, gid, uname, gname, umask, template_contents);
+    auto vm_template = new VMTemplate(-1, uid, gid, uname, gname, umask,
+                                      move(template_contents));
 
     // Check name
     vm_template->get_template_attribute("NAME", name);
@@ -67,7 +66,7 @@ int VMTemplatePool::allocate (
     // Insert the Object in the pool
     // ------------------------------------------------------------------------
 
-    *oid = PoolSQL::allocate(vm_template, error_str);
+    *oid = PoolSQL::allocate(move(vm_template), error_str);
 
     return *oid;
 
diff --git a/src/vn_template/VNTemplate.cc b/src/vn_template/VNTemplate.cc
index 52ed9d995f..1c9ad47efb 100644
--- a/src/vn_template/VNTemplate.cc
+++ b/src/vn_template/VNTemplate.cc
@@ -30,17 +30,17 @@ VNTemplate::VNTemplate(int id,
                        const string& _uname,
                        const string& _gname,
                        int umask,
-                       VirtualNetworkTemplate * _template_contents):
+                       unique_ptr<VirtualNetworkTemplate> _template_contents):
     PoolObjectSQL(id,VNTEMPLATE,"",_uid,_gid,_uname,_gname,one_db::vn_template_table),
     regtime(time(0))
 {
-    if (_template_contents != 0)
+    if (_template_contents)
     {
-        obj_template = _template_contents;
+        obj_template = move(_template_contents);
     }
     else
     {
-        obj_template = new VirtualNetworkTemplate;
+        obj_template = make_unique<VirtualNetworkTemplate>();
     }
 
     set_umask(umask);
@@ -87,7 +87,8 @@ int VNTemplate::insert(SqlDB *db, string& error_str)
 
     get_template_attribute("OUTER_VLAN_ID", outer_id);
 
-    rc = VirtualNetwork::parse_phydev_vlans(obj_template, vn_mad, phydev, bridge, auto_id, vlan_id, auto_outer, outer_id, error_str);
+    rc = VirtualNetwork::parse_phydev_vlans(obj_template.get(), vn_mad, phydev,
+            bridge, auto_id, vlan_id, auto_outer, outer_id, error_str);
 
     if (rc == -1)
     {
diff --git a/src/vn_template/VNTemplatePool.cc b/src/vn_template/VNTemplatePool.cc
index dc3ae404c2..5d0fc66923 100644
--- a/src/vn_template/VNTemplatePool.cc
+++ b/src/vn_template/VNTemplatePool.cc
@@ -31,12 +31,10 @@ int VNTemplatePool::allocate (
         const string&            uname,
         const string&            gname,
         int                      umask,
-        VirtualNetworkTemplate * template_contents,
+        unique_ptr<VirtualNetworkTemplate> template_contents,
         int *                    oid,
         string&                  error_str)
 {
-    VNTemplate *  vn_template;
-
     int     db_oid;
     string  name;
 
@@ -45,7 +43,8 @@ int VNTemplatePool::allocate (
     // ------------------------------------------------------------------------
     // Build a new VNTemplate object
     // ------------------------------------------------------------------------
-    vn_template = new VNTemplate(-1, uid, gid, uname, gname, umask, template_contents);
+    auto vn_template = new VNTemplate(-1, uid, gid, uname, gname, umask,
+                                      move(template_contents));
 
     // Check name
     vn_template->get_template_attribute("NAME", name);
@@ -67,7 +66,7 @@ int VNTemplatePool::allocate (
     // Insert the Object in the pool
     // ------------------------------------------------------------------------
 
-    *oid = PoolSQL::allocate(vn_template, error_str);
+    *oid = PoolSQL::allocate(move(vn_template), error_str);
 
     return *oid;
 
diff --git a/src/vnm/VirtualNetwork.cc b/src/vnm/VirtualNetwork.cc
index 2386594e36..878e90e4af 100644
--- a/src/vnm/VirtualNetwork.cc
+++ b/src/vnm/VirtualNetwork.cc
@@ -43,7 +43,7 @@ VirtualNetwork::VirtualNetwork(int                      _uid,
                                int                      _umask,
                                int                      _pvid,
                                const set<int>           &_cluster_ids,
-                               VirtualNetworkTemplate * _vn_template):
+                               unique_ptr<VirtualNetworkTemplate> _vn_template):
             PoolObjectSQL(-1,NET,"",_uid,_gid,_uname,_gname,one_db::vn_table),
             Clusterable(_cluster_ids),
             bridge(""),
@@ -52,13 +52,13 @@ VirtualNetwork::VirtualNetwork(int                      _uid,
             parent_vid(_pvid),
             vrouters("VROUTERS")
 {
-    if (_vn_template != 0)
+    if (_vn_template)
     {
-        obj_template = _vn_template;
+        obj_template = move(_vn_template);
     }
     else
     {
-        obj_template = new VirtualNetworkTemplate;
+        obj_template = make_unique<VirtualNetworkTemplate>();
     }
 
     set_umask(_umask);
@@ -274,7 +274,8 @@ int VirtualNetwork::insert(SqlDB * db, string& error_str)
     // -------------------------------------------------------------------------
     // Check consistency for PHYDEV, BRIDGE and VLAN_IDs based on the driver
     // -------------------------------------------------------------------------
-    rc = parse_phydev_vlans(obj_template, vn_mad, phydev, bridge, vlan_id_automatic, vlan_id,
+    rc = parse_phydev_vlans(obj_template.get(), vn_mad, phydev, bridge,
+                            vlan_id_automatic, vlan_id,
                             outer_vlan_id_automatic, outer_vlan_id, error_str);
 
     if (rc != 0)
diff --git a/src/vnm/VirtualNetworkPool.cc b/src/vnm/VirtualNetworkPool.cc
index f63cf559bc..82b37664dd 100644
--- a/src/vnm/VirtualNetworkPool.cc
+++ b/src/vnm/VirtualNetworkPool.cc
@@ -117,21 +117,18 @@ int VirtualNetworkPool::allocate (
         const string&               gname,
         int                         umask,
         int                         pvid,
-        VirtualNetworkTemplate *    vn_template,
+        unique_ptr<VirtualNetworkTemplate> vn_template,
         int *                       oid,
         const set<int>              &cluster_ids,
         string&                     error_str)
 {
-    VirtualNetwork * vn;
+    VirtualNetwork * vn = nullptr;
 
     int    db_oid;
     string name;
 
     ostringstream oss;
 
-    vn = new VirtualNetwork(uid, gid, uname, gname, umask, pvid,
-                            cluster_ids, vn_template);
-
     vn_template->get("NAME", name);
 
     // Check for duplicates
@@ -142,6 +139,9 @@ int VirtualNetworkPool::allocate (
         goto error_duplicated;
     }
 
+    vn = new VirtualNetwork(uid, gid, uname, gname, umask, pvid,
+                            cluster_ids, move(vn_template));
+
     // Insert the VN in the DB
     *oid = PoolSQL::allocate(vn, error_str);
 
diff --git a/src/vrouter/VirtualRouter.cc b/src/vrouter/VirtualRouter.cc
index 298d9fbfb0..fc05536869 100644
--- a/src/vrouter/VirtualRouter.cc
+++ b/src/vrouter/VirtualRouter.cc
@@ -77,17 +77,17 @@ VirtualRouter::VirtualRouter(   int             id,
                                 const string&   _uname,
                                 const string&   _gname,
                                 int             _umask,
-                                Template * _template_contents):
+                                unique_ptr<Template> _template_contents):
         PoolObjectSQL(id,VROUTER,"",_uid,_gid,_uname,_gname,one_db::vr_table),
         vms("VMS")
 {
-    if (_template_contents != 0)
+    if (_template_contents)
     {
-        obj_template = _template_contents;
+        obj_template = move(_template_contents);
     }
     else
     {
-        obj_template = new Template;
+        obj_template = make_unique<Template>();
     }
 
     set_umask(_umask);
@@ -156,7 +156,7 @@ int VirtualRouter::drop(SqlDB * db)
     {
         release_network_leases();
 
-        Quotas::quota_del(Quotas::VIRTUALROUTER, uid, gid, obj_template);
+        Quotas::quota_del(Quotas::VIRTUALROUTER, uid, gid, obj_template.get());
     }
 
     return rc;
@@ -509,10 +509,10 @@ Template * VirtualRouter::get_vm_template() const
 int VirtualRouter::replace_template(const string &tmpl_str,bool keep_restricted,
 		string& error)
 {
-    Template * new_tmpl = get_new_template();
+    auto       new_tmpl = get_new_template();
     string     new_str;
 
-    if ( new_tmpl == 0 )
+    if ( !new_tmpl )
     {
         error = "Cannot allocate a new template";
         return -1;
@@ -520,24 +520,21 @@ int VirtualRouter::replace_template(const string &tmpl_str,bool keep_restricted,
 
     if ( new_tmpl->parse_str_or_xml(tmpl_str, error) != 0 )
     {
-        delete new_tmpl;
         return -1;
     }
 
     new_tmpl->erase("NIC");
 
     vector<const VectorAttribute*> nics;
-	vector<const VectorAttribute*>::const_iterator it;
 
     get_template_attribute("NIC", nics);
 
-    for (it = nics.begin(); it != nics.end(); it++)
+    for (auto nic : nics)
     {
-        new_tmpl->set((*it)->clone());
+        new_tmpl->set(nic->clone());
     }
 
     new_tmpl->to_xml(new_str);
-    delete new_tmpl;
 
     return PoolObjectSQL::replace_template(new_str, keep_restricted, error);
 }
@@ -548,10 +545,10 @@ int VirtualRouter::replace_template(const string &tmpl_str,bool keep_restricted,
 int VirtualRouter::append_template(const string& tmpl_str, bool keep_restricted,
 	   	string& error)
 {
-    Template * new_tmpl = get_new_template();
+    auto       new_tmpl = get_new_template();
     string     new_str;
 
-    if ( new_tmpl == 0 )
+    if ( !new_tmpl )
     {
         error = "Cannot allocate a new template";
         return -1;
@@ -559,14 +556,12 @@ int VirtualRouter::append_template(const string& tmpl_str, bool keep_restricted,
 
     if ( new_tmpl->parse_str_or_xml(tmpl_str, error) != 0 )
     {
-        delete new_tmpl;
         return -1;
     }
 
     new_tmpl->erase("NIC");
 
     new_tmpl->to_xml(new_str);
-    delete new_tmpl;
 
     return PoolObjectSQL::append_template(new_str, keep_restricted, error);
 }
diff --git a/src/zone/Zone.cc b/src/zone/Zone.cc
index d8d97b998e..89ff60cf8d 100644
--- a/src/zone/Zone.cc
+++ b/src/zone/Zone.cc
@@ -30,18 +30,18 @@ const char * ZoneServers::SERVER_ID_NAME = "ID";
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 
-Zone::Zone(int id, Template* zone_template):
+Zone::Zone(int id, unique_ptr<Template> zone_template):
     PoolObjectSQL(id, ZONE, "", -1, -1, "", "", one_db::zone_table),
     servers_template(false, '=', "SERVER_POOL"),
     servers(0)
 {
-    if (zone_template != 0)
+    if (zone_template)
     {
-        obj_template = zone_template;
+        obj_template = move(zone_template);
     }
     else
     {
-        obj_template = new Template;
+        obj_template = make_unique<Template>();
     }
 }
 
diff --git a/src/zone/ZonePool.cc b/src/zone/ZonePool.cc
index 4cb6aba667..397e2b54a4 100644
--- a/src/zone/ZonePool.cc
+++ b/src/zone/ZonePool.cc
@@ -63,10 +63,9 @@ ZonePool::ZonePool(SqlDB * db, bool is_federation_slave)
     if (get_lastOID() == -1)
     {
         int         rc;
-        Template *  tmpl;
 
         // Build the local zone
-        tmpl = new Template;
+        auto tmpl = make_unique<Template>();
         rc = tmpl->parse_str_or_xml(
                 zone_tmpl.str(),
                 error_str);
@@ -76,7 +75,7 @@ ZonePool::ZonePool(SqlDB * db, bool is_federation_slave)
             goto error_bootstrap;
         }
 
-        allocate(tmpl, &rc, error_str);
+        allocate(move(tmpl), &rc, error_str);
 
         if( rc < 0 )
         {
@@ -102,7 +101,7 @@ error_bootstrap:
 /* -------------------------------------------------------------------------- */
 
 int ZonePool::allocate(
-        Template *  zone_template,
+        unique_ptr<Template> zone_template,
         int *       oid,
         string&     error_str)
 {
@@ -122,7 +121,7 @@ int ZonePool::allocate(
         return -1;
     }
 
-    zone = new Zone(-1, zone_template);
+    zone = new Zone(-1, move(zone_template));
 
     // -------------------------------------------------------------------------
     // Check name & duplicates