diff --git a/README.md b/README.md
index cd01e89..bb3721e 100644
--- a/README.md
+++ b/README.md
@@ -24,3 +24,93 @@ The overall objective is to refactor the code and keep the tests passing.  There
 
 
 
+### Code refactoring improvements
+* Validation Separation: Moved validation logic to dedicated InvoiceValidator
+* Process Decomposition: Split payment processing into discrete, focused methods
+* Interface Contracts: Established clear interfaces for all dependencies
+* Method Simplification: Broke down monolithic ProcessPayment into single-responsibility methods
+* Control Flow: Eliminated nested conditionals for linear readability
+* Error Handling: Implemented structured exception handling with code safety
+* Added logging for issues investigation
+
+* The string return type in ProcessPayment is problematic as it forces client to parse unstructured messages; 
+* a strongly-typed response object would provide clearer contracts and better programmability.
+
+
+* Client side, before:
+
+// Returns unstructured string messages
+
+        string result = _invoiceService.ProcessPayment(payment);
+
+// Client must parse strings to determine outcome. How to do that efficiently?
+
+* Client side, after:
+
+      PaymentResult result = _invoiceService.ProcessPayment(payment);
+
+      if (result.IsSuccess)
+      {
+          switch (result.Code)
+          {
+              case ResultCode.FinalPaymentComplete:
+              _receiptService.Generate(invoice, result.AmountPaid);
+              _auditService.LogPaymentComplete(result.TransactionId);
+              break;
+              
+              case ResultCode.PartialPaymentComplete:
+                  _paymentTracker.ScheduleFollowUp(
+                      result.RemainingAmount,
+                      DateTime.Now.AddDays(7));
+              break;
+      
+              case ResultCode.NoPaymentNeeded:
+              case ResultCode.AlreadyFullyPaid:
+                  // Handle these cases as needed
+                  break;
+          }
+      }
+      else
+      {
+          // Handle failure scenarios
+          switch (result.Code)
+          {
+              case ResultCode.InvoiceNotFound:
+              _alertService.TriggerSupportAlert(result);
+              break;
+              
+              case ResultCode.PaymentExceedsRemainingAmount:
+              case ResultCode.PaymentExceedsInvoiceAmount:
+                  // Handle these cases as needed
+              break;
+      
+              case ResultCode.ProcessingError:
+              case ResultCode.InvalidInvoiceState:
+                  // Handle these cases as needed
+              break;
+      
+              default:
+                  _alertService.TriggerSupportAlert(result);
+              break;
+          }
+      }
+
+*** Architectural improvements
+* Proper layering with domain entities, services, and persistence
+* Dependency injection for better testability
+* Clear boundaries between components
+* Each class has a single responsibility, easier to modify or extend behavior. Clear separation makes it easier to add new features.
+
+
+*** Suggested Business Object Enhancements (not implemented):
+
+
+* Invoice/Payment Data Enrichment
+* Currently missing critical transaction details: Payer/recipient identification (names, contact info)
+* Banking/payment details
+* Transaction references
+
+
+
+
+
diff --git a/RefactorThis.Domain.Tests/App.config b/RefactorThis.Domain.Tests/App.config
new file mode 100644
index 0000000..5367091
--- /dev/null
+++ b/RefactorThis.Domain.Tests/App.config
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8"?><configuration>
+  <runtime>
+    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
+      <dependentAssembly>
+        <assemblyIdentity name="System.Runtime.CompilerServices.Unsafe" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-6.0.1.0" newVersion="6.0.1.0" />
+      </dependentAssembly>
+    </assemblyBinding>
+  </runtime>
+</configuration>
\ No newline at end of file
diff --git a/RefactorThis.Domain.Tests/InvoicePaymentProcessorTests.cs b/RefactorThis.Domain.Tests/InvoicePaymentProcessorTests.cs
index 3a607fd..4d68065 100644
--- a/RefactorThis.Domain.Tests/InvoicePaymentProcessorTests.cs
+++ b/RefactorThis.Domain.Tests/InvoicePaymentProcessorTests.cs
@@ -1,247 +1,191 @@
-using System;
-using System.Collections.Generic;
+using System.Collections.Generic;
 using NUnit.Framework;
-using RefactorThis.Persistence;
+using RefactorThis.Domain.Loggers;
+using RefactorThis.Domain.Models;
+using RefactorThis.Domain.Services;
+using RefactorThis.Domain.Tests.Mocks;
+using RefactorThis.Domain.Validators;
+using RefactorThis.Persistence.Entities;
+using RefactorThis.Persistence.Repositories;
 
 namespace RefactorThis.Domain.Tests
 {
-	[TestFixture]
-	public class InvoicePaymentProcessorTests
-	{
-		[Test]
-		public void ProcessPayment_Should_ThrowException_When_NoInoiceFoundForPaymentReference( )
-		{
-			var repo = new InvoiceRepository( );
-
-			Invoice invoice = null;
-			var paymentProcessor = new InvoiceService( repo );
-
-			var payment = new Payment( );
-			var failureMessage = "";
-
-			try
-			{
-				var result = paymentProcessor.ProcessPayment( payment );
-			}
-			catch ( InvalidOperationException e )
-			{
-				failureMessage = e.Message;
-			}
-
-			Assert.AreEqual( "There is no invoice matching this payment", failureMessage );
-		}
-
-		[Test]
-		public void ProcessPayment_Should_ReturnFailureMessage_When_NoPaymentNeeded( )
-		{
-			var repo = new InvoiceRepository( );
-
-			var invoice = new Invoice( repo )
-			{
-				Amount = 0,
-				AmountPaid = 0,
-				Payments = null
-			};
-
-			repo.Add( invoice );
-
-			var paymentProcessor = new InvoiceService( repo );
-
-			var payment = new Payment( );
-
-			var result = paymentProcessor.ProcessPayment( payment );
-
-			Assert.AreEqual( "no payment needed", result );
-		}
-
-		[Test]
-		public void ProcessPayment_Should_ReturnFailureMessage_When_InvoiceAlreadyFullyPaid( )
-		{
-			var repo = new InvoiceRepository( );
-
-			var invoice = new Invoice( repo )
-			{
-				Amount = 10,
-				AmountPaid = 10,
-				Payments = new List<Payment>
-				{
-					new Payment
-					{
-						Amount = 10
-					}
-				}
-			};
-			repo.Add( invoice );
-
-			var paymentProcessor = new InvoiceService( repo );
-
-			var payment = new Payment( );
-
-			var result = paymentProcessor.ProcessPayment( payment );
-
-			Assert.AreEqual( "invoice was already fully paid", result );
-		}
-
-		[Test]
-		public void ProcessPayment_Should_ReturnFailureMessage_When_PartialPaymentExistsAndAmountPaidExceedsAmountDue( )
-		{
-			var repo = new InvoiceRepository( );
-			var invoice = new Invoice( repo )
-			{
-				Amount = 10,
-				AmountPaid = 5,
-				Payments = new List<Payment>
-				{
-					new Payment
-					{
-						Amount = 5
-					}
-				}
-			};
-			repo.Add( invoice );
-
-			var paymentProcessor = new InvoiceService( repo );
-
-			var payment = new Payment( )
-			{
-				Amount = 6
-			};
-
-			var result = paymentProcessor.ProcessPayment( payment );
-
-			Assert.AreEqual( "the payment is greater than the partial amount remaining", result );
-		}
-
-		[Test]
-		public void ProcessPayment_Should_ReturnFailureMessage_When_NoPartialPaymentExistsAndAmountPaidExceedsInvoiceAmount( )
-		{
-			var repo = new InvoiceRepository( );
-			var invoice = new Invoice( repo )
-			{
-				Amount = 5,
-				AmountPaid = 0,
-				Payments = new List<Payment>( )
-			};
-			repo.Add( invoice );
-
-			var paymentProcessor = new InvoiceService( repo );
-
-			var payment = new Payment( )
-			{
-				Amount = 6
-			};
-
-			var result = paymentProcessor.ProcessPayment( payment );
-
-			Assert.AreEqual( "the payment is greater than the invoice amount", result );
-		}
-
-		[Test]
-		public void ProcessPayment_Should_ReturnFullyPaidMessage_When_PartialPaymentExistsAndAmountPaidEqualsAmountDue( )
-		{
-			var repo = new InvoiceRepository( );
-			var invoice = new Invoice( repo )
-			{
-				Amount = 10,
-				AmountPaid = 5,
-				Payments = new List<Payment>
-				{
-					new Payment
-					{
-						Amount = 5
-					}
-				}
-			};
-			repo.Add( invoice );
-
-			var paymentProcessor = new InvoiceService( repo );
-
-			var payment = new Payment( )
-			{
-				Amount = 5
-			};
-
-			var result = paymentProcessor.ProcessPayment( payment );
-
-			Assert.AreEqual( "final partial payment received, invoice is now fully paid", result );
-		}
-
-		[Test]
-		public void ProcessPayment_Should_ReturnFullyPaidMessage_When_NoPartialPaymentExistsAndAmountPaidEqualsInvoiceAmount( )
-		{
-			var repo = new InvoiceRepository( );
-			var invoice = new Invoice( repo )
-			{
-				Amount = 10,
-				AmountPaid = 0,
-				Payments = new List<Payment>( ) { new Payment( ) { Amount = 10 } }
-			};
-			repo.Add( invoice );
-
-			var paymentProcessor = new InvoiceService( repo );
-
-			var payment = new Payment( )
-			{
-				Amount = 10
-			};
-
-			var result = paymentProcessor.ProcessPayment( payment );
-
-			Assert.AreEqual( "invoice was already fully paid", result );
-		}
-
-		[Test]
-		public void ProcessPayment_Should_ReturnPartiallyPaidMessage_When_PartialPaymentExistsAndAmountPaidIsLessThanAmountDue( )
-		{
-			var repo = new InvoiceRepository( );
-			var invoice = new Invoice( repo )
-			{
-				Amount = 10,
-				AmountPaid = 5,
-				Payments = new List<Payment>
-				{
-					new Payment
-					{
-						Amount = 5
-					}
-				}
-			};
-			repo.Add( invoice );
-
-			var paymentProcessor = new InvoiceService( repo );
-
-			var payment = new Payment( )
-			{
-				Amount = 1
-			};
-
-			var result = paymentProcessor.ProcessPayment( payment );
-
-			Assert.AreEqual( "another partial payment received, still not fully paid", result );
-		}
-
-		[Test]
-		public void ProcessPayment_Should_ReturnPartiallyPaidMessage_When_NoPartialPaymentExistsAndAmountPaidIsLessThanInvoiceAmount( )
-		{
-			var repo = new InvoiceRepository( );
-			var invoice = new Invoice( repo )
-			{
-				Amount = 10,
-				AmountPaid = 0,
-				Payments = new List<Payment>( )
-			};
-			repo.Add( invoice );
-
-			var paymentProcessor = new InvoiceService( repo );
-
-			var payment = new Payment( )
-			{
-				Amount = 1
-			};
-
-			var result = paymentProcessor.ProcessPayment( payment );
-
-			Assert.AreEqual( "invoice is now partially paid", result );
-		}
-	}
+    [TestFixture]
+    public class InvoicePaymentProcessorTests
+    {
+        private IInvoiceService _invoiceService;
+        private IInvoiceRepository _invoiceRepository;
+        private IInvoiceValidator _invoiceValidator;
+        private IAppLogger _logger;
+
+        [SetUp]
+        public void BeforeEachTest()
+        {
+            _invoiceRepository = new MockInvoiceRepository();
+            _invoiceValidator = new InvoiceValidator();
+            _logger = new AppLogger<InvoicePaymentProcessorTests>();
+            _invoiceService = new InvoiceService(_invoiceRepository, _invoiceValidator, _logger);
+        }
+
+        [Test]
+        public void ProcessPayment_Should_ReturnFailure_When_NoInvoiceFoundForPaymentReference()
+        {
+            var payment = new Payment();
+            var result = _invoiceService.ProcessPayment(payment);
+            
+            Assert.IsFalse(result.IsSuccess);
+            Assert.AreEqual(ResultCode.InvoiceNotFound, result.Code);
+            Assert.AreEqual("There is no invoice matching this payment", result.Message);
+        }
+
+        [Test]
+        public void ProcessPayment_Should_ReturnSuccess_When_NoPaymentNeeded()
+        {
+            var invoice = new Invoice { Amount = 0, Payments = null };
+            _invoiceRepository.Add(invoice);
+            
+            var payment = new Payment();
+            var result = _invoiceService.ProcessPayment(payment);
+
+            Assert.IsTrue(result.IsSuccess);
+            Assert.AreEqual(ResultCode.NoPaymentNeeded, result.Code);
+            Assert.AreEqual("no payment needed", result.Message);
+        }
+
+        [Test]
+        public void ProcessPayment_Should_ReturnSuccess_When_InvoiceAlreadyFullyPaid()
+        {
+            var invoice = new Invoice
+            {
+                Amount = 10,
+                Payments = new List<Payment> { new Payment { Amount = 10 } }
+            };
+            _invoiceRepository.Add(invoice);
+            
+            var payment = new Payment();
+            
+            var result = _invoiceService.ProcessPayment(payment);
+
+            Assert.IsTrue(result.IsSuccess);
+            Assert.AreEqual(ResultCode.AlreadyFullyPaid, result.Code);
+            Assert.AreEqual("invoice was already fully paid", result.Message);
+        }
+
+        [Test]
+        public void ProcessPayment_Should_ReturnFailure_When_PartialPaymentExistsAndAmountPaidExceedsAmountDue()
+        {
+            // Arrange
+            var invoice = new Invoice
+            {
+                Amount = 10,
+                Payments = new List<Payment> { new Payment { Amount = 5 } }
+            };
+            _invoiceRepository.Add(invoice);
+            
+            var payment = new Payment { Amount = 6 };
+
+            var result = _invoiceService.ProcessPayment(payment);
+
+            Assert.IsFalse(result.IsSuccess);
+            Assert.AreEqual(ResultCode.PaymentExceedsRemainingAmount, result.Code);
+            Assert.AreEqual("the payment is greater than the partial amount remaining", result.Message);
+        }
+
+        [Test]
+        public void ProcessPayment_Should_ReturnFailure_When_NoPartialPaymentExistsAndAmountPaidExceedsInvoiceAmount()
+        {
+            // Arrange
+            var invoice = new Invoice { Amount = 5, Payments = new List<Payment>() };
+            _invoiceRepository.Add(invoice);
+            var payment = new Payment { Amount = 6 };
+
+            // Act
+            var result = _invoiceService.ProcessPayment(payment);
+
+            // Assert
+            Assert.IsFalse(result.IsSuccess);
+            Assert.AreEqual(ResultCode.PaymentExceedsInvoiceAmount, result.Code);
+            Assert.AreEqual("the payment is greater than the invoice amount", result.Message);
+        }
+
+        [Test]
+        public void ProcessPayment_Should_ReturnSuccess_When_PartialPaymentExistsAndAmountPaidEqualsAmountDue()
+        {
+            // Arrange
+            var invoice = new Invoice
+            {
+                Amount = 10,
+                Payments = new List<Payment> { new Payment { Amount = 5 } }
+            };
+            _invoiceRepository.Add(invoice);
+            var payment = new Payment { Amount = 5 };
+
+            // Act
+            var result = _invoiceService.ProcessPayment(payment);
+
+            // Assert
+            Assert.IsTrue(result.IsSuccess);
+            Assert.AreEqual(ResultCode.FinalPaymentComplete, result.Code);
+            Assert.AreEqual("final partial payment received, invoice is now fully paid", result.Message);
+        }
+
+        [Test]
+        public void ProcessPayment_Should_ReturnSuccess_When_PartialPaymentExistsAndAmountPaidIsLessThanAmountDue()
+        {
+            // Arrange
+            var invoice = new Invoice
+            {
+                Amount = 10,
+                Payments = new List<Payment> { new Payment { Amount = 5 } }
+            };
+            _invoiceRepository.Add(invoice);
+            var payment = new Payment { Amount = 1 };
+
+            // Act
+            var result = _invoiceService.ProcessPayment(payment);
+
+            // Assert
+            Assert.IsTrue(result.IsSuccess);
+            Assert.AreEqual(ResultCode.PartialPaymentComplete, result.Code);
+            Assert.AreEqual("partial payment received, invoice is still not fully paid", result.Message);
+        }
+
+        [Test]
+        public void ProcessPayment_Should_ReturnSuccess_When_NoPartialPaymentExistsAndAmountPaidIsLessThanInvoiceAmount()
+        {
+            // Arrange
+            var invoice = new Invoice { Amount = 10, Payments = new List<Payment>() };
+            _invoiceRepository.Add(invoice);
+            var payment = new Payment { Amount = 1 };
+
+            // Act
+            var result = _invoiceService.ProcessPayment(payment);
+
+            // Assert
+            Assert.IsTrue(result.IsSuccess);
+            Assert.AreEqual(ResultCode.PartialPaymentComplete, result.Code);
+            Assert.AreEqual("invoice is now partially paid", result.Message);
+        }
+
+        [Test]
+        public void ProcessPayment_Should_CalculateTax_When_CommercialInvoice()
+        {
+            // Arrange
+            var invoice = new Invoice 
+            { 
+                Amount = 10, 
+                Payments = new List<Payment>(),
+                Type = InvoiceType.Commercial
+            };
+            _invoiceRepository.Add(invoice);
+            var payment = new Payment { Amount = 10 };
+
+            // Act
+            var result = _invoiceService.ProcessPayment(payment);
+
+            // Assert
+            Assert.AreEqual(1.4m, invoice.TaxAmount);
+            Assert.IsTrue(result.IsSuccess);
+        }
+    }
 }
\ No newline at end of file
diff --git a/RefactorThis.Domain.Tests/Mocks/MockInvoiceRepository.cs b/RefactorThis.Domain.Tests/Mocks/MockInvoiceRepository.cs
new file mode 100644
index 0000000..be55f70
--- /dev/null
+++ b/RefactorThis.Domain.Tests/Mocks/MockInvoiceRepository.cs
@@ -0,0 +1,25 @@
+using RefactorThis.Persistence.Entities;
+using RefactorThis.Persistence.Repositories;
+
+namespace RefactorThis.Domain.Tests.Mocks
+{
+    public class MockInvoiceRepository : IInvoiceRepository
+    {
+        private Invoice _invoice;
+
+        public Invoice GetInvoice(string reference)
+        {
+            return _invoice;
+        }
+
+        public void SaveInvoice(Invoice invoice)
+        {
+            // In memory implementation for testing
+        }
+
+        public void Add(Invoice invoice)
+        {
+            _invoice = invoice;
+        }
+    }
+}
\ No newline at end of file
diff --git a/RefactorThis.Domain.Tests/RefactorThis.Domain.Tests.csproj b/RefactorThis.Domain.Tests/RefactorThis.Domain.Tests.csproj
index f118007..935774c 100644
--- a/RefactorThis.Domain.Tests/RefactorThis.Domain.Tests.csproj
+++ b/RefactorThis.Domain.Tests/RefactorThis.Domain.Tests.csproj
@@ -43,6 +43,7 @@
 	</ItemGroup>
 	<ItemGroup>
 		<Compile Include="InvoicePaymentProcessorTests.cs" />
+		<Compile Include="Mocks\MockInvoiceRepository.cs" />
 		<Compile Include="Properties\AssemblyInfo.cs" />
 	</ItemGroup>
 	<ItemGroup>
diff --git a/RefactorThis.Domain.Tests/packages.config b/RefactorThis.Domain.Tests/packages.config
index c108d44..55738bc 100644
--- a/RefactorThis.Domain.Tests/packages.config
+++ b/RefactorThis.Domain.Tests/packages.config
@@ -1,4 +1,11 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
-  <package id="NUnit" version="3.5.0" targetFramework="net45" />
+  <package id="NUnit" version="4.3.2" targetFramework="net472" />
+  <package id="System.Buffers" version="4.6.0" targetFramework="net472" />
+  <package id="System.Linq" version="4.3.0" targetFramework="net472" />
+  <package id="System.Memory" version="4.6.0" targetFramework="net472" />
+  <package id="System.Numerics.Vectors" version="4.6.0" targetFramework="net472" />
+  <package id="System.Runtime.CompilerServices.Unsafe" version="6.1.0" targetFramework="net472" />
+  <package id="System.Threading.Tasks.Extensions" version="4.5.4" targetFramework="net472" />
+  <package id="System.ValueTuple" version="4.5.0" targetFramework="net472" />
 </packages>
\ No newline at end of file
diff --git a/RefactorThis.Domain/Exceptions/InvoiceValidationException.cs b/RefactorThis.Domain/Exceptions/InvoiceValidationException.cs
new file mode 100644
index 0000000..d29387e
--- /dev/null
+++ b/RefactorThis.Domain/Exceptions/InvoiceValidationException.cs
@@ -0,0 +1,15 @@
+using System;
+
+namespace RefactorThis.Domain.Exceptions
+{
+    public class InvoiceValidationException : Exception
+    {
+        public InvoiceValidationException(string message) 
+            : base(message)
+        {}
+
+        public InvoiceValidationException(string message, Exception innerException)
+            : base(message, innerException)
+        {}
+    }
+}
\ No newline at end of file
diff --git a/RefactorThis.Domain/InvoiceService.cs b/RefactorThis.Domain/InvoiceService.cs
deleted file mode 100644
index fbd674c..0000000
--- a/RefactorThis.Domain/InvoiceService.cs
+++ /dev/null
@@ -1,149 +0,0 @@
-using System;
-using System.Linq;
-using RefactorThis.Persistence;
-
-namespace RefactorThis.Domain
-{
-	public class InvoiceService
-	{
-		private readonly InvoiceRepository _invoiceRepository;
-
-		public InvoiceService( InvoiceRepository invoiceRepository )
-		{
-			_invoiceRepository = invoiceRepository;
-		}
-
-		public string ProcessPayment( Payment payment )
-		{
-			var inv = _invoiceRepository.GetInvoice( payment.Reference );
-
-			var responseMessage = string.Empty;
-
-			if ( inv == null )
-			{
-				throw new InvalidOperationException( "There is no invoice matching this payment" );
-			}
-			else
-			{
-				if ( inv.Amount == 0 )
-				{
-					if ( inv.Payments == null || !inv.Payments.Any( ) )
-					{
-						responseMessage = "no payment needed";
-					}
-					else
-					{
-						throw new InvalidOperationException( "The invoice is in an invalid state, it has an amount of 0 and it has payments." );
-					}
-				}
-				else
-				{
-					if ( inv.Payments != null && inv.Payments.Any( ) )
-					{
-						if ( inv.Payments.Sum( x => x.Amount ) != 0 && inv.Amount == inv.Payments.Sum( x => x.Amount ) )
-						{
-							responseMessage = "invoice was already fully paid";
-						}
-						else if ( inv.Payments.Sum( x => x.Amount ) != 0 && payment.Amount > ( inv.Amount - inv.AmountPaid ) )
-						{
-							responseMessage = "the payment is greater than the partial amount remaining";
-						}
-						else
-						{
-							if ( ( inv.Amount - inv.AmountPaid ) == payment.Amount )
-							{
-								switch ( inv.Type )
-								{
-									case InvoiceType.Standard:
-										inv.AmountPaid += payment.Amount;
-										inv.Payments.Add( payment );
-										responseMessage = "final partial payment received, invoice is now fully paid";
-										break;
-									case InvoiceType.Commercial:
-										inv.AmountPaid += payment.Amount;
-										inv.TaxAmount += payment.Amount * 0.14m;
-										inv.Payments.Add( payment );
-										responseMessage = "final partial payment received, invoice is now fully paid";
-										break;
-									default:
-										throw new ArgumentOutOfRangeException( );
-								}
-								
-							}
-							else
-							{
-								switch ( inv.Type )
-								{
-									case InvoiceType.Standard:
-										inv.AmountPaid += payment.Amount;
-										inv.Payments.Add( payment );
-										responseMessage = "another partial payment received, still not fully paid";
-										break;
-									case InvoiceType.Commercial:
-										inv.AmountPaid += payment.Amount;
-										inv.TaxAmount += payment.Amount * 0.14m;
-										inv.Payments.Add( payment );
-										responseMessage = "another partial payment received, still not fully paid";
-										break;
-									default:
-										throw new ArgumentOutOfRangeException( );
-								}
-							}
-						}
-					}
-					else
-					{
-						if ( payment.Amount > inv.Amount )
-						{
-							responseMessage = "the payment is greater than the invoice amount";
-						}
-						else if ( inv.Amount == payment.Amount )
-						{
-							switch ( inv.Type )
-							{
-								case InvoiceType.Standard:
-									inv.AmountPaid = payment.Amount;
-									inv.TaxAmount = payment.Amount * 0.14m;
-									inv.Payments.Add( payment );
-									responseMessage = "invoice is now fully paid";
-									break;
-								case InvoiceType.Commercial:
-									inv.AmountPaid = payment.Amount;
-									inv.TaxAmount = payment.Amount * 0.14m;
-									inv.Payments.Add( payment );
-									responseMessage = "invoice is now fully paid";
-									break;
-								default:
-									throw new ArgumentOutOfRangeException( );
-							}
-						}
-						else
-						{
-							switch ( inv.Type )
-							{
-								case InvoiceType.Standard:
-									inv.AmountPaid = payment.Amount;
-									inv.TaxAmount = payment.Amount * 0.14m;
-									inv.Payments.Add( payment );
-									responseMessage = "invoice is now partially paid";
-									break;
-								case InvoiceType.Commercial:
-									inv.AmountPaid = payment.Amount;
-									inv.TaxAmount = payment.Amount * 0.14m;
-									inv.Payments.Add( payment );
-									responseMessage = "invoice is now partially paid";
-									break;
-								default:
-									throw new ArgumentOutOfRangeException( );
-							}
-						}
-					}
-				}
-			}
-			
-			inv.Save();
-
-			return responseMessage;
-		}
-	}
-}
\ No newline at end of file
diff --git a/RefactorThis.Domain/Loggers/AppLoggger.cs b/RefactorThis.Domain/Loggers/AppLoggger.cs
new file mode 100644
index 0000000..f188546
--- /dev/null
+++ b/RefactorThis.Domain/Loggers/AppLoggger.cs
@@ -0,0 +1,26 @@
+using System;
+
+namespace RefactorThis.Domain.Loggers
+{
+    public class AppLogger<T> : IAppLogger
+    {
+        private readonly string _typeName = typeof(T).Name;
+
+        public void LogInformation(string message, params object[] args)
+        {
+            Console.WriteLine($"[INFO] [{_typeName}] {string.Format(message, args)}");
+        }
+
+        public void LogWarning(string message, params object[] args)
+        {
+            Console.WriteLine($"[WARN] [{_typeName}] {string.Format(message, args)}");
+        }
+
+        public void LogError(Exception ex, string message, params object[] args)
+        {
+            Console.WriteLine($"[ERROR] [{_typeName}] {string.Format(message, args)}");
+            Console.WriteLine($"Exception: {ex.GetType().Name} - {ex.Message}");
+            Console.WriteLine($"Stack Trace: {ex.StackTrace}");
+        }
+    }
+}
\ No newline at end of file
diff --git a/RefactorThis.Domain/Loggers/IAppLogger.cs b/RefactorThis.Domain/Loggers/IAppLogger.cs
new file mode 100644
index 0000000..3c74159
--- /dev/null
+++ b/RefactorThis.Domain/Loggers/IAppLogger.cs
@@ -0,0 +1,11 @@
+using System;
+
+namespace RefactorThis.Domain.Loggers
+{
+    public interface IAppLogger
+    {
+        void LogInformation(string message, params object[] args);
+        void LogWarning(string message, params object[] args);
+        void LogError(Exception ex, string message, params object[] args);
+    }
+}
\ No newline at end of file
diff --git a/RefactorThis.Domain/Models/PaymentResult.cs b/RefactorThis.Domain/Models/PaymentResult.cs
new file mode 100644
index 0000000..de3199e
--- /dev/null
+++ b/RefactorThis.Domain/Models/PaymentResult.cs
@@ -0,0 +1,39 @@
+namespace RefactorThis.Domain.Models
+{
+    public class PaymentResult
+    {
+        public bool IsSuccess { get; }
+        public ResultCode? Code { get; }
+        public string Message { get; }
+
+        public static PaymentResult SuccessResult(ResultCode? code = null, string message = null) 
+            => new PaymentResult(true, code, message);
+            
+        public static PaymentResult FailureResult(ResultCode? code = null, string message = null) 
+            => new PaymentResult(false, code, message);
+        
+        private PaymentResult(bool isSuccess, ResultCode? code = null, string message = null)
+        {
+            IsSuccess = isSuccess;
+            Code = code ?? ResultCode.Unknown;
+            Message = string.IsNullOrEmpty(message) ? "No comments" : message;
+        }
+    }
+
+    public enum ResultCode
+    {
+        Unknown,
+        // Success
+        NoPaymentNeeded,
+        AlreadyFullyPaid,
+        FinalPaymentComplete,
+        PartialPaymentComplete,
+        
+        // Failure
+        InvoiceNotFound,
+        InvalidInvoiceState,
+        PaymentExceedsRemainingAmount,
+        PaymentExceedsInvoiceAmount,
+        ProcessingError
+    }
+}
\ No newline at end of file
diff --git a/RefactorThis.Domain/RefactorThis.Domain.csproj b/RefactorThis.Domain/RefactorThis.Domain.csproj
index 753e893..20c3dc7 100644
--- a/RefactorThis.Domain/RefactorThis.Domain.csproj
+++ b/RefactorThis.Domain/RefactorThis.Domain.csproj
@@ -32,20 +32,42 @@
 		<WarningLevel>4</WarningLevel>
 	</PropertyGroup>
 	<ItemGroup>
+		<Reference Include="mscorlib" />
 		<Reference Include="System" />
 		<Reference Include="System.Core" />
 		<Reference Include="System.Data" />
+		<Reference Include="System.Linq, Version=4.1.1.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
+		  <HintPath>..\packages\System.Linq.4.3.0\lib\net463\System.Linq.dll</HintPath>
+		</Reference>
 		<Reference Include="System.Xml" />
 	</ItemGroup>
 	<ItemGroup>
-		<Compile Include="InvoiceService.cs" />
+		<Compile Include="Exceptions\InvoiceValidationException.cs" />
+		<Compile Include="Loggers\AppLoggger.cs" />
+		<Compile Include="Loggers\IAppLogger.cs" />
+		<Compile Include="Models\PaymentResult.cs" />
 		<Compile Include="Properties\AssemblyInfo.cs" />
+		<Compile Include="Services\IInvoiceService.cs" />
+		<Compile Include="Services\InvoiceService.cs" />
+		<Compile Include="Validators\IInvoiceValidator.cs" />
+		<Compile Include="Validators\InvoiceValidator.cs" />
 	</ItemGroup>
 	<ItemGroup>
 	  <ProjectReference Include="..\RefactorThis.Persistence\RefactorThis.Persistence.csproj">
 	    <Project>{33cdc796-ff75-449c-9637-59c2efc46361}</Project>
 	    <Name>RefactorThis.Persistence</Name>
 	  </ProjectReference>
+	  <PackageReference Include="Microsoft.Extensions.Logging" Version="10.0.0-preview.3.25171.5" />
+	  <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="10.0.0-preview.3.25171.5" />
+	  <PackageReference Include="Microsoft.NETFramework.ReferenceAssemblies.net472" Version="1.0.3">
+	    <PrivateAssets>all</PrivateAssets>
+	    <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+	  </PackageReference>
+		<PackageReference Include="NUnit" Version="4.3.2" />
+		<PackageReference Include="NUnit3TestAdapter" Version="4.5.0" />
+	</ItemGroup>
+	<ItemGroup>
+	  <None Include="packages.config" />
 	</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/RefactorThis.Domain/Services/IInvoiceService.cs b/RefactorThis.Domain/Services/IInvoiceService.cs
new file mode 100644
index 0000000..2df00e5
--- /dev/null
+++ b/RefactorThis.Domain/Services/IInvoiceService.cs
@@ -0,0 +1,10 @@
+using RefactorThis.Domain.Models;
+using RefactorThis.Persistence.Entities;
+
+namespace RefactorThis.Domain.Services
+{
+    public interface IInvoiceService
+    {
+        PaymentResult ProcessPayment(Payment payment);
+    }
+}
\ No newline at end of file
diff --git a/RefactorThis.Domain/Services/InvoiceService.cs b/RefactorThis.Domain/Services/InvoiceService.cs
new file mode 100644
index 0000000..2fca013
--- /dev/null
+++ b/RefactorThis.Domain/Services/InvoiceService.cs
@@ -0,0 +1,113 @@
+using System;
+using System.Linq;
+using RefactorThis.Domain.Loggers;
+using RefactorThis.Domain.Models;
+using RefactorThis.Domain.Validators;
+using RefactorThis.Persistence.Entities;
+using RefactorThis.Persistence.Repositories;
+
+namespace RefactorThis.Domain.Services
+{
+    public class InvoiceService : IInvoiceService
+    {
+        private readonly IInvoiceRepository _invoiceRepository;
+        private readonly IInvoiceValidator _invoiceValidator;
+        private readonly IAppLogger _logger;
+
+        public InvoiceService(
+            IInvoiceRepository invoiceRepository, 
+            IInvoiceValidator invoiceValidator,
+            IAppLogger logger)
+        {
+            _invoiceRepository = invoiceRepository ?? throw new ArgumentNullException(nameof(invoiceRepository));
+            _invoiceValidator = invoiceValidator ?? throw new ArgumentNullException(nameof(invoiceValidator));
+            _logger = logger ?? throw new ArgumentNullException(nameof(logger));
+        }
+
+        public PaymentResult ProcessPayment(Payment payment)
+        {
+            try
+            {
+                var invoice = _invoiceRepository.GetInvoice(payment.Reference);
+                var errorResult = _invoiceValidator.ValidatePayment(invoice, payment);
+                
+                if (errorResult != null)
+                {
+                    _logger.LogWarning("Payment validation failed: {0} - {1}", 
+                        errorResult.Code, errorResult.Message);
+                    return errorResult;
+                }
+                
+                return ProcessValidPayment(invoice, payment);
+            }
+            catch (Exception ex)
+            {
+                var logMessage = $"Unexpected error processing payment for reference: {payment?.Reference ?? "null"}. " +
+                                 $"Exception: {ex.GetType().Name} - {ex.Message}. " +
+                                 $"Stack Trace: {ex.StackTrace ?? "Not available"}";
+                
+                var userMessage = "An unexpected error occurred while processing payment" +
+                                  (payment?.Reference != null ? $" (Reference: {payment.Reference})" : "");
+
+                _logger?.LogError(ex, logMessage);
+    
+                return PaymentResult.FailureResult(
+                    ResultCode.ProcessingError,
+                    userMessage);
+            }
+        }
+
+        private PaymentResult ProcessValidPayment(Invoice invoice, Payment payment)
+        {
+            try
+            {
+                var totalPaid = invoice.Payments.Sum(p => p.Amount);
+                var remainingAmount = invoice.Amount - totalPaid;
+                var isFinalPayment = remainingAmount == payment.Amount;
+                var hasExistingPayments = invoice.Payments.Any();
+
+                _logger.LogInformation("Processing payment - Amount: {0}, Remaining: {1}, Final: {2}", 
+                    payment.Amount, remainingAmount, isFinalPayment);
+
+                UpdateInvoiceWithPayment(invoice, payment);
+                _invoiceRepository.SaveInvoice(invoice);
+
+                _logger.LogInformation("Successfully updated invoice {0} with payment {1}", 
+                    payment.Reference, payment.Amount);
+
+                if (isFinalPayment)
+                {
+                    _logger.LogInformation("Final payment completed for invoice {0}", payment.Reference);
+                    return PaymentResult.SuccessResult(
+                        ResultCode.FinalPaymentComplete,
+                        "final partial payment received, invoice is now fully paid");
+                }
+
+                _logger.LogInformation("Partial payment processed for invoice {0}", payment.Reference);
+                return PaymentResult.SuccessResult(
+                    ResultCode.PartialPaymentComplete,
+                    hasExistingPayments 
+                        ? "partial payment received, invoice is still not fully paid" 
+                        : "invoice is now partially paid");
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Error processing valid payment for reference: {0}", payment.Reference);
+                throw;
+            }
+        }
+
+        private void UpdateInvoiceWithPayment(Invoice invoice, Payment payment)
+        {
+            invoice.AmountPaid += payment.Amount;
+            invoice.Payments.Add(payment);
+
+            if (invoice.Type != InvoiceType.Commercial) return;
+            
+            var tax = payment.Amount * 0.14m;
+            invoice.TaxAmount += tax;
+            _logger.LogInformation("Added commercial tax {0} for payment {1}", 
+                tax, payment.Amount);
+        }
+    }
+}
\ No newline at end of file
diff --git a/RefactorThis.Domain/Validators/IInvoiceValidator.cs b/RefactorThis.Domain/Validators/IInvoiceValidator.cs
new file mode 100644
index 0000000..3e6a4ca
--- /dev/null
+++ b/RefactorThis.Domain/Validators/IInvoiceValidator.cs
@@ -0,0 +1,10 @@
+using RefactorThis.Domain.Models;
+using RefactorThis.Persistence.Entities;
+
+namespace RefactorThis.Domain.Validators
+{
+    public interface IInvoiceValidator
+    {
+        PaymentResult ValidatePayment(Invoice invoice, Payment payment);
+    }
+}
\ No newline at end of file
diff --git a/RefactorThis.Domain/Validators/InvoiceValidator.cs b/RefactorThis.Domain/Validators/InvoiceValidator.cs
new file mode 100644
index 0000000..f1d4996
--- /dev/null
+++ b/RefactorThis.Domain/Validators/InvoiceValidator.cs
@@ -0,0 +1,70 @@
+using System.Linq;
+using RefactorThis.Domain.Models;
+using RefactorThis.Persistence.Entities;
+
+namespace RefactorThis.Domain.Validators
+{
+    public class InvoiceValidator : IInvoiceValidator
+    {
+        public PaymentResult ValidatePayment(Invoice invoice, Payment payment)
+        {
+            if (invoice == null)
+                return PaymentResult.FailureResult(
+                    ResultCode.InvoiceNotFound, 
+                    "There is no invoice matching this payment");
+
+            if (invoice.Amount == 0)
+                return ValidateZeroAmountInvoice(invoice);
+
+            return ValidateNonZeroAmountInvoice(invoice, payment);
+        }
+
+        private PaymentResult ValidateZeroAmountInvoice(Invoice invoice)
+        {
+            if (invoice.Payments == null || !invoice.Payments.Any())
+                return PaymentResult.SuccessResult(
+                    ResultCode.NoPaymentNeeded, 
+                    "no payment needed");
+
+            return PaymentResult.FailureResult(
+                ResultCode.InvalidInvoiceState,
+                "The invoice is in an invalid state, it has an amount of 0 and it has payments.");
+        }
+
+        private PaymentResult ValidateNonZeroAmountInvoice(Invoice invoice, Payment payment)
+        {
+            if (invoice.Payments.Any())
+                return ValidateInvoiceWithExistingPayments(invoice, payment);
+
+            return ValidateInvoiceWithoutPayments(invoice, payment);
+        }
+
+        private PaymentResult ValidateInvoiceWithExistingPayments(Invoice invoice, Payment payment)
+        {
+            var totalPaid = invoice.Payments.Sum(x => x.Amount);
+            var remainingAmount = invoice.Amount - totalPaid;
+
+            if (totalPaid == invoice.Amount)
+                return PaymentResult.SuccessResult(
+                    ResultCode.AlreadyFullyPaid,
+                    "invoice was already fully paid");
+
+            if (payment.Amount > remainingAmount)
+                return PaymentResult.FailureResult(
+                    ResultCode.PaymentExceedsRemainingAmount,
+                    "the payment is greater than the partial amount remaining");
+
+            return null; // validation passed
+        }
+
+        private PaymentResult ValidateInvoiceWithoutPayments(Invoice invoice, Payment payment)
+        {
+            if (payment.Amount > invoice.Amount)
+                return PaymentResult.FailureResult(
+                    ResultCode.PaymentExceedsInvoiceAmount,
+                    "the payment is greater than the invoice amount");
+
+            return null; // validation passed
+        }
+    }
+}
\ No newline at end of file
diff --git a/RefactorThis.Domain/packages.config b/RefactorThis.Domain/packages.config
new file mode 100644
index 0000000..928cdea
--- /dev/null
+++ b/RefactorThis.Domain/packages.config
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<packages>
+  <package id="System.Linq" version="4.3.0" targetFramework="net472" />
+</packages>
\ No newline at end of file
diff --git a/RefactorThis.Persistence/Entities/Invoice.cs b/RefactorThis.Persistence/Entities/Invoice.cs
new file mode 100644
index 0000000..1e99387
--- /dev/null
+++ b/RefactorThis.Persistence/Entities/Invoice.cs
@@ -0,0 +1,19 @@
+using System.Collections.Generic;
+
+namespace RefactorThis.Persistence.Entities
+{
+	public class Invoice
+	{
+		public decimal Amount { get; set; }
+		public decimal AmountPaid { get; set; }
+		public decimal TaxAmount { get; set; }
+		public List<Payment> Payments { get; set; } = new List<Payment>();
+		public InvoiceType Type { get; set; }
+	}
+
+	public enum InvoiceType
+	{
+		Standard,
+		Commercial  
+	}
+}
\ No newline at end of file
diff --git a/RefactorThis.Persistence/Payment.cs b/RefactorThis.Persistence/Entities/Payment.cs
similarity index 71%
rename from RefactorThis.Persistence/Payment.cs
rename to RefactorThis.Persistence/Entities/Payment.cs
index db29372..7322a5e 100644
--- a/RefactorThis.Persistence/Payment.cs
+++ b/RefactorThis.Persistence/Entities/Payment.cs
@@ -1,4 +1,4 @@
-namespace RefactorThis.Persistence
+namespace RefactorThis.Persistence.Entities
 {
 	public class Payment
 	{
diff --git a/RefactorThis.Persistence/Invoice.cs b/RefactorThis.Persistence/Invoice.cs
deleted file mode 100644
index bd4370d..0000000
--- a/RefactorThis.Persistence/Invoice.cs
+++ /dev/null
@@ -1,31 +0,0 @@
-using System.Collections.Generic;
-
-namespace RefactorThis.Persistence
-{
-	public class Invoice
-	{
-		private readonly InvoiceRepository _repository;
-		public Invoice( InvoiceRepository repository )
-		{
-			_repository = repository;
-		}
-
-		public void Save( )
-		{
-			_repository.SaveInvoice( this );
-		}
-
-		public decimal Amount { get; set; }
-		public decimal AmountPaid { get; set; }
-		public decimal TaxAmount { get; set; }
-		public List<Payment> Payments { get; set; }
-		
-		public InvoiceType Type { get; set; }
-	}
-
-	public enum InvoiceType
-	{
-		Standard,
-		Commercial
-	}
-}
\ No newline at end of file
diff --git a/RefactorThis.Persistence/InvoiceRepository.cs b/RefactorThis.Persistence/InvoiceRepository.cs
deleted file mode 100644
index 38548c7..0000000
--- a/RefactorThis.Persistence/InvoiceRepository.cs
+++ /dev/null
@@ -1,21 +0,0 @@
-namespace RefactorThis.Persistence {
-	public class InvoiceRepository
-	{
-		private Invoice _invoice;
-
-		public Invoice GetInvoice( string reference )
-		{
-			return _invoice;
-		}
-
-		public void SaveInvoice( Invoice invoice )
-		{
-			//saves the invoice to the database
-		}
-
-		public void Add( Invoice invoice )
-		{
-			_invoice = invoice;
-		}
-	}
-}
\ No newline at end of file
diff --git a/RefactorThis.Persistence/RefactorThis.Persistence.csproj b/RefactorThis.Persistence/RefactorThis.Persistence.csproj
index 78de691..17b2c33 100644
--- a/RefactorThis.Persistence/RefactorThis.Persistence.csproj
+++ b/RefactorThis.Persistence/RefactorThis.Persistence.csproj
@@ -5,4 +5,8 @@
 		<LangVersion>7.3</LangVersion>
 	</PropertyGroup>
 
+	<ItemGroup>
+	  <PackageReference Include="System.Linq" Version="4.3.0" />
+	</ItemGroup>
+
 </Project>
diff --git a/RefactorThis.Persistence/Repositories/IInvoiceRepository.cs b/RefactorThis.Persistence/Repositories/IInvoiceRepository.cs
new file mode 100644
index 0000000..076714a
--- /dev/null
+++ b/RefactorThis.Persistence/Repositories/IInvoiceRepository.cs
@@ -0,0 +1,11 @@
+using RefactorThis.Persistence.Entities;
+
+namespace RefactorThis.Persistence.Repositories
+{
+    public interface IInvoiceRepository
+    {
+        Invoice GetInvoice(string reference);
+        void SaveInvoice(Invoice invoice);
+        void Add(Invoice invoice);
+    }
+}
\ No newline at end of file
diff --git a/RefactorThis.Persistence/Repositories/InvoiceRepository.cs b/RefactorThis.Persistence/Repositories/InvoiceRepository.cs
new file mode 100644
index 0000000..38dfc29
--- /dev/null
+++ b/RefactorThis.Persistence/Repositories/InvoiceRepository.cs
@@ -0,0 +1,24 @@
+using System;
+using RefactorThis.Persistence.Entities;
+
+namespace RefactorThis.Persistence.Repositories 
+{
+	public class InvoiceRepository : IInvoiceRepository
+	{
+		public Invoice GetInvoice( string reference )
+		{
+			throw new NotImplementedException();
+		}
+
+		public void SaveInvoice( Invoice invoice )
+		{
+			//saves the invoice to the database
+			throw new NotImplementedException();
+		}
+
+		public void Add( Invoice invoice )
+		{
+			throw new NotImplementedException();
+		}
+	}
+}
\ No newline at end of file