diff --git a/src/document/field.rs b/src/document/field.rs
index 58234db..ee97984 100644
--- a/src/document/field.rs
+++ b/src/document/field.rs
@@ -349,13 +349,23 @@ enum DataOrigin {
 struct ParagraphData {
     string: String,
     origin: DataOrigin,
+    initial: bool,
 }
 
 impl ParagraphData {
+    fn initial(string: String) -> Self {
+        Self {
+            string: string,
+            origin: DataOrigin::Human,
+            initial: true,
+        }
+    }
+
     fn new(string: String, origin: DataOrigin) -> Self {
         Self {
             string: string,
             origin: origin,
+            initial: false,
         }
     }
 
@@ -369,24 +379,41 @@ impl ParagraphData {
             DataOrigin::Computer => false,
         }
     }
+
+    fn is_initial(&self) -> bool {
+        self.initial
+    }
 }
 
 #[cfg(test)]
 mod paragraph_data {
     use super::*;
 
+    #[test]
+    fn can_determine_initial_information() {
+        let text = Uuid::new_v4().to_string();
+        let data = ParagraphData::initial(text.clone());
+        assert_eq!(data.get_text(), &text);
+        assert!(data.by_human(), "{:?} should have returned true", data);
+        assert!(data.is_initial(), "{:?} should have returned true", data);
+    }
+
     #[test]
     fn can_be_made_by_humans() {
         let text = Uuid::new_v4().to_string();
         let data = ParagraphData::new(text.clone(), DataOrigin::Human);
+        assert_eq!(data.get_text(), &text);
         assert!(data.by_human(), "{:?} should have returned true", data);
+        assert!(!data.is_initial(), "{:?} should have returned false", data);
     }
 
     #[test]
     fn can_be_made_by_computers() {
         let text = Uuid::new_v4().to_string();
         let data = ParagraphData::new(text.clone(), DataOrigin::Computer);
-        assert!(!data.by_human(), "{:?} should have returned true", data);
+        assert_eq!(data.get_text(), &text);
+        assert!(!data.by_human(), "{:?} should have returned false", data);
+        assert!(!data.is_initial(), "{:?} should have returned false", data);
     }
 }
 
@@ -395,9 +422,9 @@ struct Paragraph {
 }
 
 impl Paragraph {
-    fn new(string: String, lang: Language) -> Self {
+    fn new(lang: Language, string: String) -> Self {
         let mut data = HashMap::new();
-        data.insert(lang, ParagraphData::new(string, DataOrigin::Human));
+        data.insert(lang, ParagraphData::initial(string));
         Self { data: data }
     }
 
@@ -423,7 +450,16 @@ impl Paragraph {
         }
     }
 
-    fn get_original(&self) -> HashMap<Language, String> {
+    fn get_initial(&self) -> (&Language, &String) {
+        for (lang, data) in self.data.iter() {
+            if data.is_initial() {
+                return (lang, data.get_text());
+            }
+        }
+        unreachable!("paragraph should initialize with data");
+    }
+
+    fn by_humans(&self) -> HashMap<Language, String> {
         let mut output = HashMap::new();
         for (lang, data) in self.data.iter() {
             if data.by_human() {
@@ -446,7 +482,7 @@ mod paragraphs {
         ];
         let data = Uuid::new_v4().to_string();
         for lang in languages.iter() {
-            let result = Paragraph::new(data.clone(), lang.clone());
+            let result = Paragraph::new(lang.clone(), data.clone());
             assert_eq!(result.get(lang).unwrap(), &data);
         }
     }
@@ -458,7 +494,7 @@ mod paragraphs {
             Language::from_639_1("en").unwrap(),
             Language::from_639_1("ja").unwrap(),
         ];
-        let mut paragraph = Paragraph::new(text[0].clone().to_string(), languages[0].clone());
+        let mut paragraph = Paragraph::new(languages[0].clone(), text[0].clone().to_string());
         paragraph.add_translation(text[1].clone().to_string(), languages[1].clone());
         for i in 0..text.len() {
             assert_eq!(paragraph.get(&languages[i]).unwrap(), text[i]);
@@ -469,7 +505,7 @@ mod paragraphs {
     fn does_add_translation_get_ignored_if_it_already_exists() {
         let text = "something";
         let lang = Language::from_639_1("en").unwrap();
-        let mut paragraph = Paragraph::new(text.to_string(), lang.clone());
+        let mut paragraph = Paragraph::new(lang.clone(), text.to_string());
         paragraph.add_translation("other".to_string(), lang);
         assert_eq!(paragraph.get(&lang).unwrap(), text);
     }
@@ -478,54 +514,80 @@ mod paragraphs {
     fn does_improve_translation_replace_existing() {
         let text = "new";
         let lang = Language::from_639_1("en").unwrap();
-        let mut paragraph = Paragraph::new("old".to_string(), lang.clone());
+        let mut paragraph = Paragraph::new(lang.clone(), "old".to_string());
         paragraph.improve_translation(text.to_string(), lang.clone());
         assert_eq!(paragraph.get(&lang).unwrap(), text);
     }
 
     #[test]
-    fn can_determine_original_text() {
+    fn can_determine_human_text() {
         let text = "something";
         let lang = Language::from_639_1("en").unwrap();
-        let paragraph = Paragraph::new(text.to_string(), lang.clone());
-        let result = paragraph.get_original();
+        let paragraph = Paragraph::new(lang.clone(), text.to_string());
+        let result = paragraph.by_humans();
         assert_eq!(result.len(), 1, "got wrong numnber of texts");
         assert_eq!(result.get(&lang).unwrap(), text);
     }
 
     #[test]
-    fn add_translation_does_not_count_as_original_text() {
+    fn add_translation_does_not_count_as_human_text() {
         let text = "test";
         let lang = Language::from_639_1("en").unwrap();
-        let mut paragraph = Paragraph::new(text.to_string(), lang.clone());
+        let mut paragraph = Paragraph::new(lang.clone(), text.to_string());
         paragraph.add_translation("テスト".to_string(), Language::from_639_1("ja").unwrap());
-        let result = paragraph.get_original();
+        let result = paragraph.by_humans();
         assert_eq!(result.len(), 1, "got wrong numnber of texts");
         assert_eq!(result.get(&lang).unwrap(), text);
     }
 
     #[test]
-    fn impove_translation_does_get_added_as_original() {
+    fn impove_translation_does_get_added_as_human() {
         let text = ["test", "テスト"];
         let languages = [
             Language::from_639_1("en").unwrap(),
             Language::from_639_1("ja").unwrap(),
         ];
-        let mut paragraph = Paragraph::new(text[0].clone().to_string(), languages[0].clone());
+        let mut paragraph = Paragraph::new(languages[0].clone(), text[0].clone().to_string());
         paragraph.improve_translation(text[1].clone().to_string(), languages[1].clone());
-        let result = paragraph.get_original();
+        let result = paragraph.by_humans();
         assert_eq!(result.len(), 2, "got wrong numnber of texts");
         for i in 0..text.len() {
             assert_eq!(result.get(&languages[i]).unwrap(), text[i]);
         }
     }
+
+    #[test]
+    fn can_get_original_text() {
+        let text = Uuid::nil().to_string();
+        let lang = Language::from_639_1("en").unwrap();
+        let mut paragraph = Paragraph::new(lang.clone(), text.clone());
+        paragraph.add_translation(
+            Uuid::new_v4().to_string(),
+            Language::from_639_1("ja").unwrap(),
+        );
+        paragraph.improve_translation(
+            Uuid::new_v4().to_string(),
+            Language::from_639_1("de").unwrap(),
+        );
+        let (rlang, rtext) = paragraph.get_initial();
+        assert_eq!(rlang, &lang);
+        assert_eq!(rtext, &text);
+    }
 }
 
-struct UniversalString {}
+struct UniversalString {
+    data: Paragraph,
+}
 
 impl UniversalString {
-    fn new() -> Self {
-        Self {}
+    fn new(lang: Language, text: String) -> Self {
+        Self {
+            data: Paragraph::new(lang, text),
+        }
+    }
+
+    fn get(&self, lang: &Language) -> Option<&String> {
+        self.data.get(lang)
     }
 }
 
@@ -533,8 +595,49 @@ impl UniversalString {
 mod universal_strings {
     use super::*;
 
+    const INITIAL_DATA: [&str; 5] = ["one", "two", "three", "four", "five"];
+
+    struct TestData {
+        data: Vec<String>,
+    }
+
+    impl TestData {
+        fn new(paragraphs: Vec<&str>) -> Self {
+            let mut holder = Vec::new();
+            for item in paragraphs.iter() {
+                holder.push(item.to_string());
+            }
+            Self { data: holder }
+        }
+
+        fn get_text(&self) -> String {
+            let mut output = "".to_string();
+            for paragraph in self.data.iter() {
+                output += paragraph;
+                output += "\u{2029}";
+            }
+            output
+        }
+    }
+
     #[test]
     fn are_initial_strings_empty() {
-        UniversalString::new();
+        let text = ["test", "テスト"];
+        let languages = [
+            Language::from_639_1("en").unwrap(),
+            Language::from_639_1("ja").unwrap(),
+        ];
+        for i in 0..text.len() {
+            let ustr = UniversalString::new(languages[i].clone(), text[i].to_string());
+            assert_eq!(ustr.get(&languages[i]).unwrap(), text[i]);
+        }
+    }
+
+    #[test]
+    fn accepts_strings_with_multiple_paragraphs() {
+        let lang = Language::from_639_1("en").unwrap();
+        let input = TestData::new(INITIAL_DATA.to_vec());
+        let ustr = UniversalString::new(lang.clone(), input.get_text());
+        assert_eq!(ustr.get(&lang).unwrap(), &input.get_text());
     }
 }