The Vision

The Hakim Project is not just a blog; it’s a living laboratory for modern engineering. Built to solve real-world problems—like the friction of job applications and the difficulty of technical knowledge management—it demonstrates how AI can be integrated into a robust, production-grade ecosystem.

The Homepage Ecosystem

The central hub, featuring live activity feeds, automated metrics, and a premium dark-mode aesthetic.

The Content Engine

The public-facing side of the platform is designed for maximum engagement and clarity.

1. The Blog Engine

A high-performance writing platform that supports:

- Rich Media: Automated image processing and Azure Blob storage.

- Engagement Metrics: Real-time view counts, likes, and reading-time estimations.

- Social Interaction: A full comment and reply system powered by our dual-identity model.

Technical Blog Post

A look at the technical layout: Clean typography, reading time indicators, and social engagement tools.

2. Projects Showcase

A curated portfolio where every project is more than just a link.

- Technical Context: Each project highlights the tech stack and the "Why" behind the build.

- Knowledge Integration: Every project is tagged and automatically linked into the Knowledge Universe.

Projects Grid

The Projects section: A visual testament to continuous building and learning.

3. Guestbook & Social Proof

A space for visitors to leave their mark.

- Admin Curation: The ability to "pin" high-value messages for social proof.

- Seamless Auth: Powered by Better-Auth for a frictionless user experience.

Guestbook Page

The Guestbook: Demonstrating social engagement and real-time community interaction.

Core Architecture

the architecture overview

The backend is built using Clean Architecture (Domain-Driven Design) in .NET 8, ensuring that the business logic remains pure and decoupled from external frameworks.

MediatR & Validation Behaviors

We use the CQRS pattern with MediatR. To ensure data integrity, we implemented MediatR Behaviors that automatically validate every request using FluentValidation before it even reaches the handler.

// Professional Request Validation Middleware
public class ValidationBehavior<TRequest, TResponse>(IEnumerable<IValidator<TRequest>> validators) 
    : IPipelineBehavior<TRequest, TResponse>
{
    public async Task<TResponse> Handle(TRequest request, RequestHandlerDelegate<TResponse> next, CancellationToken ct)
    {
        var context = new ValidationContext<TRequest>(request);
        var failures = validators
            .Select(v => v.Validate(context))
            .SelectMany(result => result.Errors)
            .Where(f => f != null).ToList();
        if (failures.Count != 0) throw new ValidationException(failures);
        return await next();
    }

}

Dual-Identity Security Architecture

We implemented a tiered authentication model to balance strict administrative security with smooth social engagement.

* Administrative Layer (JWT): Secure, stateless authentication for the backend API and Admin Panel.

* Engagement Layer (Better-Auth): A modern, social-first authentication system for the blog frontend. This allows users to engage with Comments, Likes, and the Guestbook using GitHub or Google, with sessions automatically synced to our PostgreSQL database.

The AI Engine: Groq, Jina, & JSON Patch

This is the "Brain" of the project. We moved beyond simple AI prompts to a Deterministic Engineering Pipeline.

1. High-Speed Inference (Groq)

We utilize Groq (LPU Technology) with the llama-3.3-70b-versatile model. This provides near-instant response times (sub-second inference) for complex resume tailoring tasks.

2. Intelligent Scraping (Jina AI)

The Jina Scraper Service handles the heavy lifting of bot detection and JavaScript rendering, delivering clean plain-text to the LLM.

3. Deterministic Patching

Instead of letting the AI rewrite the whole file, it generates a TailoringPlan. Our service then uses JSON Patch to surgically update specific IDs in the Master CV.

// Slicing the Master CV for LLM Context

private static (string ResumeDataStr, ResumeContext Context) ExtractContextAndData(string masterCvJson)
{
    // Extracting ONLY relevant section IDs to keep context window tight
    var context = new ResumeContext();
    if (masterRoot.TryGetProperty("experience", out var exp)) {
                foreach (var item in exp.EnumerateArray()) context.ExperienceIds.Add(item.GetProperty("id").GetString()!);  
    }
// Logic ensures we stay within a compact 6000-char context window for maximum accuracy
}

The Command Center: Kanban & IMAP Tracking

The admin panel features a custom Kanban Job Board that serves as the nerve center for professional activity.

* Auto-Apply One-Click: Scrapes the URL, tailors the resume, and sends the email in ~5 seconds.

* Automatic Follow-ups (IMAP): A background service polls Gmail via IMAP, identifies replies to specific MessageIds, and uses heuristics to transition job statuses.

// Automatic Status Transition Heuristics (Background Service)
if (emailBody.Contains("interview") || emailBody.Contains("schedule")) {

    job.UpdateStatus(JobApplicationStatus.Interviewing);

} else if (emailBody.Contains("regret") || emailBody.Contains("not moving forward")) {
    job.UpdateStatus(JobApplicationStatus.Rejected);
}

Knowledge Universe

To showcase technical breadth, I built an interactive, Obsidian-style graph.

Knowledge Universe Graph

The Universe: Visualizing the interconnected nature of articles, projects, and skills.

The Connected Ecosystem

* WakaTime: Live coding statistics streamed from the IDE to the blog.

* GitHub Service: Real-time contribution tracking and latest project updates.

* Spotify Integration: Displays "Currently Listening" status to humanize the digital presence.

* Azure Blob Storage: Professional asset management for production media.

Live Spotify Status: Bridging the gap between code and personality.

Developer Excellence (DX)

* Performance: Custom ETag Middleware provides automatic 304 caching, ensuring sub-100ms loads.

* Localization: Full i18n support for English and Arabic (RTL), handled dynamically at the API level.

* Quality: Backed by a comprehensive test suite using xUnit, Moq, and FluentAssertions.

[Fact]
public async Task Should_Update_Job_Status_When_Reply_Is_Interview_Request()
{
    // Arrange: Mocking a recruiter reply
    var reply = "We would like to schedule an interview...";
    // Act: Running the heuristic classifier
    var status = _classifier.Classify(reply);
    // Assert: Ensuring deterministic state transition
    status.Should().Be(JobApplicationStatus.Interviewing);
}

Infrastructure & DevOps

The entire ecosystem is designed for stability and scale:

* Docker: Multi-stage builds for optimized container sizes and security.

* Nginx: Reverse proxy with SSL termination and optimized header handling.

* Azure: Production hosting on a high-availability cloud environment.

* PostgreSQL: A shared database instance handling both EF Core (Domain) and Better-Auth (Social) schemas.