diff --git a/server/AyaNova/Controllers/WorkOrderController.cs b/server/AyaNova/Controllers/WorkOrderController.cs
index 0fc17211..124cf59b 100644
--- a/server/AyaNova/Controllers/WorkOrderController.cs
+++ b/server/AyaNova/Controllers/WorkOrderController.cs
@@ -42,13 +42,13 @@ namespace AyaNova.Api.Controllers
 
         #region WorkOrder top level routes
         /// <summary>
-        /// Create WorkOrder "header"
+        /// Create WorkOrder
         /// </summary>
-        /// <param name="newObject">WorkOrder top level only, no descendents are evaluated</param>
+        /// <param name="newObject">WorkOrder - top level only, no descendents</param>
         /// <param name="apiVersion">From route path</param>
-        /// <returns>WorkOrder "header" object</returns>
+        /// <returns>WorkOrder</returns>
         [HttpPost]
-        public async Task<IActionResult> PostWorkOrder([FromBody] WorkOrder newObject, ApiVersion apiVersion)
+        public async Task<IActionResult> PostWorkOrder([FromBody] dtWorkOrder newObject, ApiVersion apiVersion)
         {
             if (!serverState.IsOpen)
                 return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
@@ -71,7 +71,7 @@ namespace AyaNova.Api.Controllers
         /// </summary>
         /// <param name="id">Source object id</param>
         /// <param name="apiVersion">From route path</param>
-        /// <returns>Full WorkOrder object including all descendents</returns>
+        /// <returns>WorkOrder</returns>
         [HttpPost("duplicate/{id}")]
         public async Task<IActionResult> DuplicateWorkOrder([FromRoute] long id, ApiVersion apiVersion)
         {
@@ -91,10 +91,10 @@ namespace AyaNova.Api.Controllers
 
 
         /// <summary>
-        /// Get full WorkOrder object
+        /// Get WorkOrder
         /// </summary>
         /// <param name="id"></param>
-        /// <returns>Entire WorkOrder object including all descendents</returns>
+        /// <returns>WorkOrder</returns>
         [HttpGet("{id}")]
         public async Task<IActionResult> GetWorkOrder([FromRoute] long id)
         {
@@ -112,16 +112,14 @@ namespace AyaNova.Api.Controllers
 
 
         /// <summary>
-        /// Put (update) WorkOrder
-        /// This route does not evaluate nor update nor return the entire WorkOrder object graph
-        /// only the "header" or top level
-        /// Descendent objects must be updated via their individual routes seperately
+        /// Put (update) WorkOrder        
+        /// (Descendent objects must be updated via their individual routes seperately)
         /// </summary>
         /// <param name="id">WorkOrder id</param>
-        /// <param name="updatedObject">WorkOrder top level only, no descendents are evaluated</param>
+        /// <param name="updatedObject">WorkOrder - top level only, no descendents</param>
         /// <returns>New concurrency token</returns>
         [HttpPut("{id}")]
-        public async Task<IActionResult> PutWorkOrder([FromRoute] long id, [FromBody] WorkOrder updatedObject)
+        public async Task<IActionResult> PutWorkOrder([FromRoute] long id, [FromBody] dtWorkOrder updatedObject)
         {
             if (!serverState.IsOpen)
                 return StatusCode(503, new ApiErrorResponse(serverState.ApiErrorCode, null, serverState.Reason));
diff --git a/server/AyaNova/biz/WorkOrderBiz.cs b/server/AyaNova/biz/WorkOrderBiz.cs
index cdfdc672..e6e63bf1 100644
--- a/server/AyaNova/biz/WorkOrderBiz.cs
+++ b/server/AyaNova/biz/WorkOrderBiz.cs
@@ -43,8 +43,10 @@ namespace AyaNova.Biz
         ////////////////////////////////////////////////////////////////////////////////////////////////
         //CREATE   
         //
-        internal async Task<WorkOrder> CreateAsync(WorkOrder newObject)
+        internal async Task<WorkOrder> CreateAsync(dtWorkOrder dtNewObject)
         {
+            WorkOrder newObject = new WorkOrder();
+            CopyObject.Copy(dtNewObject, newObject);
             await ValidateAsync(newObject, null);
             if (HasErrors)
                 return null;
@@ -116,12 +118,8 @@ namespace AyaNova.Biz
         ////////////////////////////////////////////////////////////////////////////////////////////////
         //UPDATE
         //       
-        internal async Task<WorkOrder> PutAsync(long id, WorkOrder putObj)
+        internal async Task<WorkOrder> PutAsync(long id, dtWorkOrder dtPutObject)
         {
-            //TODO: THIS IS ALL WRONG, NEEDS TO HANDLE DESCENDENTS WITH TAGS AND SUCH
-            //IDEALLY IT SHOULD CALL THE OTHER METHODS TO HANDLE THEM INDIVIDUALLY   
-            //OR...SHOULD IT ONLY EVER HANDLE THE TOP LEVEL....hmmm....
-            //I guess it would work if it traversed the input workorder and did each bit individually
 
             WorkOrder dbObject = await GetAsync(id, false);
             if (dbObject == null)
@@ -135,22 +133,18 @@ namespace AyaNova.Biz
             CopyObject.Copy(dbObject, SnapshotOfOriginalDBObj);
 
             //Replace the db object with the PUT object
-            CopyObject.Copy(putObj, dbObject, "Id,Serial");
+            CopyObject.Copy(dtPutObject, dbObject, "Id,Serial");
 
             //if user has rights then change it, otherwise just ignore it and do the rest
-            if (SnapshotOfOriginalDBObj.Serial != putObj.Serial && Authorized.HasAnyRole(CurrentUserRoles, RolesAllowedToChangeSerial))
+            if (SnapshotOfOriginalDBObj.Serial != dtPutObject.Serial && Authorized.HasAnyRole(CurrentUserRoles, RolesAllowedToChangeSerial))
             {
-                dbObject.Serial = putObj.Serial;
+                dbObject.Serial = dtPutObject.Serial;
             }
 
             dbObject.Tags = TagUtil.NormalizeTags(dbObject.Tags);
             dbObject.CustomFields = JsonUtil.CompactJson(dbObject.CustomFields);
 
-            //Set "original" value of concurrency token to input token
-            //this will allow EF to check it out
-            ct.Entry(dbObject).OriginalValues["ConcurrencyToken"] = putObj.ConcurrencyToken;
-
-
+            ct.Entry(dbObject).OriginalValues["ConcurrencyToken"] = dtPutObject.ConcurrencyToken;
             await ValidateAsync(dbObject, SnapshotOfOriginalDBObj);
             if (HasErrors)
                 return null;
@@ -199,21 +193,22 @@ namespace AyaNova.Biz
         ////////////////////////////////////////////////////////////////////////////////////////////////
         //DELETE
         //
-        internal async Task<bool> DeleteAsync(WorkOrder dbObj)
+        internal async Task<bool> DeleteAsync(long workorderId)
         {
 
+            WorkOrder dbObject = await GetAsync(workorderId);
 
-            // NOT REQUIRED NOW BUT IF IN FUTURE ValidateCanDelete(dbObj);
+            ValidateCanDelete(dbObject);
             if (HasErrors)
                 return false;
 
-            ct.WorkOrder.Remove(dbObj);
+            ct.WorkOrder.Remove(dbObject);
             await ct.SaveChangesAsync();
 
             //Log event 
-            await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObj.Id, dbObj.Serial.ToString(), ct);
-            await Search.ProcessDeletedObjectKeywordsAsync(dbObj.Id, BizType);
-            await TagUtil.ProcessDeleteTagsInRepositoryAsync(ct, dbObj.Tags);
+            await EventLogProcessor.DeleteObjectLogAsync(UserId, BizType, dbObject.Id, dbObject.Serial.ToString(), ct);
+            await Search.ProcessDeletedObjectKeywordsAsync(dbObject.Id, BizType);
+            await TagUtil.ProcessDeleteTagsInRepositoryAsync(ct, dbObject.Tags);
             return true;
         }
 
@@ -265,10 +260,10 @@ namespace AyaNova.Biz
 
 
         //Can delete?
-        // private void ValidateCanDelete(WorkOrder inObj)
-        // {
-        //     //whatever needs to be check to delete this object
-        // }
+        private void ValidateCanDelete(WorkOrder dbObject)
+        {
+            //whatever needs to be check to delete this object
+        }
         #endregion workorder level
 
         #region WorkOrderItem level
@@ -515,7 +510,7 @@ namespace AyaNova.Biz
             }
         }
 
- ////////////////////////////////////////////////////////////////////////////////////////////////
+        ////////////////////////////////////////////////////////////////////////////////////////////////
         // GET 
         //    
         internal async Task<WorkOrderItemPart> GetPartAsync(long id, bool logTheGetEvent = true)
diff --git a/server/AyaNova/models/WorkOrder.cs b/server/AyaNova/models/WorkOrder.cs
index 808f5888..cabb0582 100644
--- a/server/AyaNova/models/WorkOrder.cs
+++ b/server/AyaNova/models/WorkOrder.cs
@@ -5,11 +5,38 @@ using Newtonsoft.Json;
 
 namespace AyaNova.Models
 {
-    //NOTE: Any non required field (nullable in DB) sb nullable here, i.e. decimal? not decimal, 
-    //otherwise the server will call it an invalid record if the field isn't sent from client
-    
+
+    //Data transfer no child collections
+    public class dtWorkOrder
+    {
+        public dtWorkOrder()
+        {
+            Tags = new List<string>();
+        }
+
+        public long Id { get; set; }
+        public uint ConcurrencyToken { get; set; }
+
+        [Required]
+        public uint Serial { get; set; }
+        public bool Active { get; set; }
+        public string Notes { get; set; }
+        public string Wiki { get; set; }
+        public string CustomFields { get; set; }
+        public List<string> Tags { get; set; }
+
+    }//eoc
+
     public class WorkOrder
     {
+        public WorkOrder()
+        {
+            Tags = new List<string>();
+
+            //dependents
+            WorkorderItems = new List<WorkOrderItem>();
+        }
+
         public long Id { get; set; }
         public uint ConcurrencyToken { get; set; }
 
@@ -24,20 +51,9 @@ namespace AyaNova.Models
         //dependents
         public List<WorkOrderItem> WorkorderItems { get; set; }
 
-        public WorkOrder()
-        {
-            Tags = new List<string>();
-            WorkorderItems = new List<WorkOrderItem>();
-        }
 
-
-        //Not persisted business properties
-        // //NOTE: this could be a common class applied to everything for common biz rule stuff
-        // //i.e. specific rights in situations based on rules, like candelete, canedit etc
         // [NotMapped]
-        // public string OP { get; set; }//Patch operation value, e.g. "add", "remove", "replace"
-
-
+        // public string NotPersistedExample { get; set; }
     }//eoc
 
 }//eons