Abdullah Hakim Mousa

Role: Full-Stack Developer & System Architect | Live: abdullahhakim.me

Stack: .NET 10, ASP.NET Core Web API, EF Core, PostgreSQL, Redis, MediatR, FluentValidation, JWT Bearer Auth, Swagger/OpenAPI, Docker, GitHub Actions (CI/CD), Python FastAPI.

• Architected production backend using Clean Architecture (Domain → Application → Infrastructure → API) with .NET 10, serving a Next.js 19 frontend via RESTful APIs.
• Implemented JWT Bearer authentication with symmetric security keys and RBAC (AdminOnly authorization policy), integrated with Swagger/OpenAPI Bearer auth flow for secure API documentation.
• Built a request validation pipeline using MediatR behavior pipeline with FluentValidation, enforcing domain rules before command handlers execute.
• Designed PostgreSQL schema with EF Core code-first migrations, assembly-scanned entity configurations (ApplyConfigurationsFromAssembly), and startup auto-migration with structured logging.
• Implemented API rate limiting (Fixed Window, 5 req/min on login endpoints) and global exception handling middleware with ProblemDetails for consistent error responses.
• Integrated Redis distributed caching (StackExchangeRedisCache) for session management and high-performance data retrieval.
• Organized backend into 14+ modular feature domains (Auth, Posts, Comments, Projects, JobApplications, Analytics, etc.) using MediatR handlers for maintainable command/query flows.
• Developed background services for analytics page-view tracking and job application reply monitoring.
• Containerized multi-service ecosystem with Docker Compose (API, Redis, Python JobSpy microservice) and automated CI/CD via GitHub Actions pushing images to GHCR.
• Implemented i18n support via custom CultureMiddleware for dynamic Arabic/English content localization at the database level using translation entities.
• Built storage abstraction layer supporting Azure Blob Storage and local filesystem, switchable via configuration.
• Integrated external APIs (GitHub, Spotify, WakaTime) using IHttpClientFactory for real-time portfolio data and coding metrics.

Role: .NET Backend Developer & System Architect | Team Project | Grade: Excellent

Stack: .NET 8, ASP.NET Core Web API, EF Core, PostgreSQL, Redis, MediatR, FluentValidation, AutoMapper, Hangfire, Serilog, JWT Authentication, Clean Architecture, Generic Repository Pattern.

• Architected and developed two independent backend service modules (Examination Service and Attendance Service) for a unified academic management platform, applying consistent Clean Architecture patterns across both codebases.
• Designed a 5-layer architectural stack for each service: Api → Core → Domain → Infrastructure → Service, ensuring strict dependency direction and testable interface contracts via modular DI registration.
• Implemented CQRS with MediatR across both services, organizing features into explicit Commands and Queries with dedicated handlers, request models, and response DTOs per domain entity.
• Built a validation pipeline using MediatR behavior pipelines with FluentValidation, enforcing domain rules before command handlers execute.
• Configured JWT-based authentication and authorization middleware in both services, securing endpoints with bearer token validation.
• Implemented Generic Repository Pattern (IGenericRepositoryAsync<T>) with EF Core, extended by service-specific repository interfaces for typed data access across Instructors, Students, Quizzes, Questions, Modules, Attendance Sessions, and Attendance Records.
• Designed PostgreSQL schemas with EF Core code-first migrations, including relationship mapping for many-to-many join entities (e.g., StudentQuiz, AttendanceRecord) and enum conversions.
• Integrated Redis distributed caching (StackExchangeRedisCache) in the Exam Service for high-performance session and metadata storage.
• Implemented background job processing using Hangfire in both services, with a dedicated dashboard for job monitoring and scheduled task execution.
• Built structured logging with Serilog across both services, capturing request pipelines and domain events with configurable sinks.
• Developed geolocation-based attendance validation in the Attendance Service via a DistanceSolverService that calculates student-to-location proximity for automated check-in verification.
• Implemented global exception handling middleware (ErrorHandlerMiddleware) with consistent JSON error responses across both services.
• Configured CORS policies and static file serving for cross-origin frontend integration and report asset delivery.
• Designed complete system architecture documentation including Use Case, Class, Sequence, ER, and Data Flow Diagrams for the full platform.

Repositories: Exam Service | Attendance Service

Role: .NET Developer | Type: Technical Assessment

Stack: .NET 8, ASP.NET Core Web API, Clean Architecture, xUnit, Moq, FluentAssertions, Swashbuckle.

• Built a high-performance, stateless API for country-based IP blocking using thread-safe in-memory storage, fulfilling a strict no-database constraint while maintaining data integrity across concurrent requests.
• Implemented Clean Architecture with strict layer separation (Api → Domain → Infrastructure) and dependency inversion via interface contracts.
• Eliminated primitive obsession by designing strongly-typed Value Objects (e.g., CountryCode record with ISO validation rules enforced in the constructor; UserAgent with fallback and length-guard logic).
• Modeled domain entities with encapsulated behavior: BlockedCountry uses private setters and a static factory method Create() to enforce valid state at instantiation.
• Implemented a custom Result<T> and Result pattern across all layers to eliminate exception-driven control flow, producing typed HTTP responses (200, 400, 404, 409, 500) mapped consistently via extension methods.
• Built thread-safe repositories using ConcurrentDictionary (country blocking storage) and ConcurrentQueue (audit logging) enabling concurrent read/write without manual locking.
• Integrated IPGeolocation.io API for real-time IP-to-country lookups using IHttpClientFactory for resilient HTTP client lifecycle management.
• Implemented Sliding Window rate limiting (100 requests/minute per IP) to protect third-party API quotas (1,000 req/day free tier).
• Built global exception handling middleware implementing IExceptionHandler with RFC 7807 ProblemDetails responses for consistent error formatting.
• Developed a comprehensive unit test suite (xUnit, Moq, FluentAssertions) covering block verification flows, thread-safe dictionary behavior, domain value object validation, and edge cases.
• Configured Swagger/OpenAPI with XML doc comments for interactive API documentation and schema discovery.
• Automated build and test pipeline via GitHub Actions with artifact upload for test result traceability.

Role: Backend Developer | Type: Self-Directed Learning Project (10 structured tasks + Application Layer refactoring)

Stack: .NET 10, ASP.NET Core Web API, EF Core, SQL Server, Clean Architecture, FluentValidation, xUnit, Moq, FluentAssertions.

• Built a production-grade e-commerce Web API demonstrating enterprise-level patterns and advanced EF Core features across 10 structured learning tasks with score progression from 3.7 → 10.0.
• Implemented Domain-Driven Design (DDD) with genuine aggregate roots: Order entity encapsulates its own behavior via AddOrderItem(), ConfirmOrder(), CancelOrder(), and ReCalculateTotal() methods, enforcing business invariants internally.
• Designed strict Clean Architecture with 4 layers: Domain → Application → Infrastructure → API, ensuring dependency inversion and testable service contracts via interfaces.
• Implemented automated auditing via a custom EF Core SaveChangesInterceptor that automatically stamps CreatedAt on insert and UpdatedAt on update across all entities inheriting from BaseEntity.
• Built soft deletion using EF Core Global Query Filters (IsDeleted) so removed entities are automatically excluded from all standard queries without manual Where clauses.
• Implemented optimistic concurrency control using RowVersion tokens on all entities to prevent lost updates in concurrent scenarios.
• Optimized read performance using .AsNoTracking() and explicit Select() projections, reducing SQL column count by ~65% (14 columns vs ~40 in full entity loads) while maintaining the same JOIN structure.
• Mastered compiled queries (EF.CompileAsyncQuery) for hot-path endpoints, paying the LINQ-to-SQL translation cost once at startup and skipping expression tree parsing on every subsequent call.
• Implemented bulk operations using ExecuteUpdateAsync and ExecuteDeleteAsync for single-statement category-wide updates and hard deletes, bypassing the change tracker for maximum performance.
• Designed explicit transactions with savepoints: placed a named savepoint ("StockReduced") between critical business operations (order confirmation + stock reduction) and audit trail creation, enabling partial rollback that preserves critical work while discarding recoverable audit records.
• Applied the Result<T> pattern to replace exceptions with structured success/failure states, reducing controller logic from ~150 lines to ~15 lines and enabling clean HTTP-to-service mapping via extension methods.
• Built a validation pipeline using FluentValidation with cross-field rules (e.g., MaxPrice ≥ MinPrice), .When() guards on optional nullable fields, and automatic ASP.NET Core model binding integration.
• Implemented global exception handling middleware registered first in the pipeline to catch unhandled exceptions across routing, auth, and controllers, with special handling for OperationCanceledException (client disconnects) and consistent JSON error responses.