diff --git a/.nuget/NuGet.Config b/.nuget/NuGet.Config
index 67f8ea0..58b08e6 100644
--- a/.nuget/NuGet.Config
+++ b/.nuget/NuGet.Config
@@ -3,4 +3,7 @@
   <solution>
     <add key="disableSourceControlIntegration" value="true" />
   </solution>
+  <activePackageSource>
+    <add key="nuget.org" value="https://www.nuget.org/api/v2/" />
+  </activePackageSource>
 </configuration>
\ No newline at end of file
diff --git a/ContentConsole.Test.Unit/BannedWordCounterServiceTests.cs b/ContentConsole.Test.Unit/BannedWordCounterServiceTests.cs
new file mode 100644
index 0000000..b76786b
--- /dev/null
+++ b/ContentConsole.Test.Unit/BannedWordCounterServiceTests.cs
@@ -0,0 +1,112 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using ContentConsole.Helpers;
+using ContentConsole.Services;
+using Moq;
+using NUnit.Framework;
+
+namespace ContentConsole.Test.Unit
+{
+    [TestFixture]
+    public class BannedWordCounterServiceTests
+    {
+        [Test]
+        public void CountBannedWords_OnLowercaseContentwithUppercaseBannedWord_CountsBannedWords()
+        {
+            const string upperBannedWord = "BANNED";
+            const string lowercaseContent = "banned content";
+            var lowercaseRetrievedBannedWordsService = new Mock<IBannedWordRetrievalService>();
+            lowercaseRetrievedBannedWordsService
+                .Setup(service => service.GetBannedWords())
+                .Returns(new List<string> { upperBannedWord });
+
+            IBannedWordCounterService bannedWordCounterService
+                = new BannedWordCounterService(lowercaseRetrievedBannedWordsService.Object, new PhraseMatcher());
+
+            Assert.AreEqual(bannedWordCounterService.CountBannedWords(lowercaseContent), 1);
+        }
+
+        [Test]
+        public void CountBannedWords_OnUppercaseContentwithLowercaseBannedWord_CountsBannedWords()
+        {
+            const string lowercaseBannedWord = "banned";
+            const string uppercaseContent = "BANNED CONTENT";
+            var lowercaseRetrievedBannedWordsService = new Mock<IBannedWordRetrievalService>();
+            lowercaseRetrievedBannedWordsService
+                .Setup(service => service.GetBannedWords())
+                .Returns(new List<string> { lowercaseBannedWord });
+
+            IBannedWordCounterService bannedWordCounterService
+                = new BannedWordCounterService(lowercaseRetrievedBannedWordsService.Object, new PhraseMatcher());
+
+            Assert.AreEqual(bannedWordCounterService.CountBannedWords(uppercaseContent), 1);
+        }
+
+        [Test]
+        public void CountBannedWords_BannedWordAtSentenceEndNoPunctuation_CountsBannedWords()
+        {
+            const string lowercaseBannedWord = "banned";
+            const string uppercaseContent = "This word is banned";
+            var lowercaseRetrievedBannedWordsService = new Mock<IBannedWordRetrievalService>();
+            lowercaseRetrievedBannedWordsService
+                .Setup(service => service.GetBannedWords())
+                .Returns(new List<string> { lowercaseBannedWord });
+
+            IBannedWordCounterService bannedWordCounterService
+                = new BannedWordCounterService(lowercaseRetrievedBannedWordsService.Object, new PhraseMatcher());
+
+            Assert.AreEqual(bannedWordCounterService.CountBannedWords(uppercaseContent), 1);
+        }
+
+        [Test]
+        public void CountBannedWords_BannedWordAtSentenceEndWithPunctuation_CountsBannedWords()
+        {
+            const string lowercaseBannedWord = "banned";
+            const string uppercaseContent = "This word is banned.";
+            var lowercaseRetrievedBannedWordsService = new Mock<IBannedWordRetrievalService>();
+            lowercaseRetrievedBannedWordsService
+                .Setup(service => service.GetBannedWords())
+                .Returns(new List<string> { lowercaseBannedWord });
+
+            IBannedWordCounterService bannedWordCounterService
+                = new BannedWordCounterService(lowercaseRetrievedBannedWordsService.Object, new PhraseMatcher());
+
+            Assert.AreEqual(bannedWordCounterService.CountBannedWords(uppercaseContent), 1);
+        }
+
+        [Test]
+        public void CountBannedWords_BannedWordAtSentenceStartAndEnd_CountsBannedWords()
+        {
+            const string lowercaseBannedWord = "banned";
+            const string uppercaseContent = "banned words are banned";
+            var lowercaseRetrievedBannedWordsService = new Mock<IBannedWordRetrievalService>();
+            lowercaseRetrievedBannedWordsService
+                .Setup(service => service.GetBannedWords())
+                .Returns(new List<string> { lowercaseBannedWord });
+
+            IBannedWordCounterService bannedWordCounterService
+                = new BannedWordCounterService(lowercaseRetrievedBannedWordsService.Object, new PhraseMatcher());
+
+            Assert.AreEqual(bannedWordCounterService.CountBannedWords(uppercaseContent), 2);
+        }
+
+        [Test]
+        public void CountBannedWords_BannedWordAtSentenceStart_CountsBannedWords()
+        {
+            const string lowercaseBannedWord = "banned";
+            const string uppercaseContent = "banned words";
+            var lowercaseRetrievedBannedWordsService = new Mock<IBannedWordRetrievalService>();
+            lowercaseRetrievedBannedWordsService
+                .Setup(service => service.GetBannedWords())
+                .Returns(new List<string> { lowercaseBannedWord });
+
+            IBannedWordCounterService bannedWordCounterService
+                = new BannedWordCounterService(lowercaseRetrievedBannedWordsService.Object, new PhraseMatcher());
+
+            Assert.AreEqual(bannedWordCounterService.CountBannedWords(uppercaseContent), 1);
+        }
+    }
+}
diff --git a/ContentConsole.Test.Unit/BannedWordFile.txt b/ContentConsole.Test.Unit/BannedWordFile.txt
new file mode 100644
index 0000000..541f0ce
--- /dev/null
+++ b/ContentConsole.Test.Unit/BannedWordFile.txt
@@ -0,0 +1,8 @@
+
+	b1
+b2
+
+b3
+B3
+
+	
diff --git a/ContentConsole.Test.Unit/BannedWordFileRepositoryTests.cs b/ContentConsole.Test.Unit/BannedWordFileRepositoryTests.cs
new file mode 100644
index 0000000..9df3546
--- /dev/null
+++ b/ContentConsole.Test.Unit/BannedWordFileRepositoryTests.cs
@@ -0,0 +1,42 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using ContentConsole.DataRepository;
+using NUnit.Framework;
+
+namespace ContentConsole.Test.Unit
+{
+    [TestFixture]
+    public class BannedWordFileRepositoryTests
+    {
+        [Test]
+        public void Initialize_GivenFileThatDoesNotExist_ThrowsFileNotFoundException()
+        {
+            Assert.Throws(typeof(ArgumentException),
+                delegate { throw new ArgumentException(); });
+            Assert.Throws<FileNotFoundException>(() => new BannedWordFileRepository("NotABannedWordFile.txt"));
+        }
+
+        [Test]
+        public void Initialize_GivenFileThatExists_DoesNotThrowException()
+        {
+            IBannedWordRepository repository = new BannedWordFileRepository("../../BannedWordFile.txt");
+        }
+
+        [Test]
+        public void Initialize_GivenFileThatExists_ReadsFileWords()
+        {
+            IBannedWordRepository repository = new BannedWordFileRepository("../../BannedWordFile.txt");
+
+            Assert.IsTrue(repository.Contains("b1"));
+            Assert.IsTrue(repository.Contains("b2"));
+            Assert.IsTrue(repository.Contains("b3"));
+            Assert.IsTrue(repository.Contains("B3"));
+
+            Assert.AreEqual(repository.GetAll().Count(), 3);
+        }
+    }
+}
diff --git a/ContentConsole.Test.Unit/BannedWordReplacementServiceTests.cs b/ContentConsole.Test.Unit/BannedWordReplacementServiceTests.cs
new file mode 100644
index 0000000..3044cf3
--- /dev/null
+++ b/ContentConsole.Test.Unit/BannedWordReplacementServiceTests.cs
@@ -0,0 +1,111 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using ContentConsole.Helpers;
+using ContentConsole.Services;
+using Moq;
+using NUnit.Framework;
+
+namespace ContentConsole.Test.Unit
+{
+    [TestFixture]
+    public class BannedWordReplacementServiceTests
+    {
+
+        private IBannedWordRetrievalService CreatedMockBannedWordRetrievalService()
+        {
+            var mockRetrievalService = new Mock<IBannedWordRetrievalService>();
+            mockRetrievalService.Setup(service => service.GetBannedWords())
+                .Returns(new List<string> { "a", "an", "banned", "WORD", "bad" });
+            return mockRetrievalService.Object;
+        }
+
+        [Test]
+        public void ReplaceBannedWords_OnGivenNullContent_ReturnsNull()
+        {
+            IBannedWordReplacementService replacementService =
+                new BannedWordReplacementService(CreatedMockBannedWordRetrievalService(), new PhraseMatcher());
+            Assert.IsNull(replacementService.ReplaceBannedWords(null));
+        }
+
+        [Test]
+        public void ReplaceBannedWords_OnGivenEmptyContent_ReturnsEmptyString()
+        {
+            IBannedWordReplacementService replacementService =
+                 new BannedWordReplacementService(CreatedMockBannedWordRetrievalService(), new PhraseMatcher());
+            Assert.AreEqual("", replacementService.ReplaceBannedWords(""));
+        }
+
+        [Test]
+        public void ReplaceBannedWords_OnGivenEmptyPaddedContent_ReturnsEmptyOriginalPaddedInput()
+        {
+            IBannedWordReplacementService replacementService =
+               new BannedWordReplacementService(CreatedMockBannedWordRetrievalService(), new PhraseMatcher());
+            const string testContent = "\t\n  ";
+            Assert.AreEqual(testContent, replacementService.ReplaceBannedWords(testContent), testContent);
+        }
+
+        [Test]
+        public void ReplaceBannedWords_OnGivenBannedWordContentLower_ReplacesBannedWordsWithOriginalCapitalization()
+        {
+            IBannedWordReplacementService replacementService =
+               new BannedWordReplacementService(CreatedMockBannedWordRetrievalService(), new PhraseMatcher());
+            const string testContent = "lower case banned word ";
+            const string expectedReplacement = "lower case b####d w##d ";
+            Assert.AreEqual(expectedReplacement, replacementService.ReplaceBannedWords(testContent));
+        }
+
+        [Test]
+        public void ReplaceBannedWords_OnGivenBannedWordContentUpper_ReplacesBannedWordsWithOriginalCapitalization()
+        {
+            IBannedWordReplacementService replacementService =
+               new BannedWordReplacementService(CreatedMockBannedWordRetrievalService(), new PhraseMatcher());
+            const string testContent = "UPPER CASE BANNED WORD ";
+            const string expectedReplacement = "UPPER CASE B####D W##D ";
+            Assert.AreEqual(expectedReplacement, replacementService.ReplaceBannedWords(testContent));
+        }
+
+        [Test]
+        public void ReplaceBannedWords_OnGivenSingleLetterBannedWord_HidesEntireBannedWord()
+        {
+            IBannedWordReplacementService replacementService =
+               new BannedWordReplacementService(CreatedMockBannedWordRetrievalService(), new PhraseMatcher());
+            const string testContent = "a lower case banned word ";
+            const string expectedReplacement = "# lower case b####d w##d ";
+            Assert.AreEqual(expectedReplacement, replacementService.ReplaceBannedWords(testContent));
+        }
+
+        [Test]
+        public void ReplaceBannedWords_OnGivenTwoLetterBannedWord_HidesEntireBannedWord()
+        {
+            IBannedWordReplacementService replacementService =
+               new BannedWordReplacementService(CreatedMockBannedWordRetrievalService(), new PhraseMatcher());
+            const string testContent = "AN UPPER CASE BANNED WORD ";
+            const string expectedReplacement = "## UPPER CASE B####D W##D ";
+            Assert.AreEqual(expectedReplacement, replacementService.ReplaceBannedWords(testContent));
+        }
+
+        [Test]
+        public void ReplaceBannedWords_OnGivenThreeLetterBannedWord_HidesMiddleLetterOfBannedWord()
+        {
+            IBannedWordReplacementService replacementService =
+               new BannedWordReplacementService(CreatedMockBannedWordRetrievalService(), new PhraseMatcher());
+            const string testContent = "The weather in Manchester in winter is bad.It rains all the time -it must be horrible for people visiting.";
+            const string expectedReplacement = "The weather in Manchester in winter is b#d.It rains all the time -it must be horrible for people visiting.";
+            Assert.AreEqual(expectedReplacement, replacementService.ReplaceBannedWords(testContent));
+        }
+
+        // We might want to check for this, but for now don't check for pluralization and skip the word.
+        [Test]
+        public void ReplaceBannedWords_OnGivenBadWordPluralized_DoesNotReplacePluralizedBannedWord()
+        {
+            IBannedWordReplacementService replacementService =
+               new BannedWordReplacementService(CreatedMockBannedWordRetrievalService(), new PhraseMatcher());
+            const string testContent = "UPPER CASE BANNED WORDS ";
+            const string expectedReplacement = "UPPER CASE B####D WORDS ";
+            Assert.AreEqual(expectedReplacement, replacementService.ReplaceBannedWords(testContent));
+        }
+    }
+}
diff --git a/ContentConsole.Test.Unit/BannedWordRepositoryTests.cs b/ContentConsole.Test.Unit/BannedWordRepositoryTests.cs
new file mode 100644
index 0000000..51b3683
--- /dev/null
+++ b/ContentConsole.Test.Unit/BannedWordRepositoryTests.cs
@@ -0,0 +1,132 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using ContentConsole.DataRepository;
+using NUnit.Framework;
+namespace ContentConsole.Test.Unit
+{
+    [TestFixture]
+    public class BannedWordRepositoryTests
+    {
+        [Test]
+        public void GetAll_OnInitialization_ReturnsEmptyNonNullEnumerable()
+        {
+            IBannedWordRepository bannedWordRepository = new BannedWordRepository();
+            IEnumerable<string> bannedWords = bannedWordRepository.GetAll();
+
+            Assert.IsNotNull(bannedWords);
+            Assert.AreEqual(bannedWords.Count(), 0);
+        }
+
+        [Test]
+        public void Add_OnInitialization_AddsNewWordToRepository()
+        {
+            string bannedWord = "banned";
+            IBannedWordRepository bannedWordRepository = new BannedWordRepository();
+
+            bannedWordRepository.Add(bannedWord);
+
+            IEnumerable<string> bannedWords = bannedWordRepository.GetAll();
+            Assert.IsNotNull(bannedWords);
+            Assert.AreEqual(bannedWords.Count(), 1);
+            Assert.AreEqual(bannedWords.First(), bannedWord);
+        }
+
+        [Test]
+        public void Add_OnAddingNull_DoesNotAddNewWord()
+        {
+            string bannedWord = "banned";
+            IBannedWordRepository bannedWordRepository = new BannedWordRepository();
+
+            // Add null
+            bannedWordRepository.Add(null);
+            bannedWordRepository.Add(bannedWord);
+
+            IEnumerable<string> bannedWords = bannedWordRepository.GetAll();
+            Assert.IsNotNull(bannedWords);
+            Assert.AreEqual(bannedWords.Count(), 1);
+            Assert.AreEqual(bannedWords.First(), bannedWord);
+        }
+
+        [Test]
+        public void Add_OnAddingEmpty_DoesNotAddNewWord()
+        {
+            string bannedWord = "banned";
+            IBannedWordRepository bannedWordRepository = new BannedWordRepository();
+
+            // Add null
+            bannedWordRepository.Add("");
+            bannedWordRepository.Add(bannedWord);
+
+            IEnumerable<string> bannedWords = bannedWordRepository.GetAll();
+            Assert.IsNotNull(bannedWords);
+            Assert.AreEqual(bannedWords.Count(), 1);
+            Assert.AreEqual(bannedWords.First(), bannedWord);
+        }
+
+        [Test]
+        public void Add_OnAddingDuplicateWordWithPaddedWhiteSpace_DoesNotAddDuplicate()
+        {
+            string bannedWord = "banned";
+            IBannedWordRepository bannedWordRepository = new BannedWordRepository();
+
+            // Add duplicate word with padding 
+            bannedWordRepository.Add(bannedWord);
+            bannedWordRepository.Add(" \t" + bannedWord + "\n");
+
+            IEnumerable<string> bannedWords = bannedWordRepository.GetAll();
+            Assert.IsNotNull(bannedWords);
+            Assert.AreEqual(bannedWords.Count(), 1);
+            Assert.AreEqual(bannedWords.First(), bannedWord);
+        }
+
+        [Test]
+        public void Contains_OnInitialization_ReturnsFalse()
+        {
+            string bannedWord = "banned";
+            IBannedWordRepository bannedWordRepository = new BannedWordRepository();
+            Assert.IsFalse(bannedWordRepository.Contains(bannedWord));
+        }
+
+        [Test]
+        public void Contains_OnGivenNull_ReturnsFalse()
+        {
+            IBannedWordRepository bannedWordRepository = new BannedWordRepository();
+            Assert.IsFalse(bannedWordRepository.Contains(null));
+        }
+
+        [Test]
+        public void Contains_OnGivenEmptyWord_ReturnsFalse()
+        {
+            IBannedWordRepository bannedWordRepository = new BannedWordRepository();
+            Assert.IsFalse(bannedWordRepository.Contains(""));
+        }
+
+        [Test]
+        public void Contains_AddingLowercaseWordAndCheckingUppercaseContains_ReturnsTrueOnMatch()
+        {
+            string bannedWord = "banned";
+            IBannedWordRepository bannedWordRepository = new BannedWordRepository();
+
+            bannedWordRepository.Add(bannedWord);
+            Assert.IsTrue(bannedWordRepository.Contains(bannedWord));
+        }
+
+        [Test]
+        public void Contains_ContainsIgnoresWhiteSpace_DoesNotAddDuplicate()
+        {
+            string bannedWord = "banned";
+            IBannedWordRepository bannedWordRepository = new BannedWordRepository();
+
+            // Add original word with padding 
+            bannedWordRepository.Add(" \t" + bannedWord + "\n");
+
+            // check original word is contained, as well as padded variations
+            Assert.IsTrue(bannedWordRepository.Contains(bannedWord));
+            Assert.IsTrue(bannedWordRepository.Contains(" " + bannedWord));
+            Assert.IsTrue(bannedWordRepository.Contains("\t" + bannedWord + "\n"));
+        }
+    }
+}
diff --git a/ContentConsole.Test.Unit/BannedWordRetrievalServiceTests.cs b/ContentConsole.Test.Unit/BannedWordRetrievalServiceTests.cs
new file mode 100644
index 0000000..0f18185
--- /dev/null
+++ b/ContentConsole.Test.Unit/BannedWordRetrievalServiceTests.cs
@@ -0,0 +1,43 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using ContentConsole.DataRepository;
+using ContentConsole.Services;
+using Moq;
+using NUnit.Framework;
+
+namespace ContentConsole.Test.Unit
+{
+    [TestFixture]
+    public class BannedWordRetrievalServiceTests
+    {
+        [Test]
+        public void GetBannedWords_InitializedWithEmptyRepo_ReturnsEmptyList()
+        {
+            var mockRepo = new Mock<IBannedWordRepository>();
+            mockRepo.Setup(repo => repo.GetAll())
+                .Returns(new List<string>());
+
+            IBannedWordRetrievalService bannedWordRetrievalService = new BannedWordRetrievalService(mockRepo.Object);
+
+            Assert.AreSame(bannedWordRetrievalService.GetBannedWords(), mockRepo.Object.GetAll());
+        }
+
+        [Test]
+        public void GetBannedWords_InitializedWithRepo_ReturnsMatchingList()
+        {
+            var mockRepo = new Mock<IBannedWordRepository>();
+            mockRepo.Setup(repo => repo.GetAll())
+                .Returns(new List<string>() { "banned", "word" });
+
+            IBannedWordRetrievalService bannedWordRetrievalService = new BannedWordRetrievalService(mockRepo.Object);
+            IEnumerable<string> serviceBannedWords = bannedWordRetrievalService.GetBannedWords();
+
+            Assert.AreEqual(serviceBannedWords.Count(), 2);
+            Assert.IsTrue(serviceBannedWords.Contains("banned"));
+            Assert.IsTrue(serviceBannedWords.Contains("word"));
+        }
+    }
+}
diff --git a/ContentConsole.Test.Unit/ContentConsole.Test.Unit.csproj b/ContentConsole.Test.Unit/ContentConsole.Test.Unit.csproj
index f1b05c0..6db05f3 100644
--- a/ContentConsole.Test.Unit/ContentConsole.Test.Unit.csproj
+++ b/ContentConsole.Test.Unit/ContentConsole.Test.Unit.csproj
@@ -35,9 +35,25 @@
     <Reference Include="Moq">
       <HintPath>..\packages\Moq.4.2.1409.1722\lib\net40\Moq.dll</HintPath>
     </Reference>
+    <Reference Include="nunit.core, Version=2.6.4.14350, Culture=neutral, PublicKeyToken=96d09a1eb7f44a77, processorArchitecture=MSIL">
+      <HintPath>..\packages\NUnitTestAdapter.2.0.0\lib\nunit.core.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="nunit.core.interfaces, Version=2.6.4.14350, Culture=neutral, PublicKeyToken=96d09a1eb7f44a77, processorArchitecture=MSIL">
+      <HintPath>..\packages\NUnitTestAdapter.2.0.0\lib\nunit.core.interfaces.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
     <Reference Include="nunit.framework">
       <HintPath>..\packages\NUnit.2.6.3\lib\nunit.framework.dll</HintPath>
     </Reference>
+    <Reference Include="nunit.util, Version=2.6.4.14350, Culture=neutral, PublicKeyToken=96d09a1eb7f44a77, processorArchitecture=MSIL">
+      <HintPath>..\packages\NUnitTestAdapter.2.0.0\lib\nunit.util.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="NUnit.VisualStudio.TestAdapter, Version=2.0.0.0, Culture=neutral, PublicKeyToken=4cb40d35494691ac, processorArchitecture=MSIL">
+      <HintPath>..\packages\NUnitTestAdapter.2.0.0\lib\NUnit.VisualStudio.TestAdapter.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core" />
     <Reference Include="System.Xml.Linq" />
@@ -47,11 +63,29 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="BannedWordCounterServiceTests.cs" />
+    <Compile Include="BannedWordFileRepositoryTests.cs" />
+    <Compile Include="BannedWordReplacementServiceTests.cs" />
+    <Compile Include="BannedWordRepositoryTests.cs" />
+    <Compile Include="BannedWordRetrievalServiceTests.cs" />
+    <Compile Include="PhraseMatcherTests.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>
   <ItemGroup>
     <None Include="packages.config" />
   </ItemGroup>
+  <ItemGroup>
+    <Content Include="BannedWordFile.txt" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\ContentConsole\ContentConsole.csproj">
+      <Project>{70da2b36-ebf3-4438-9f95-ecc828a64527}</Project>
+      <Name>ContentConsole</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <ItemGroup>
+    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
+  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <Import Project="$(SolutionDir)\.nuget\NuGet.targets" Condition="Exists('$(SolutionDir)\.nuget\NuGet.targets')" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
diff --git a/ContentConsole.Test.Unit/PhraseMatcherTests.cs b/ContentConsole.Test.Unit/PhraseMatcherTests.cs
new file mode 100644
index 0000000..9dc59b6
--- /dev/null
+++ b/ContentConsole.Test.Unit/PhraseMatcherTests.cs
@@ -0,0 +1,85 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using ContentConsole.Helpers;
+using NUnit.Framework;
+
+namespace ContentConsole.Test.Unit
+{
+    [TestFixture]
+    public class PhraseMatcherTests
+    {
+        [Test]
+        public void Match_GivenMatchAtStringStart_ReturnsCorrectMatch()
+        {
+            IPhraseMatcher matcher = new PhraseMatcher();
+            PhraseMatchResult expectedResult = new PhraseMatchResult()
+            {
+                Index = 0,
+                MatchedPhrase = "An"
+            };
+
+            PhraseMatchResult actualResult = matcher.Match(0, "An AWESOME test", new List<string>() { "An", "test" });
+
+            Assert.IsNotNull(actualResult);
+            Assert.AreEqual(expectedResult.MatchedPhrase, actualResult.MatchedPhrase);
+            Assert.AreEqual(expectedResult.Index, actualResult.Index);
+        }
+
+        [Test]
+        public void Match_GivenMatchAtNonZero_ReturnsCorrectMatch()
+        {
+            IPhraseMatcher matcher = new PhraseMatcher();
+            PhraseMatchResult expectedResult = new PhraseMatchResult()
+            {
+                Index = 3,
+                MatchedPhrase = "AWESOME"
+            };
+
+            PhraseMatchResult actualResult = matcher.Match(0, "An AWESOME test", new List<string>() { "A", "AWESOME" });
+
+            Assert.IsNotNull(actualResult);
+            Assert.AreEqual(expectedResult.MatchedPhrase, actualResult.MatchedPhrase);
+            Assert.AreEqual(expectedResult.Index, actualResult.Index);
+        }
+
+
+        [Test]
+        public void Match_GivenMatchAtEnd_ReturnsCorrectMatch()
+        {
+            IPhraseMatcher matcher = new PhraseMatcher();
+            PhraseMatchResult expectedResult = new PhraseMatchResult()
+            {
+                Index = 11,
+                MatchedPhrase = "test"
+            };
+
+            PhraseMatchResult actualResult = matcher.Match(0, "An AWESOME test", new List<string>() { "A", "test" });
+
+            Assert.IsNotNull(actualResult);
+            Assert.AreEqual(expectedResult.MatchedPhrase, actualResult.MatchedPhrase);
+            Assert.AreEqual(expectedResult.Index, actualResult.Index);
+        }
+
+        [Test]
+        public void Match_GivenNonMatch_ReturnsNull()
+        {
+            IPhraseMatcher matcher = new PhraseMatcher();
+
+            PhraseMatchResult result = matcher.Match(0, "An AWESOME test", new List<string>() { "X" });
+
+            Assert.IsNull(result);
+        }
+
+        [Test]
+        public void Match_GivenPartialInnerMatch_ReturnsNull()
+        {
+            IPhraseMatcher matcher = new PhraseMatcher();
+
+            PhraseMatchResult result = matcher.Match(0, "An AWESOME test", new List<string>() { "SOME" });
+            Assert.IsNull(result);
+        }
+    }
+}
diff --git a/ContentConsole.Test.Unit/packages.config b/ContentConsole.Test.Unit/packages.config
index 89b4f35..2e765f1 100644
--- a/ContentConsole.Test.Unit/packages.config
+++ b/ContentConsole.Test.Unit/packages.config
@@ -2,4 +2,5 @@
 <packages>
   <package id="Moq" version="4.2.1409.1722" targetFramework="net45" />
   <package id="NUnit" version="2.6.3" targetFramework="net45" />
+  <package id="NUnitTestAdapter" version="2.0.0" targetFramework="net45" />
 </packages>
\ No newline at end of file
diff --git a/ContentConsole/BannedWordFile.txt b/ContentConsole/BannedWordFile.txt
new file mode 100644
index 0000000..0a64d1e
--- /dev/null
+++ b/ContentConsole/BannedWordFile.txt
@@ -0,0 +1,6 @@
+swine
+bad
+nasty
+horrible
+
+	
diff --git a/ContentConsole/ContentConsole.csproj b/ContentConsole/ContentConsole.csproj
index 113bcb7..dd0cd21 100644
--- a/ContentConsole/ContentConsole.csproj
+++ b/ContentConsole/ContentConsole.csproj
@@ -42,8 +42,23 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="DataRepository\BannedWordFileRepository.cs" />
+    <Compile Include="DataRepository\BannedWordRepository.cs" />
+    <Compile Include="DataRepository\IBannedWordRepository.cs" />
+    <Compile Include="Helpers\IPhraseMatcher.cs" />
+    <Compile Include="Helpers\PhraseMatcher.cs" />
+    <Compile Include="Helpers\PhraseMatcherResult.cs" />
     <Compile Include="Program.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="Services\BannedWordCounterService.cs" />
+    <Compile Include="Services\BannedWordReplacementService.cs" />
+    <Compile Include="Services\BannedWordRetrievalService.cs" />
+    <Compile Include="Services\IBannedWordCounterService.cs" />
+    <Compile Include="Services\IBannedWordReplacementService.cs" />
+    <Compile Include="Services\IBannedWordRetrievalService.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <Content Include="BannedWordFile.txt" />
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
diff --git a/ContentConsole/DataRepository/BannedWordFileRepository.cs b/ContentConsole/DataRepository/BannedWordFileRepository.cs
new file mode 100644
index 0000000..a470c56
--- /dev/null
+++ b/ContentConsole/DataRepository/BannedWordFileRepository.cs
@@ -0,0 +1,46 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace ContentConsole.DataRepository
+{
+    /// <summary>
+    /// A word repository which loads a file of words separated into different lines
+    /// </summary>
+    public class BannedWordFileRepository : BannedWordRepository
+    {
+        private readonly string _filename;
+
+        /// <summary>
+        /// Initialize banned word repository with a file.
+        /// </summary>
+        /// <param name="filename">location of the banned word file, separated by lines</param>
+        public BannedWordFileRepository(string filename) : base()
+        {
+            _filename = filename;
+            Read();
+        }
+
+        /// <summary>
+        /// Read the file into the repository. Throws FileNotFound exception if file is not found
+        /// </summary>
+        private void Read()
+        {
+            string[] lines = System.IO.File.ReadAllLines(_filename);
+            foreach (string bannedWord in lines)
+            {
+                Add(bannedWord);
+            }
+        }
+
+        /// <summary>
+        /// Save the repository changes to file
+        /// </summary>
+        public void Save()
+        {
+            throw new NotImplementedException();
+        }
+    }
+}
diff --git a/ContentConsole/DataRepository/BannedWordRepository.cs b/ContentConsole/DataRepository/BannedWordRepository.cs
new file mode 100644
index 0000000..34b571f
--- /dev/null
+++ b/ContentConsole/DataRepository/BannedWordRepository.cs
@@ -0,0 +1,107 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace ContentConsole.DataRepository
+{
+
+    /// <summary>
+    /// Banned word repository 
+    /// </summary>
+    public class BannedWordRepository : IBannedWordRepository
+    {
+        // Set of banned words in lowercase. 
+        private readonly ISet<string> _lowercaseBannedWordSet;
+
+        public BannedWordRepository()
+        {
+            _lowercaseBannedWordSet = new HashSet<string>();
+        }
+
+        /// <summary>
+        /// Get all of the banned words. 
+        /// </summary>
+        /// <returns>IEnumerable of words, not guaranteed to be in the same case as they were provided.
+        /// </returns>
+        public IEnumerable<string> GetAll()
+        {
+            return _lowercaseBannedWordSet;
+        }
+
+        /// <summary>
+        ///  Add a word if it doesn't exist in our set
+        /// </summary>
+        /// <param name="bannedWord">Word to add</param>
+        public void Add(string bannedWord)
+        {
+            // Do not add null words
+            if (bannedWord == null)
+            {
+                return;
+            }
+
+            string lowercaseTrimmedBannedWord = bannedWord.Trim().ToLower();
+
+            // Do not add empty words
+            if (lowercaseTrimmedBannedWord.Length == 0)
+            {
+                return;
+            }
+
+            if (!Contains(lowercaseTrimmedBannedWord))
+            {
+                _lowercaseBannedWordSet.Add(lowercaseTrimmedBannedWord);
+            }
+        }
+
+        /// <summary>
+        /// Whether the banned word exists in the repository. Case insensitive. 
+        /// </summary>
+        /// <param name="bannedWord">The word to check</param>
+        /// <returns>True if the repository contains the word, false otherwise</returns>
+        public bool Contains(string bannedWord)
+        {
+            // Return false on null
+            if (bannedWord == null)
+            {
+                return false;
+            }
+
+            string lowercaseTrimmedBannedWord = bannedWord.Trim().ToLower();
+
+            // Return false on empty word
+            if (lowercaseTrimmedBannedWord.Length == 0)
+            {
+                return false;
+            }
+
+            return _lowercaseBannedWordSet.Contains(lowercaseTrimmedBannedWord);
+        }
+
+        /// <summary>
+        /// Remove the banned word if it exists. Case insensitive. 
+        /// </summary>
+        /// <param name="bannedWord">The word to remove</param>
+        public void Remove(string bannedWord)
+        {
+            if (bannedWord == null)
+            {
+                return;
+            }
+
+            string lowercaseTrimmedBannedWord = bannedWord.Trim().ToLower();
+
+            if (lowercaseTrimmedBannedWord.Length == 0)
+            {
+                return;
+            }
+
+            if (Contains(lowercaseTrimmedBannedWord))
+            {
+                _lowercaseBannedWordSet.Remove(lowercaseTrimmedBannedWord);
+            }
+        }
+    }
+}
diff --git a/ContentConsole/DataRepository/IBannedWordRepository.cs b/ContentConsole/DataRepository/IBannedWordRepository.cs
new file mode 100644
index 0000000..b20a20c
--- /dev/null
+++ b/ContentConsole/DataRepository/IBannedWordRepository.cs
@@ -0,0 +1,40 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace ContentConsole.DataRepository
+{
+    /// <summary>
+    /// A repository of banned words
+    /// </summary>
+    public interface IBannedWordRepository
+    {
+        /// <summary>
+        /// Get all of the banned words. 
+        /// </summary>
+        /// <returns>IEnumerable of words, not guaranteed to be in the same case as they were provided.
+        /// </returns>
+        IEnumerable<string> GetAll();
+
+        /// <summary>
+        ///  Add a word if it doesn't exist in our set
+        /// </summary>
+        /// <param name="bannedWord">Word to add</param>
+        void Add(string bannedWord);
+
+        /// <summary>
+        /// Whether the banned word exists in the repository. Case insensitive. 
+        /// </summary>
+        /// <param name="bannedWord">The word to check</param>
+        /// <returns>True if the repository contains the word, false otherwise</returns>
+        bool Contains(string bannedWord);
+
+        /// <summary>
+        /// Remove the banned word if it exists. Case insensitive. 
+        /// </summary>
+        /// <param name="bannedWord">The word to remove</param>// Remove word if it exists
+        void Remove(string bannedWord);
+    }
+}
diff --git a/ContentConsole/Helpers/IPhraseMatcher.cs b/ContentConsole/Helpers/IPhraseMatcher.cs
new file mode 100644
index 0000000..27e5a0d
--- /dev/null
+++ b/ContentConsole/Helpers/IPhraseMatcher.cs
@@ -0,0 +1,23 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace ContentConsole.Helpers
+{
+    /// <summary>
+    /// Matches a set of phrases, find the location of the first match.
+    /// </summary>
+    public interface IPhraseMatcher
+    {
+        /// <summary>
+        /// Matches the input to a list of phrases, returns the value of the matched phrase and it's location. 
+        /// </summary>
+        /// <param name="start">The location to start checking for matching phrases</param>
+        /// <param name="input">The input to check</param>
+        /// <param name="matchedPhrases">IEnumerable of phrases to match</param>
+        /// <returns>A PhraseMatchResult containing the matched phrase and it's location, or null if no matches are found.</returns>
+        PhraseMatchResult Match(int start, string input, IEnumerable<string> matchedPhrases);
+    }
+}
diff --git a/ContentConsole/Helpers/PhraseMatcher.cs b/ContentConsole/Helpers/PhraseMatcher.cs
new file mode 100644
index 0000000..bdb9b2f
--- /dev/null
+++ b/ContentConsole/Helpers/PhraseMatcher.cs
@@ -0,0 +1,132 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace ContentConsole.Helpers
+{
+
+    /// <summary>
+    /// Matches a set of phrases, find the location of the first match.
+    /// </summary>
+    public class PhraseMatcher : IPhraseMatcher
+    {
+        private readonly static List<char> Whitespace = new List<char>() { '\t', '\n', ' ' };
+        private readonly static List<char> Punctuation = new List<char>() { '.', '-', '?', '!', '&' };
+
+        /// <summary>
+        /// Check whether the input character is whitepsace or punctuation 
+        /// </summary>
+        /// <param name="c">The character to check</param>
+        /// <returns>True if whitespace or punctuation, false otherwise</returns>
+        private static bool IsWhiteSpaceOrPunctuation(char c)
+        {
+            return Whitespace.Contains(c) || Punctuation.Contains(c);
+        }
+
+        /// <summary>
+        /// Return the location of the matched phrase in the input, starting at the start location
+        /// </summary>
+        /// <param name="start">The location to start checking</param>
+        /// <param name="input">The input sentence</param>
+        /// <param name="matchedPhrase">The phrase to check</param>
+        /// <returns>Location of the instance of the matched phrase, -1 if not found</returns>
+        private int FindNextMatch(int start, string input, string matchedPhrase)
+        {
+            int nextPosition = input.ToLower().Substring(start).IndexOf(matchedPhrase.ToLower());
+
+            // No match found
+            if (nextPosition == -1)
+            {
+                return -1;
+            }
+            else
+            {
+                int absoluteMatchPosition = start + nextPosition;
+
+                // Match found, check it's bounds are either the start or end of the string, whitespace, or punctuation
+                bool isLeftBoundValid = absoluteMatchPosition == 0 ||
+                                        IsWhiteSpaceOrPunctuation(input[absoluteMatchPosition - 1]);
+
+                // Check that the right bound is either the end of the string, whitespace char, or punctuatoin
+                bool isRightBoundValid = absoluteMatchPosition + matchedPhrase.Length == input.Length;
+                if (!isRightBoundValid)
+                {
+                    isRightBoundValid = IsWhiteSpaceOrPunctuation(input[absoluteMatchPosition + matchedPhrase.Length]);
+                }
+
+                // Check bounds are valid
+                bool isValidMatch = isLeftBoundValid && isRightBoundValid;
+
+                // If the match is valid then return it.
+                if (isValidMatch)
+                {
+                    return absoluteMatchPosition;
+                }
+                else
+                {
+                    // Otherwise return the next match.
+                    return FindNextMatch(start + nextPosition + 1, input, matchedPhrase);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Creates a mapping of each phrase to the next instance in the input. 
+        /// </summary>
+        /// <param name="start">the location in the phrase to start checking for matches</param>
+        /// <param name="input">the input string to check</param>
+        /// <param name="matchedPhrases">An IEnumerable of phrases to check</param>
+        /// <returns>A mapping of each phrase to the next location in the input, or -1 if the phrase is not found</returns>
+        private IDictionary<string, int> FindNextMatches(int start, string input, IEnumerable<string> matchedPhrases)
+        {
+            IDictionary<string, int> nextMatches = new Dictionary<string, int>();
+            foreach (string matchedPhrase in matchedPhrases)
+            {
+                nextMatches[matchedPhrase] = FindNextMatch(start, input, matchedPhrase);
+            }
+            return nextMatches;
+        }
+
+        /// <summary>
+        /// Matches the input to a list of phrases, returns the value of the matched phrase and it's location. 
+        /// </summary>
+        /// <param name="start">The location to start checking for matching phrases</param>
+        /// <param name="input">The input to check</param>
+        /// <param name="matchedPhrases">IEnumerable of phrases to match</param>
+        /// <returns>A PhraseMatchResult containing the matched phrase and it's location, or null if no matches are found.</returns>
+        public PhraseMatchResult Match(int start, string input, IEnumerable<string> matchedPhrases)
+        {
+            IDictionary<string, int> nextMatches = FindNextMatches(start, input, matchedPhrases);
+
+            // Find the phrase with the lowest matching non -1 position. If none are found return null.
+            string lowestMatchingPhrase = null;
+            int lowestMatchingPosition = Int32.MaxValue;
+
+            foreach (string matchedPhrase in nextMatches.Keys)
+            {
+                int matchPosition = nextMatches[matchedPhrase];
+                if (matchPosition > -1 && matchPosition < lowestMatchingPosition)
+                {
+                    lowestMatchingPhrase = matchedPhrase;
+                    lowestMatchingPosition = matchPosition;
+                }
+            }
+
+            if (lowestMatchingPhrase == null)
+            {
+                return null;
+            }
+            else
+            {
+                return new PhraseMatchResult()
+                {
+                    Index = lowestMatchingPosition,
+                    MatchedPhrase = lowestMatchingPhrase
+                };
+            }
+        }
+    }
+}
+
diff --git a/ContentConsole/Helpers/PhraseMatcherResult.cs b/ContentConsole/Helpers/PhraseMatcherResult.cs
new file mode 100644
index 0000000..5ad0c88
--- /dev/null
+++ b/ContentConsole/Helpers/PhraseMatcherResult.cs
@@ -0,0 +1,17 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace ContentConsole.Helpers
+{
+    /// <summary>
+    /// Store the result of the PhraseMatcher, the matched phrase and it's location. 
+    /// </summary>
+    public class PhraseMatchResult
+    {
+        public int Index { get; set; }
+        public string MatchedPhrase { get; set; }
+    }
+}
diff --git a/ContentConsole/Program.cs b/ContentConsole/Program.cs
index af4df25..d521ed8 100644
--- a/ContentConsole/Program.cs
+++ b/ContentConsole/Program.cs
@@ -1,40 +1,47 @@
 using System;
+using ContentConsole.DataRepository;
+using ContentConsole.Helpers;
+using ContentConsole.Services;
 
 namespace ContentConsole
 {
     public static class Program
     {
+        // Settings
+        private const string BannedWordFileLocation = "../../BannedWordFile.txt";
+        private const bool HideBannedWords = true;
+
         public static void Main(string[] args)
         {
-            string bannedWord1 = "swine";
-            string bannedWord2 = "bad";
-            string bannedWord3 = "nasty";
-            string bannedWord4 = "horrible";
 
+            // Load words from file 
+            IBannedWordRepository bannedWordRepository = new BannedWordFileRepository(BannedWordFileLocation);
+
+            IBannedWordRetrievalService bannedWordRetrieval = new BannedWordRetrievalService(bannedWordRepository);
+            IBannedWordCounterService bannedWordCounterService = new BannedWordCounterService(bannedWordRetrieval, new PhraseMatcher());
+
+            IBannedWordReplacementService bannedWordReplacementService
+                = new BannedWordReplacementService(bannedWordRetrieval, new PhraseMatcher());
+
+            // Calculations 
             string content =
                 "The weather in Manchester in winter is bad. It rains all the time - it must be horrible for people visiting.";
+            int bannedWordCount = bannedWordCounterService.CountBannedWords(content);
 
-            int badWords = 0;
-            if (content.Contains(bannedWord1))
-            {
-                badWords = badWords + 1;
-            }
-            if (content.Contains(bannedWord2))
-            {
-                badWords = badWords + 1;
-            }
-            if (content.Contains(bannedWord3))
+            // Display output 
+            Console.WriteLine("Scanned the text:");
+
+            // Conditionally hide the banned words
+            if (HideBannedWords)
             {
-                badWords = badWords + 1;
+                Console.WriteLine(bannedWordReplacementService.ReplaceBannedWords(content));
             }
-            if (content.Contains(bannedWord4))
+            else
             {
-                badWords = badWords + 1;
+                Console.WriteLine(content);
             }
 
-            Console.WriteLine("Scanned the text:");
-            Console.WriteLine(content);
-            Console.WriteLine("Total Number of negative words: " + badWords);
+            Console.WriteLine("Total Number of negative words: " + bannedWordCount);
 
             Console.WriteLine("Press ANY key to exit.");
             Console.ReadKey();
diff --git a/ContentConsole/Services/BannedWordCounterService.cs b/ContentConsole/Services/BannedWordCounterService.cs
new file mode 100644
index 0000000..f93f63a
--- /dev/null
+++ b/ContentConsole/Services/BannedWordCounterService.cs
@@ -0,0 +1,51 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using ContentConsole.DataRepository;
+using ContentConsole.Helpers;
+
+namespace ContentConsole.Services
+{
+    /// <summary>
+    /// A service which counts the number of instances of banned words
+    /// </summary>
+    public class BannedWordCounterService : IBannedWordCounterService
+    {
+        private readonly IBannedWordRetrievalService _bannedWordRetrievalService;
+        private readonly IPhraseMatcher _matcher;
+        public BannedWordCounterService(IBannedWordRetrievalService bannedWordRetrievalService, IPhraseMatcher matcher)
+        {
+            _bannedWordRetrievalService = bannedWordRetrievalService;
+            _matcher = matcher;
+        }
+
+        /// <summary>
+        /// Counts the banned words in the content
+        /// </summary>
+        /// <param name="content">The content to process</param>
+        /// <returns>Number of banned words found</returns>
+        public int CountBannedWords(string content)
+        {
+            // Use the matcher to iterate through the words to find matches
+            string lowercaseContent = content.ToLower();
+
+            List<string> bannedWordList = _bannedWordRetrievalService.GetBannedWords()
+                .Select(bannedWord => bannedWord.ToLower())
+                .ToList();
+
+            PhraseMatchResult currentResult = null;
+            int currentIndex = 0;
+            int count = 0;
+            while ((currentResult = _matcher.Match(currentIndex, lowercaseContent, bannedWordList)) != null)
+            {
+                count++;
+                // Update index
+                currentIndex = currentResult.Index + currentResult.MatchedPhrase.Length;
+            }
+
+            return count;
+        }
+    }
+}
diff --git a/ContentConsole/Services/BannedWordReplacementService.cs b/ContentConsole/Services/BannedWordReplacementService.cs
new file mode 100644
index 0000000..1f8bead
--- /dev/null
+++ b/ContentConsole/Services/BannedWordReplacementService.cs
@@ -0,0 +1,87 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using ContentConsole.Helpers;
+
+namespace ContentConsole.Services
+{
+    /// <summary>
+    /// Replaces banned words with another character
+    /// </summary>
+    public class BannedWordReplacementService : IBannedWordReplacementService
+    {
+        private readonly IBannedWordRetrievalService _bannedWordRetrievalService;
+        private readonly IPhraseMatcher _matcher;
+        public BannedWordReplacementService(IBannedWordRetrievalService bannedWordRetrievalService, IPhraseMatcher matcher)
+        {
+            _bannedWordRetrievalService = bannedWordRetrievalService;
+            _matcher = matcher;
+        }
+
+        /// <summary>
+        /// Replaces banned words with the replacement character. 
+        /// If the words are less than three characters long then the entire word is replaced, 
+        /// otherwise only the first and last characters will be shown.
+        /// </summary>
+        /// <param name="content">The content to process</param>
+        /// <param name="replacementCharacter">The character to replace the banned word characters with</param>
+        /// <returns>A string with the banned words replaced.</returns>
+        public string ReplaceBannedWords(string content, char replacementCharacter = '#')
+        {
+            if (content == null)
+            {
+                return null;
+            }
+
+            if (content.Trim().Length == 0)
+            {
+                return content;
+            }
+
+            List<string> bannedWordList = _bannedWordRetrievalService.GetBannedWords()
+                .Select(bannedWord => bannedWord.ToLower())
+                .ToList();
+
+            string lowercaseContent = content.ToLower();
+            string resultContent = content;
+
+            PhraseMatchResult currentResult = null;
+            int currentIndex = 0;
+            while ((currentResult = _matcher.Match(currentIndex, lowercaseContent, bannedWordList)) != null)
+            {
+
+                int replacedWordLength = currentResult.MatchedPhrase.Length;
+
+                if (replacedWordLength <= 2)
+                {
+                    // Replace entire words less than or equal to two characters in length
+                    resultContent = resultContent.Remove(currentResult.Index, replacedWordLength);
+
+                    resultContent = resultContent.Insert(currentResult.Index, replacementCharacter + "");
+                    if (replacedWordLength == 2)
+                    {
+                        resultContent = resultContent.Insert(currentResult.Index, replacementCharacter + "");
+                    }
+
+                }
+                else
+                {
+                    // Replace the middle characters
+                    resultContent = resultContent.Remove(currentResult.Index + 1, replacedWordLength - 2);
+                    for (int i = 0; i < replacedWordLength - 2; i++)
+                    {
+                        resultContent = resultContent.Insert(currentResult.Index + 1, replacementCharacter + "");
+                    }
+                }
+
+                // Update index
+                currentIndex = currentResult.Index + currentResult.MatchedPhrase.Length;
+            }
+
+            return resultContent;
+        }
+    }
+}
+
diff --git a/ContentConsole/Services/BannedWordRetrievalService.cs b/ContentConsole/Services/BannedWordRetrievalService.cs
new file mode 100644
index 0000000..54ce45a
--- /dev/null
+++ b/ContentConsole/Services/BannedWordRetrievalService.cs
@@ -0,0 +1,31 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using ContentConsole.DataRepository;
+
+namespace ContentConsole.Services
+{
+    /// <summary>
+    /// Uses a repository to fetch banned words
+    /// </summary>
+    public class BannedWordRetrievalService : IBannedWordRetrievalService
+    {
+        private readonly IBannedWordRepository _bannedWordRepository;
+        public BannedWordRetrievalService(IBannedWordRepository bannedWordRepository)
+        {
+            _bannedWordRepository = bannedWordRepository;
+        }
+
+        /// <summary>
+        /// Get banned words
+        /// </summary>
+        /// <returns>An IEnumerable of banned words</returns>
+        public IEnumerable<string> GetBannedWords()
+        {
+            return _bannedWordRepository.GetAll();
+        }
+    }
+}
+
diff --git a/ContentConsole/Services/IBannedWordCounterService.cs b/ContentConsole/Services/IBannedWordCounterService.cs
new file mode 100644
index 0000000..d12566b
--- /dev/null
+++ b/ContentConsole/Services/IBannedWordCounterService.cs
@@ -0,0 +1,22 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace ContentConsole.Services
+{
+    /// <summary>
+    /// A service which counts the number of instances of banned words
+    /// </summary>
+    public interface IBannedWordCounterService
+    {
+        /// <summary>
+        /// Counts the banned words in the content
+        /// </summary>
+        /// <param name="content">The content to process</param>
+        /// <returns>Number of banned words found</returns>
+        int CountBannedWords(string content);
+    }
+}
+
diff --git a/ContentConsole/Services/IBannedWordReplacementService.cs b/ContentConsole/Services/IBannedWordReplacementService.cs
new file mode 100644
index 0000000..f51d81c
--- /dev/null
+++ b/ContentConsole/Services/IBannedWordReplacementService.cs
@@ -0,0 +1,24 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace ContentConsole.Services
+{
+    /// <summary>
+    /// Replaces banned words with another character
+    /// </summary>
+    public interface IBannedWordReplacementService
+    {
+        /// <summary>
+        /// Replaces banned words with the replacement character. 
+        /// If the words are less than three characters long then the entire word is replaced, 
+        /// otherwise only the first and last characters will be shown.
+        /// </summary>
+        /// <param name="content">The content to process</param>
+        /// <param name="replacementCharacter">The character to replace the banned word characters with</param>
+        /// <returns>A string with the banned words replaced.</returns>
+        string ReplaceBannedWords(string content, char replacementCharacter = '#');
+    }
+}
diff --git a/ContentConsole/Services/IBannedWordRetrievalService.cs b/ContentConsole/Services/IBannedWordRetrievalService.cs
new file mode 100644
index 0000000..cde53f7
--- /dev/null
+++ b/ContentConsole/Services/IBannedWordRetrievalService.cs
@@ -0,0 +1,21 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace ContentConsole.Services
+{
+
+    /// <summary>
+    /// Retrieves an enumerable of banned words
+    /// </summary>
+    public interface IBannedWordRetrievalService
+    {
+        /// <summary>
+        /// Get banned words
+        /// </summary>
+        /// <returns>An IEnumerable of banned words</returns>
+        IEnumerable<string> GetBannedWords();
+    }
+}
diff --git a/README.md b/README.md
index e4e4d26..1eef857 100644
--- a/README.md
+++ b/README.md
@@ -13,6 +13,12 @@ This assignment is to analyse text, detecting and filtering negative words.
 - Reformat, refactor and rework the provided code in any way you see fit.
 - Code must be supported by tests to be "done-done".
 
+## Advice to candidates
+
+- You should approach this task in the same way that you would a real, production assignment. Do not 'code to the test'. 
+- It is more important that you show the right approach than that you complete all the stories. If you run low on time, apply an MVP to the stories. 
+- We will assume that the code you produce for this exercise reflects the kind of code you would write in a real-world situation, and assess accordingly.
+
 ## Task Stories
 
 Please complete each story in order.
@@ -75,4 +81,6 @@ So that **I can see the original content**.
 
 ---
 
+Note: Please submit your changes as a new pull request on *this* repo, and not on the original repo from which this is forked. If you can't submit a pull request then zip up your code and email it to us, but PRs are *strongly* preferred.
+
 Thanks for your time, we look forward to hearing from you!