A full-stack blog platform built with ASP.NET Core 8.0 and React.js

It enables users to create, edit, and follow blog posts, interact through comments and likes, and receive real-time notifications powered by SignalR.
The system is built using Clean Architecture principles and follows the CQRS (Command Query Responsibility Segregation) pattern for high scalability and maintainability.

🔗 Live Demo https://marko-blog.vercel.app/

👨‍💻 Admin login:
Username: admin
Password: admin123

👨‍💻 Author login:
Username: emily_s
Password: pass123

✅ Post Management – Create, edit, and delete blog posts with images and categories.
✅ Comments & Likes – Interact with posts and comments in real-time.
✅ Following System – Follow favorite authors and get updates about their activity.
✅ Real-Time Notifications – SignalR provides instant updates on comments, likes, and follows.
✅ JWT + Firebase Authentication – Ensures secure login and role-based access.
✅ Advanced Filtering & Pagination – Find content efficiently by multiple criteria.
✅ Use Case Logging – Every action is logged for transparency and analysis.
✅ Responsive Design – Fully optimized for desktop and mobile devices.
✅ Administrative Dashboard – Manage users, posts, and author requests.

MyBlog follows a multi-layered architecture adhering to Clean Architecture and SOLID principles:

• ASP.NET Core 8.0 – Web API
• C# – Core language
• Entity Framework Core – ORM for SQL Server
• SignalR – Real-time WebSocket communication
• CQRS – Segregated command and query processing
• JWT – Token-based authentication
• Sentry – Error logging and performance tracking

• React.js – Client-side app
• Redux Toolkit – Global state management
• Tailwind CSS & Flowbite React – UI styling
• Fetch API – Communication with backend

The project was originally built using SQL Server, but has since been fully migrated to PostgreSQL to improve portability, deployment compatibility (Railway/Postgres hosting), and development speed.
All Entity Framework configurations and migrations are adjusted accordingly.

• JWT (JSON Web Token) – Handles user authentication and role-based access.
• Firebase – Supports external authentication providers.
• FluentValidation – Validates request data at the application layer.
• Global Exception Handling – Centralized API error management for consistent responses.

• Asynchronous operations – Non-blocking data processing for better performance.
• Pagination & Filtering – Efficiently retrieves only relevant data.
• BulkExtensions – Optimized for large-scale database operations.
• Decoupled services – Easy horizontal scaling and independent deployment.

MyBlog/
├── Domain/           # Core entities and business models
├── EFDataAccess/     # Entity Framework configurations, migrations & DbContext
├── Application/      # CQRS commands & queries, DTOs, validation
├── Implementation/   # Services, repositories, SignalR hub, etc.
├── API/              # ASP.NET Core Web API (Controllers, Middleware, JWT)
└── Client/           # React.js frontend app (Vite)

Install:

• .NET SDK 8.0+
• Node.js 18+
• PostgreSQL: Railway hosted instance or Local PostgreSQL (postgres default user)
• EF Core CLI tool:

dotnet tool install --global dotnet-ef --version 8.0.0

Before running the API, create your local config file: Go to the API/ folder Copy the template file:

appsettings.Development.json.example → appsettings.Development.json

Open the new file and fill in your real values:
PostgreSQL connection string (Railway or local Postgres)
JWT secret key (min 32 chars)
Optional SMTP config
This file is NOT tracked by Git and must be created manually.

🔐 JWT Example

"JWT": {
    "Issuer": "http://localhost:5000",
    "Audience": "BlogClient",
    "SecretKey": "your-dev-secret-key-min-32-chars",
    "TokenExpiryMinutes": 120
},

✉ SMTP Example

"SMTP": {
    "SenderEmail": "noreply@yourdomain.com",
    "Host": "smtp.yourdomain.com",
    "Port": 587,
    "Username": "noreply@yourdomain.com",
    "Password": "your-smtp-password"
}

API uses PostgreSQL connection from appsettings.Development.json.
✔ Railway example:

"ConnectionStrings": {
  "DefaultConnection": "Host=YOUR_HOST;Port=YOUR_PORT;Database=railway;Username=postgres;Password=YOUR_PASSWORD;SSL Mode=Require;Trust Server Certificate=true"
}

✔ Local PostgreSQL example:

"ConnectionStrings": {
  "DefaultConnection": "Host=localhost;Port=5432;Database=blog;Username=postgres;Password=yourpassword"
}

📦 Required NuGet package:

dotnet add package Npgsql.EntityFrameworkCore.PostgreSQL

Start migrations:

cd API
dotnet ef database update --project ../EFDataAccess --startup-project .

This creates the blog database automatically.

Seeder will automatically start when you run API.

cd API
dotnet run

If the database is empty, initial data will be inserted.

cd Api
dotnet restore
dotnet run

Backend URL: http://localhost:5000 Swagger: http://localhost:5000/swagger

In folder Client/ create .env
It must be next to vite.config.js.

🔥 Firebase

VITE_FIREBASE_API_KEY=AIzaSyBp3oi6SrSoQ8G3jrgzZKye4KSmrLCae7k
VITE_FIREBASE_AUTH_DOMAIN=blog-a6b98.firebaseapp.com
VITE_FIREBASE_PROJECT_ID=blog-a6b98
VITE_FIREBASE_STORAGE_BUCKET=blog-a6b98.appspot.com
VITE_FIREBASE_MESSAGING_SENDER_ID=311198757906
VITE_FIREBASE_APP_ID=1:311198757906:web:3023a83a49eeb68fa494cb
VITE_FIREBASE_MEASUREMENT_ID=G-TJWVQ5W4KH

🔗 API URL:

VITE_API_URL=http://localhost:5000/api

cd Client
npm install
npm run dev

Frontend runs at: http://localhost:5173

This project is the most important to me because it demonstrates the complete set of knowledge I have acquired:

• Real-time communication (SignalR)
• Clean Architecture + CQRS
• JWT and Firebase combined authentication
• Database migration (SQL Server → PostgreSQL)
• Full-stack development (C#, EF Core, React, Redux)
• Deployment to Vercel / Railway