diff --git a/src/message.rs b/src/message.rs
index e449256..66062c1 100644
--- a/src/message.rs
+++ b/src/message.rs
@@ -989,9 +989,14 @@ mod fieldtypes {
             let result = ftype.get_default();
             match result {
                 Field::Uuid(data) => {
-                    assert!(!ids.contains(&data), "found duplicate id {:?} in {:?}", data, ids);
+                    assert!(
+                        !ids.contains(&data),
+                        "found duplicate id {:?} in {:?}",
+                        data,
+                        ids
+                    );
                     ids.push(data.clone());
-                },
+                }
                 _ => unreachable!("got {:?}: should have been uuid", result),
             }
         }
@@ -1078,19 +1083,38 @@ mod fields {
     }
 }
 
+#[derive(Clone, Debug)]
+enum DefaultSetting {
+    Value(Field),
+    FieldType,
+    None,
+}
+
 #[derive(Clone, Debug)]
 struct FieldSetting {
     fieldtype: FieldType,
+    default_setting: DefaultSetting,
 }
 
 impl FieldSetting {
     fn new(ftype: FieldType) -> Self {
-        Self { fieldtype: ftype }
+        Self {
+            fieldtype: ftype,
+            default_setting: DefaultSetting::None,
+        }
     }
 
     fn get_type(&self) -> &FieldType {
         &self.fieldtype
     }
+
+    fn set_default(&mut self, value: DefaultSetting) {
+        self.default_setting = value;
+    }
+
+    fn get_default(&self) -> &DefaultSetting {
+        &self.default_setting
+    }
 }
 
 #[cfg(test)]
@@ -1103,6 +1127,22 @@ mod fieldsettings {
         for ftype in ftypes.into_iter() {
             let fieldinfo = FieldSetting::new(ftype.clone());
             assert_eq!(fieldinfo.get_type(), &ftype);
+            let dset = fieldinfo.get_default();
+            match dset {
+                DefaultSetting::None => {}
+                _ => unreachable!("got {:?}: should have been none", dset),
+            }
+        }
+    }
+
+    #[test]
+    fn can_default_be_changed() {
+        let mut fieldinfo = FieldSetting::new(FieldType::Uuid);
+        fieldinfo.set_default(DefaultSetting::FieldType);
+        let dset = fieldinfo.get_default();
+        match dset {
+            DefaultSetting::FieldType => {}
+            _ => unreachable!("got {:?}: should have been none", dset),
         }
     }
 }
@@ -1202,6 +1242,11 @@ impl DocDef {
         }
     }
 
+    fn use_default_function(&mut self, field_name: &str) {
+        let setting = self.fields.get_mut(field_name).unwrap();
+        setting.set_default(DefaultSetting::FieldType);
+    }
+
     fn iter(&self) -> impl Iterator<Item = (&String, &FieldSetting)> {
         self.fields.iter()
     }
@@ -1247,6 +1292,19 @@ mod docdefs {
             assert_eq!(result.get_type(), &field_type);
         }
     }
+
+    #[test]
+    fn can_change_field_default_to_function() {
+        let mut docdef = DocDef::new();
+        let name = "defaultfunction";
+        docdef.add_field(name.to_string(), FieldType::StaticString);
+        docdef.use_default_function(name);
+        let dset = docdef.get_field(name).unwrap().get_default();
+        match dset {
+            DefaultSetting::FieldType => {}
+            _ => unreachable!("got {:?}: should have been field type", dset),
+        }
+    }
 }
 
 #[derive(Clone, Debug)]
@@ -1560,10 +1618,18 @@ impl DocumentFile {
                 }
             }
         }
-        for (key, _) in self.docdef.iter() {
+        for (key, value) in self.docdef.iter() {
             match holder.get_field(key) {
                 Some(_) => {}
-                None => return MTTError::DocumentFieldMissing(key.clone()).into(),
+                None => match value.get_default() {
+                    DefaultSetting::Value(_) => {}
+                    DefaultSetting::FieldType => {
+                        holder.add_field(key.clone(), value.get_type().get_default())
+                    }
+                    DefaultSetting::None => {
+                        return MTTError::DocumentFieldMissing(key.clone()).into()
+                    }
+                },
             }
         }
         self.docs.push(holder.clone());
@@ -2058,6 +2124,29 @@ mod document_files {
             _ => unreachable!("got {:?}: should have been a error", action),
         }
     }
+
+    #[test]
+    fn can_use_default_values() {
+        let doc_name = "default";
+        let mut docdef = create_docdef([FieldType::StaticString].to_vec());
+        docdef.use_default_function("field0");
+        let (queue, rx) = test_doc(doc_name, docdef, standard_routes());
+        let new_doc = Addition::new();
+        let msg = Message::new(doc_name, new_doc);
+        queue.send(msg).unwrap();
+        let result = rx.recv_timeout(TIMEOUT).unwrap();
+        let action = result.get_action();
+        match action {
+            MsgAction::Reply(docs) => {
+                assert_eq!(docs.len(), 1);
+                for doc in docs.iter() {
+                    let expected: Field = "".into();
+                    assert_eq!(doc.get_field("field0").unwrap(), &expected);
+                }
+            }
+            _ => unreachable!("got {:?}: should have gotten a reply", action),
+        }
+    }
 }
 
 #[cfg(test)]