<blockquote>
The domain defines what your business is. The Application layer defines what your system can do. Get the boundary wrong and everything bleeds together.
</blockquote>
<hr>
<h2>Day 4 of building SGAcademy in public</h2>
Yesterday I built the domain layer — entities, value objects, enums, and the base <code>AuditableEntity</code> that stamps every record with created/updated metadata.
Today: the Application layer.
In SGAcademy this layer lives in <code>SGAcademy.Application</code>. Its job is to expose use cases — the actual operations your system supports — through services that the API layer calls.
No business logic leaking into controllers. No database code here. Just clean orchestration.
<hr>
<h2>What lives in the Application layer</h2>
Three things:
<ul>
<li>Service interfaces — contracts that define what each feature area can do</li>
<li>Service implementations — the code that orchestrates domain objects and repositories</li>
<li>DTOs + AutoMapper profiles — the shapes of data going in and out</li>
</ul>
That’s it. The Application layer depends on the Domain layer. It defines interfaces for repositories. It never touches Entity Framework directly — that’s Infrastructure’s job.
<hr>
<h2>The pattern: Service → IRepositoryWrapper → Repository</h2>
Every service in SGAcademy follows the same structure. Here’s the student enrollment service as a real example:
Service interface → <code>Contracts/Services/IStudentService.cs</code>
<pre><code class="language-csharp">public interface IStudentService
{
 Task&lt;IEnumerable&lt;StudentDto&gt;&gt; GetAllAsync();
 Task&lt;StudentDto&gt; GetByIdAsync(Guid id);
 Task&lt;StudentDto&gt; CreateAsync(CreateStudentDto dto);
 Task&lt;StudentDto&gt; UpdateAsync(Guid id, UpdateStudentDto dto);
 Task DeleteAsync(Guid id);
}
</code></pre>
Service implementation → <code>Services/StudentService.cs</code>
<pre><code class="language-csharp">public class StudentService : IStudentService
{
 private readonly IRepositoryWrapper _repository;
 private readonly IMapper _mapper;

 public StudentService(IRepositoryWrapper repository, IMapper mapper)
 {
 _repository = repository;
 _mapper = mapper;
 }

 public async Task&lt;StudentDto&gt; GetByIdAsync(Guid id)
 {
 var student = await _repository.Student.GetByIdAsync(id)
 ?? throw new RecordNotFoundError($&quot;Student {id} not found.&quot;);

 return _mapper.Map&lt;StudentDto&gt;(student);
 }

 public async Task&lt;StudentDto&gt; CreateAsync(CreateStudentDto dto)
 {
 var student = _mapper.Map&lt;Student&gt;(dto);
 _repository.Student.Create(student);
 await _repository.SaveAsync();
 return _mapper.Map&lt;StudentDto&gt;(student);
 }

 public async Task DeleteAsync(Guid id)
 {
 var student = await _repository.Student.GetByIdAsync(id)
 ?? throw new RecordNotFoundError($&quot;Student {id} not found.&quot;);

 _repository.Student.Delete(student);
 await _repository.SaveAsync();
 }

 // ... UpdateAsync, GetAllAsync
}
</code></pre>
The service never touches <code>DbContext</code>. It goes through <code>IRepositoryWrapper</code>, which aggregates every repository behind a single injectable dependency. <code>SaveAsync()</code> is called once after all mutations — that’s the unit of work.
<hr>
<h2>DTOs: the shapes of data</h2>
The Application layer owns all DTOs. Three per entity, as a rule:
<pre><code class="language-csharp">// StudentDto.cs — what the client receives
public class StudentDto
{
 public Guid Id { get; set; }
 public string FullName { get; set; } = string.Empty;
 public string RegistrationNumber { get; set; } = string.Empty;
 public DateOnly DateOfBirth { get; set; }
 public string Status { get; set; } = string.Empty;
}

// CreateStudentDto.cs — what the client sends on POST
public class CreateStudentDto
{
 public string FullName { get; set; } = string.Empty;
 public string RegistrationNumber { get; set; } = string.Empty;
 public DateOnly DateOfBirth { get; set; }
}

// UpdateStudentDto.cs — what the client sends on PUT
public class UpdateStudentDto
{
 public string FullName { get; set; } = string.Empty;
 public DateOnly DateOfBirth { get; set; }
}
</code></pre>
The entity never leaves the Application layer. The client always gets a DTO. AutoMapper handles the translation.
<hr>
<h2>AutoMapper profiles</h2>
Every entity gets its own mapping profile:
<pre><code class="language-csharp">public class StudentMappingProfile : BaseMappingProfile
{
 public StudentMappingProfile()
 {
 CreateMap&lt;Student, StudentDto&gt;();
 CreateMap&lt;CreateStudentDto, Student&gt;();
 CreateMap&lt;UpdateStudentDto, Student&gt;();
 }
}
</code></pre>
<code>BaseMappingProfile</code> is a shared base class in SGAcademy that all profiles extend. AutoMapper is registered once in <code>Application/Extensions/ServiceExtensions.cs</code> and picks up all profiles automatically.
<hr>
<h2>Folder structure for SGAcademy.Application</h2>
Here’s the exact structure I set up today:
<pre><code class="language-csharp">SGAcademy.Application/
├── Contracts/
│ └── Services/
│ ├── IStudentService.cs
│ ├── IStaffService.cs
│ ├── IClassService.cs
│ ├── IAttendanceService.cs
│ └── IEnrollmentService.cs
├── Services/
│ ├── StudentService.cs
│ ├── StaffService.cs
│ ├── ClassService.cs
│ ├── AttendanceService.cs
│ └── EnrollmentService.cs
├── DTOs/
│ ├── Student/
│ │ ├── StudentDto.cs
│ │ ├── CreateStudentDto.cs
│ │ └── UpdateStudentDto.cs
│ ├── Staff/
│ ├── Class/
│ ├── Attendance/
│ └── Enrollment/
├── Mappings/
│ ├── StudentMappingProfile.cs
│ ├── StaffMappingProfile.cs
│ └── ...
└── Extensions/
 └── ServiceExtensions.cs
</code></pre>
One folder per domain area. DTOs grouped by entity. Interfaces and implementations kept separate.
<hr>
<h2>Error handling</h2>
Services throw typed errors from <code>SGAcademy.Shared</code>. The API layer catches and maps them to HTTP responses.
<pre><code class="language-csharp">// 404 — entity not found
throw new RecordNotFoundError($&quot;Student {id} not found.&quot;);

// 409 — conflict (e.g. duplicate registration number)
throw new ConflictError(&quot;A student with this registration number already exists.&quot;);

// 400 — validation failure
throw new ValidationError(&quot;Date of birth cannot be in the future.&quot;);
</code></pre>
No <code>try/catch</code> in services. No HTTP status codes. That’s the API layer’s concern. The service just describes what went wrong.
<hr>
<h2>What I actually built today</h2>
For Day 4 of SGAcademy, I shipped the Application layer for five domain areas:
<ul>
<li><code>StudentService</code> — full CRUD + enrollment status management</li>
<li><code>StaffService</code> — full CRUD with department and designation lookups</li>
<li><code>ClassService</code> — create, update, get by academic year</li>
<li><code>AttendanceService</code> — mark attendance, get by class and date range</li>
<li><code>EnrollmentService</code> — enroll student in class, get class roster</li>
</ul>
All service interfaces registered in <code>ServiceExtensions.cs</code>. All AutoMapper profiles set up. All DTOs defined and mapped.
Zero Entity Framework references in this layer. Zero HTTP concerns. Pure orchestration.
<hr>
<h2>The mistake that kills this pattern</h2>
Making your services too smart.
I’ve seen codebases where services have 500-line methods, nested conditionals, raw SQL strings, and HTTP calls. The service becomes the god object — everything ends up there because “it’s easier.”
The rule: services orchestrate. Domain objects enforce business rules. Repositories handle data access. Keep each layer doing exactly one thing.
When you feel like your service is getting complicated, it’s usually a sign that logic belongs in the domain entity — not in the service.
<hr>
<h2>One principle to take away</h2>
The Application layer is the public API of your backend’s logic. It’s what your controllers talk to. It’s what you’d test first if something broke.
Keep it clean. Keep it thin. Name your methods after what the user is trying to accomplish, not after database operations.
<code>EnrollStudentInClass()</code> — not <code>UpdateStudentRecord()</code>.
The name should tell the story.
<hr>
<h2>Tomorrow</h2>
Day 5: Infrastructure layer — implementing the repositories, wiring up Entity Framework Core configurations, and setting up SQL Server. Where the clean theory meets actual database tables.
<hr>
Learn | Build | Ship — BuildWithRafique <code>&lt;R/&gt;</code>
#buildinpublic #dotnet #cleanarchitecture #devtips #learntocode #webdev #sgacademy

Abdul Rafique

A practical walkthrough of building the Application layer in a .NET Clean Architecture project called SGAcademy. Covers service interfaces and implementations using the IRepositoryWrapper pattern, DTO design (three DTOs per entity), AutoMapper profiles, folder structure, typed error handling, and the principle that services should orchestrate rather than contain business logic. Includes concrete C# code examples for a student enrollment service.

The Application layer is where our use cases live.