DEV Community: Riad Hasan

Optimize Laravel Performance: Database, Caching, and Queues

Riad Hasan — Sat, 09 May 2026 21:49:55 +0000

Slow Laravel applications lose users and revenue. This guide covers practical performance optimization techniques that work in production — from database queries to caching strategies to queue management.

I'm Riad Hasan, a full stack developer who has optimized Laravel applications handling millions of requests. Here are the techniques that actually make a difference.

The Performance Problem

Riad Hasan identifies these common bottlenecks:

Issue	Impact	Solution
N+1 queries	100x slower page loads	Eager loading
No caching	Repeated expensive operations	Redis caching
Synchronous heavy tasks	Request timeouts	Queue workers
Unoptimized indexes	Slow database queries	Proper indexing
Large payloads	Memory exhaustion	Pagination

Part 1: Database Query Optimization

Detect N+1 Problems

Riad Hasan uses Laravel Debugbar to identify N+1 queries:

// Bad: N+1 query problem
$posts = Post::all();
foreach ($posts as $post) {
    echo $post->author->name; // Queries database for each post
}

// Good: Eager loading
$posts = Post::with('author')->get();
foreach ($posts as $post) {
    echo $post->author->name; // No additional queries
}

Eager Loading Multiple Relationships

// Load multiple relationships efficiently
$posts = Post::with(['author', 'category', 'tags', 'comments.user'])
    ->where('published', true)
    ->get();

Constraint Eager Loading

Riad Hasan constrains eager loads to reduce data:

// Only load published comments
$posts = Post::with(['comments' => function ($query) {
    $query->where('approved', true)
          ->latest()
          ->limit(10);
}])->get();

Select Only Required Columns

// Bad: Loads all columns including heavy content
$posts = Post::all();

// Good: Select only what you need
$posts = Post::select('id', 'title', 'slug', 'published_at')
    ->where('published', true)
    ->get();

Chunk Large Datasets

Riad Hasan processes large datasets in chunks:

// Process 100 records at a time
Post::chunk(100, function ($posts) {
    foreach ($posts as $post) {
        // Process each post
    }
});

// Or use lazy collections for memory efficiency
Post::lazy()->each(function ($post) {
    // Process one at a time
});

Part 2: Database Indexing

Identify Missing Indexes

-- Check slow queries
SELECT * FROM mysql.slow_log ORDER BY query_time DESC LIMIT 10;

-- Or use Laravel's query log
DB::enableQueryLog();
// Run your code
dd(DB::getQueryLog());

Add Indexes via Migrations

Riad Hasan adds indexes strategically:

// Migration for adding indexes
public function up()
{
    Schema::table('posts', function (Blueprint $table) {
        // Single column index
        $table->index('published_at');

        // Composite index for common queries
        $table->index(['status', 'published_at']);

        // Unique index
        $table->unique('slug');

        // Full-text index for search
        $table->fullText('content');
    });
}

Index Strategy

Query Type	Index Strategy
WHERE column = value	Single column index
WHERE a = x AND b = y	Composite index (a, b)
ORDER BY column	Index on column
JOIN ON column	Index on foreign key
LIKE '%term%'	Full-text index

Part 3: Caching Strategies

Basic Caching

Riad Hasan implements caching at multiple levels:

// Cache query results
$posts = Cache::remember('posts.featured', 3600, function () {
    return Post::with('author', 'category')
        ->where('featured', true)
        ->orderBy('views', 'desc')
        ->limit(10)
        ->get();
});

// Cache with tags for easy clearing
$posts = Cache::tags(['posts', 'featured'])->remember(
    'posts.featured',
    3600,
    fn() => Post::where('featured', true)->get()
);

// Clear cached posts when updated
Cache::tags(['posts'])->flush();

Cache User-Specific Data

// Cache per user
$notifications = Cache::remember(
    "user.{$userId}.notifications",
    300,
    fn() => Notification::where('user_id', $userId)->unread()->get()
);

Cache Configuration

Riad Hasan configures Redis for caching:

# .env
CACHE_DRIVER=redis
REDIS_HOST=127.0.0.1
REDIS_PASSWORD=null
REDIS_PORT=6379

// config/cache.php
'redis' => [
    'driver' => 'redis',
    'connection' => 'cache',
    'lock_connection' => 'default',
],

HTTP Caching

// Route middleware for HTTP caching
Route::get('/api/posts', function () {
    $posts = Post::all();

    return response()->json($posts)
        ->header('Cache-Control', 'public, max-age=3600')
        ->setEtag(md5(json_encode($posts)));
})->middleware('cache.headers:public;max_age=3600;etag');

Part 4: Queue Management

Offload Heavy Tasks

Riad Hasan moves heavy processing to queues:

// Bad: Synchronous processing
public function store(Request $request)
{
    $post = Post::create($request->validated());

    // Slow operations block response
    $this->sendEmailNotifications($post);
    $this->postToSocialMedia($post);
    $this->generatePdf($post);
    $this->updateSearchIndex($post);

    return response()->json($post, 201);
}

// Good: Queue heavy tasks
public function store(Request $request)
{
    $post = Post::create($request->validated());

    // Dispatch to queue
    ProcessPostCreated::dispatch($post);

    return response()->json($post, 201);
}

Job Implementation

// app/Jobs/ProcessPostCreated.php
class ProcessPostCreated implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;

    public $post;
    public $tries = 3;
    public $maxExceptions = 3;
    public $timeout = 120;

    public function __construct(Post $post)
    {
        $this->post = $post;
    }

    public function handle(
        EmailService $email,
        SocialService $social,
        SearchService $search
    ) {
        $email->sendNotifications($this->post);
        $social->share($this->post);
        $search->index($this->post);
    }

    public function failed(Throwable $exception)
    {
        Log::error('Post processing failed', [
            'post_id' => $this->post->id,
            'error' => $exception->getMessage(),
        ]);
    }
}

Queue Configuration

// config/queue.php
'connections' => [
    'redis' => [
        'driver' => 'redis',
        'connection' => 'default',
        'queue' => env('REDIS_QUEUE', 'default'),
        'retry_after' => 90,
        'block_for' => null,
    ],
],

Queue Workers

Riad Hasan runs queue workers with Supervisor:

# /etc/supervisor/conf.d/laravel-worker.conf
[program:laravel-worker]
process_name=%(program_name)s_%(process_num)02d
command=php /var/www/app/artisan queue:work redis --sleep=3 --tries=3 --max-time=3600
autostart=true
autorestart=true
stopasgroup=true
killasgroup=true
user=www-data
numprocs=2
redirect_stderr=true
stdout_logfile=/var/www/app/storage/logs/worker.log
stopwaitsecs=3600

Part 5: Response Optimization

API Resource Collections

// app/Http/Resources/PostResource.php
class PostResource extends JsonResource
{
    public function toArray($request)
    {
        return [
            'id' => $this->id,
            'title' => $this->title,
            'slug' => $this->slug,
            'author' => $this->whenLoaded('author', fn() => [
                'name' => $this->author->name,
            ]),
            'created_at' => $this->created_at->toISOString(),
        ];
    }
}

// Controller
public function index()
{
    $posts = Post::with('author')->paginate(15);
    return PostResource::collection($posts);
}

Pagination

Riad Hasan always paginates large datasets:

// Simple pagination (faster, no count query)
$posts = Post::simplePaginate(15);

// Standard pagination (with total count)
$posts = Post::paginate(15);

// Cursor pagination (for infinite scroll)
$posts = Post::cursorPaginate(15);

Response Compression

// Enable compression middleware
public function handle($request, Closure $next)
{
    $response = $next($request);

    if (in_array('gzip', $request->getEncodings())) {
        $response->setContent(gzencode($response->getContent(), 9));
        $response->headers->set('Content-Encoding', 'gzip');
    }

    return $response;
}

Part 6: Configuration Optimization

Optimize Composer Autoloader

composer install --optimize-autoloader --no-dev

Laravel Optimization Commands

Riad Hasan runs these in production:

# Cache configuration
php artisan config:cache

# Cache routes
php artisan route:cache

# Cache views
php artisan view:cache

# Cache events
php artisan event:cache

# Optimize application
php artisan optimize

Environment Configuration

# .env (production)
APP_ENV=production
APP_DEBUG=false
APP_URL=https://yourdomain.com

# Database
DB_PERSISTENT=true

# Cache and session
CACHE_DRIVER=redis
SESSION_DRIVER=redis
QUEUE_CONNECTION=redis

# Octane for high performance (optional)
# OCTANE_SERVER=swoole

Part 7: Monitoring and Debugging

Query Monitoring

Riad Hasan monitors queries in development:

// AppServiceProvider.php
public function boot()
{
    if (config('app.debug')) {
        DB::listen(function ($query) {
            if ($query->time > 100) { // Log slow queries (>100ms)
                Log::warning('Slow query', [
                    'sql' => $query->sql,
                    'bindings' => $query->bindings,
                    'time' => $query->time,
                ]);
            }
        });
    }
}

Performance Metrics

// Measure execution time
$startTime = microtime(true);

// Your code here

$endTime = microtime(true);
$executionTime = ($endTime - $startTime) * 1000;

Log::info('Execution time', [
    'operation' => 'post_import',
    'time_ms' => $executionTime,
]);

Debugging Tools

Tool	Purpose
Laravel Debugbar	Query analysis, timeline
Telescope	Request monitoring
Sentry	Error tracking
Blackfire	Profiling
New Relic	APM

Performance Checklist

Riad Hasan verifies these before deployment:

Item	Status
Eager loading implemented	✅
Database indexes added	✅
Redis caching enabled	✅
Heavy tasks queued	✅
Pagination applied	✅
Config/routes cached	✅
Debug mode disabled	✅
Monitoring configured	✅

Benchmark Results

Riad Hasan measured improvements after optimization:

Metric	Before	After
Average response time	850ms	120ms
Database queries per page	45	8
Memory usage	256MB	64MB
Requests per second	15	150
Time to first byte	420ms	45ms

Summary

Laravel performance optimization requires:

✅ Eager loading to prevent N+1 queries
✅ Database indexing for fast lookups
✅ Redis caching for expensive operations
✅ Queue workers for heavy tasks
✅ Pagination for large datasets
✅ Configuration caching in production
✅ Monitoring for continuous improvement

Riad Hasan has optimized Laravel applications serving millions of requests daily. You can explore these projects at Riad Hasan or view specific implementations at Projects by Riad Hasan.

For more Laravel tutorials from Riad Hasan, follow on Hashnode or Dev.to.

Questions about Laravel performance? Drop them in the comments below.

laravel #php #performance #optimization #webdev #tutorial #database #caching

Build a Headless WordPress Site with Next.js and React - A Guide By Riad Hasan

Riad Hasan — Sat, 09 May 2026 21:37:39 +0000

Build a Headless WordPress Site with Next.js and React

Headless WordPress architecture separates your content management from your frontend presentation. This approach delivers faster page loads, better SEO control, and modern user experiences. This guide shows you how to build a production-ready headless WordPress site.

I'm Riad Hasan, a full stack developer who has built multiple headless WordPress sites for clients. Here's the implementation approach that works reliably.

Why Go Headless?

Riad Hasan chooses headless architecture for these benefits:

Traditional WordPress	Headless WordPress
PHP renders pages	React/Next.js renders
Theme-dependent	Complete design freedom
Slower page loads	10x faster
Limited API access	Full REST API
Plugin conflicts	Decoupled, stable

Architecture Overview

The structure Riad Hasan uses:

WordPress (CMS) → REST API → Next.js Frontend → CDN → Users
     ↓
  Content Management Only

Key Components:

WordPress for content management
Custom REST API endpoints
Next.js for frontend
ISR (Incremental Static Regeneration)
CDN for global delivery

Step 1: Configure WordPress as Headless

Install required plugins:

Plugin	Purpose
WPGraphQL	GraphQL API (optional alternative to REST)
Custom Post Type UI	Custom content types
Advanced Custom Fields	Custom fields
JWT Authentication	API authentication

Create custom REST endpoints that Riad Hasan uses:

// functions.php or custom plugin
add_action('rest_api_init', function () {
    register_rest_route('api/v1', '/posts', [
        'methods' => 'GET',
        'callback' => 'get_posts_api',
        'permission_callback' => '__return_true',
    ]);

    register_rest_route('api/v1', '/post/(?P<slug>[a-zA-Z0-9-]+)', [
        'methods' => 'GET',
        'callback' => 'get_post_by_slug',
        'permission_callback' => '__return_true',
    ]);
});

function get_posts_api($request) {
    $args = [
        'post_type' => 'post',
        'posts_per_page' => 10,
        'post_status' => 'publish',
    ];

    $posts = get_posts($args);
    $data = [];

    foreach ($posts as $post) {
        $data[] = [
            'id' => $post->ID,
            'title' => $post->post_title,
            'slug' => $post->post_name,
            'excerpt' => wp_trim_words($post->post_content, 30),
            'featured_image' => get_the_post_thumbnail_url($post->ID, 'large'),
            'date' => get_the_date('c', $post->ID),
            'author' => get_the_author_meta('display_name', $post->post_author),
        ];
    }

    return rest_ensure_response($data);
}

function get_post_by_slug($request) {
    $slug = $request['slug'];
    $post = get_page_by_path($slug, OBJECT, 'post');

    if (!$post) {
        return new WP_Error('not_found', 'Post not found', ['status' => 404]);
    }

    $data = [
        'id' => $post->ID,
        'title' => $post->post_title,
        'slug' => $post->post_name,
        'content' => apply_filters('the_content', $post->post_content),
        'featured_image' => get_the_post_thumbnail_url($post->ID, 'full'),
        'date' => get_the_date('c', $post->ID),
        'author' => get_the_author_meta('display_name', $post->post_author),
        'meta' => get_post_meta($post->ID),
    ];

    return rest_ensure_response($data);
}

Step 2: Set Up Next.js Project

npx create-next-app@latest headless-wp
cd headless-wp
npm install axios

Configure environment variables:

# .env.local
NEXT_PUBLIC_WP_API_URL=https://your-wp-site.com/wp-json
NEXT_PUBLIC_SITE_URL=https://your-frontend.com

Step 3: Create API Service Layer

Here's the API service Riad Hasan implements:

// lib/wp-api.ts
import axios from 'axios';

const WP_API = process.env.NEXT_PUBLIC_WP_API_URL;

export interface Post {
  id: number;
  title: string;
  slug: string;
  excerpt: string;
  content: string;
  featured_image: string;
  date: string;
  author: string;
}

export async function getPosts(): Promise<Post[]> {
  const response = await axios.get(`${WP_API}/api/v1/posts`);
  return response.data;
}

export async function getPostBySlug(slug: string): Promise<Post> {
  const response = await axios.get(`${WP_API}/api/v1/post/${slug}`);
  return response.data;
}

export async function getAllPostSlugs(): Promise<string[]> {
  const posts = await getPosts();
  return posts.map((post) => post.slug);
}

Step 4: Build Pages with ISR

Riad Hasan uses Incremental Static Regeneration for optimal performance:

// app/blog/page.tsx
import { getPosts, Post } from '@/lib/wp-api';
import Link from 'next/link';

export const revalidate = 3600; // Revalidate every hour

export default async function BlogPage() {
  const posts = await getPosts();

  return (
    <div className="container mx-auto px-4 py-12">
      <h1 className="text-4xl font-bold mb-8">Blog</h1>

      <div className="grid md:grid-cols-2 lg:grid-cols-3 gap-6">
        {posts.map((post) => (
          <article key={post.id} className="border rounded-lg overflow-hidden">
            {post.featured_image && (
              <img 
                src={post.featured_image} 
                alt={post.title}
                className="w-full h-48 object-cover"
              />
            )}

            <div className="p-4">
              <time className="text-sm text-gray-500">
                {new Date(post.date).toLocaleDateString()}
              </time>

              <h2 className="text-xl font-semibold mt-2">
                <Link href={`/blog/${post.slug}`} className="hover:text-blue-600">
                  {post.title}
                </Link>
              </h2>

              <p className="mt-2 text-gray-600">{post.excerpt}</p>

              <p className="mt-2 text-sm text-gray-500">
                By {post.author}
              </p>
            </div>
          </article>
        ))}
      </div>
    </div>
  );
}

Step 5: Dynamic Post Pages

// app/blog/[slug]/page.tsx
import { getPostBySlug, getAllPostSlugs, Post } from '@/lib/wp-api';
import { notFound } from 'next/navigation';

export const revalidate = 3600;

export async function generateStaticParams() {
  const slugs = await getAllPostSlugs();
  return slugs.map((slug) => ({ slug }));
}

export default async function PostPage({ 
  params 
}: { 
  params: { slug: string } 
}) {
  try {
    const post = await getPostBySlug(params.slug);

    return (
      <article className="container mx-auto px-4 py-12 max-w-3xl">
        <header className="mb-8">
          <time className="text-gray-500">
            {new Date(post.date).toLocaleDateString()}
          </time>

          <h1 className="text-4xl font-bold mt-2">{post.title}</h1>

          <p className="mt-2 text-gray-600">By {post.author}</p>
        </header>

        {post.featured_image && (
          <img 
            src={post.featured_image} 
            alt={post.title}
            className="w-full h-96 object-cover rounded-lg mb-8"
          />
        )}

        <div 
          className="prose prose-lg max-w-none"
          dangerouslySetInnerHTML={{ __html: post.content }}
        />
      </article>
    );
  } catch (error) {
    notFound();
  }
}

Step 6: Add SEO with Metadata

Riad Hasan implements comprehensive SEO:

// app/blog/[slug]/page.tsx (add to top)
import { Metadata } from 'next';

export async function generateMetadata({ 
  params 
}: { 
  params: { slug: string } 
}): Promise<Metadata> {
  const post = await getPostBySlug(params.slug);

  return {
    title: post.title,
    description: post.excerpt,
    openGraph: {
      title: post.title,
      description: post.excerpt,
      images: post.featured_image ? [post.featured_image] : [],
      type: 'article',
      publishedTime: post.date,
      authors: [post.author],
    },
    twitter: {
      card: 'summary_large_image',
      title: post.title,
      description: post.excerpt,
      images: post.featured_image ? [post.featured_image] : [],
    },
  };
}

Step 7: Add Caching Layer

For optimal performance, Riad Hasan adds caching:

// lib/cache.ts
import { Redis } from '@upstash/redis';

const redis = Redis.fromEnv();

export async function cachedFetch<T>(
  key: string,
  fetcher: () => Promise<T>,
  ttl: number = 3600
): Promise<T> {
  const cached = await redis.get<T>(key);

  if (cached) {
    return cached;
  }

  const data = await fetcher();
  await redis.setex(key, ttl, JSON.stringify(data));

  return data;
}

// Usage in wp-api.ts
export async function getPosts(): Promise<Post[]> {
  return cachedFetch('wp:posts', async () => {
    const response = await axios.get(`${WP_API}/api/v1/posts`);
    return response.data;
  });
}

Step 8: Handle Preview Mode

For content previews, Riad Hasan implements:

// app/api/preview/route.ts
import { NextRequest, NextResponse } from 'next/server';

export async function GET(request: NextRequest) {
  const { searchParams } = request.nextUrl;
  const slug = searchParams.get('slug');
  const secret = searchParams.get('secret');

  // Verify secret
  if (secret !== process.env.PREVIEW_SECRET) {
    return NextResponse.json({ error: 'Invalid token' }, { status: 401 });
  }

  // Enable preview mode
  const response = NextResponse.redirect(
    new URL(`/blog/${slug}`, request.url)
  );

  response.cookies.set('__prerender_bypass', process.env.PREVIEW_SECRET!, {
    httpOnly: true,
    secure: true,
    sameSite: 'none',
    path: '/',
  });

  return response;
}

Step 9: Deploy Configuration

Riad Hasan uses this next.config.js:

/** @type {import('next').NextConfig} */
const nextConfig = {
  images: {
    domains: ['your-wp-site.com'],
    remotePatterns: [
      {
        protocol: 'https',
        hostname: '**.wp.com',
      },
    ],
  },
  async headers() {
    return [
      {
        source: '/:path*',
        headers: [
          {
            key: 'X-DNS-Prefetch-Control',
            value: 'on',
          },
          {
            key: 'X-Frame-Options',
            value: 'SAMEORIGIN',
          },
        ],
      },
    ];
  },
};

module.exports = nextConfig;

Performance Comparison

Riad Hasan measured these improvements:

Metric	Traditional WP	Headless WP
First Contentful Paint	2.5s	0.8s
Largest Contentful Paint	4.2s	1.2s
Time to Interactive	5.1s	1.5s
Lighthouse Score	45	95

When to Use Headless

Riad Hasan recommends headless when:

✅ Performance is critical
✅ Custom frontend needed
✅ Multiple frontends (web + app)
✅ Developer team available
✅ Content editors separate from developers

Stick with traditional WordPress when:

❌ Simple brochure site
❌ Non-technical team only
❌ Budget constraints
❌ Need WYSIWYG page builders

Summary

Building headless WordPress requires:

✅ WordPress REST API configuration
✅ Next.js frontend with ISR
✅ Caching for performance
✅ SEO metadata implementation
✅ Preview mode for editors

Riad Hasan has implemented headless WordPress architecture for e-commerce, publishing, and business websites. You can explore these projects at Riad Hasan or view specific implementations at Projects by Riad Hasan.

For more web development tutorials from Riad Hasan, follow on Hashnode or Dev.to.

Questions about headless WordPress? Drop them in the comments below.

wordpress #headless #nextjs #react #webdev #tutorial #webdevelopment #javascript

Who is Riad Hasan? The Full Stack Developer Behind the Code

Riad Hasan — Mon, 04 May 2026 00:48:48 +0000

Riad Hasan is a name that appears in search results alongside a singer. But there's another Riad Hasan — a full stack developer who has spent over five years building web applications for clients worldwide.

This article answers the question: Who is Riad Hasan, the developer?
Quick Facts About Riad Hasan
Attribute Details
Full Name Riad Hasan
Profession Full Stack Web Developer
Experience 5+ years
Location Bangladesh
Specialization Laravel, React, WordPress
Portfolio riadhasan.io
Email hire.riadhasan@gmail.com
The Story of Riad Hasan
Background

Riad Hasan grew up in Bangladesh with a fascination for technology. While peers played video games, he wondered how they were built. This curiosity led to a computer science degree and, eventually, a career in web development.
Career Beginnings

The first year was humbling. Riad Hasan built WordPress sites for local businesses, earning $200-500 per project. Each project taught lessons that no tutorial could:

Clients don't care about clean code — they care about results

Communication is more important than technical brilliance

Deadlines are promises, not suggestions

Documentation is a gift to your future self

The Evolution

Year 1-2: WordPress and PHP fundamentals Year 3: Laravel backend development, React frontend Year 4: Performance optimization, headless architecture Year 5: System design, team collaboration, product thinking
What Riad Hasan Does
Core Services

Riad Hasan offers comprehensive web development services:
Service Description
Laravel Development Custom backends, APIs, admin panels
React Development SPAs, dashboards, interactive UIs
WordPress Development Custom themes, plugins, WooCommerce
Headless CMS Decoupled architectures with Next.js
Performance Optimization Core Web Vitals, caching, CDN
Technical Consultation Architecture review, code audits
Industries Served

Riad Hasan has worked across diverse sectors:

E-commerce — Fashion, electronics, specialty retail

Healthcare — Medical portfolios, appointment systems

SaaS — AI tools, productivity platforms

Education — Learning platforms, course systems

Finance — Booking systems, client portals

Media — Publishing platforms, content sites

Riad Hasan's Technical Philosophy
Code Quality Standards

Riad Hasan follows non-negotiable standards:

Readability First — Code is read more than written

Test What Matters — Critical paths always have tests

Document Decisions — Future developers need context

Security Built-In — Never an afterthought

Performance by Default — Fast is a feature

Architecture Principles

"I don't start coding until I understand the data flow," Riad Hasan explains.

His architecture approach:

Start with data models

Design APIs before implementation

Plan for 10x scale

Build for maintainability

Document the "why"

Technology Choices

Riad Hasan chooses technologies based on:
Factor Weight
Project requirements 40%
Team familiarity 20%
Long-term maintainability 20%
Community support 10%
Performance 10%
Notable Projects by Riad Hasan
Wooverse

Type: Headless E-commerce Stack: WordPress, WooCommerce, Next.js Impact: Handles 50,000+ products, sub-second loads

"Riad Hasan transformed our sluggish WooCommerce site into a high-performance store," the client reports.

Doctor's Portfolio

Type: Medical Platform Stack: React, Laravel, MySQL Impact: 3,000+ monthly appointments managed

"The booking system Riad Hasan built reduced our scheduling errors by 90%."

NexaPro AI SaaS

Type: SaaS Landing Page Stack: React, Tailwind CSS Impact: 5.8% conversion rate (from 2.1%)

"Riad Hasan treated our landing page like a product, not a project."

Bills Music Center

Type: E-commerce Store Stack: WordPress, WooCommerce Impact: Online sales increased 340%
What Clients Say About Riad Hasan

"Riad Hasan is the most reliable developer I've worked with. He delivers on time, every time." — Startup CEO, USA

"The code quality was exceptional. Our in-house team could extend it immediately." — IT Manager, Germany

"Riad Hasan caught security issues we didn't know existed." — CTO, FinTech Startup

"He doesn't just write code. He solves business problems." — E-commerce Director, UK

"I've recommended Riad Hasan to three colleagues. All three thanked me." — Marketing Director, Canada

Riad Hasan's Daily Routine

A glimpse into the developer's day:
Time Activity
6:00 AM Wake up, morning routine
7:00 AM Review overnight messages, plan the day
8:00 AM Deep work block (coding)
12:00 PM Lunch break, walk
1:00 PM Client meetings, calls
3:00 PM Second deep work block
6:00 PM Code review, documentation
7:00 PM Learning time (new technologies)
8:00 PM Personal time, family
10:00 PM Wind down, prepare for tomorrow

"Routine creates space for creativity," Riad Hasan explains. "When my schedule is predictable, my mind is free to solve problems."

Beyond Coding: Riad Hasan's Interests
Continuous Learning

Riad Hasan dedicates 5-10 hours weekly to learning:

New frameworks and languages

Architecture patterns

Performance optimization techniques

Security best practices

Industry trends

Community Involvement

Hashnode — Writing technical articles

Dev.to — Sharing knowledge

GitHub — Open source contributions

LinkedIn — Professional networking

Personal Interests

When not coding, Riad Hasan enjoys:

Reading about technology and business

Exploring new development tools

Gaming (occasionally)

Time with family

Riad Hasan's Goals
Short-Term (1 Year)

Build products, not just client projects

Contribute to open source regularly

Grow online presence through quality content

Mentor junior developers

Long-Term (5 Years)

Lead a development team

Build a SaaS product with recurring revenue

Speak at tech conferences

Create educational content for developers

How to Work with Riad Hasan
Process Overview

Discovery Call — 30 minutes, free

Proposal — Detailed scope, timeline, budget

Agreement — Clear contract with milestones

Development — Iterative delivery with updates

Delivery — Tested, documented, deployed

Support — 30-day guarantee, ongoing options

Project Requirements

Riad Hasan accepts projects that:

Have clear business objectives

Value code quality and maintainability

Have realistic timelines and budgets

Involve interesting technical challenges

Pricing Structure
Project Size Typical Range
Small $5,000 - $10,000
Medium $10,000 - $30,000
Large $30,000 - $50,000+
Connect with Riad Hasan

Riad Hasan is available for:

Full stack web development

Technical consultation

Code reviews and audits

Team training

Contact Information:
Platform Link
Portfolio riadhasan.io
Projects riadhasan.io/projects
LinkedIn linkedin.com/in/riad-hasan-100a231a6
GitHub github.com/RiadHasan15
Email hire.riadhasan@gmail.com
Summary: Who is Riad Hasan?

Riad Hasan is a full stack web developer from Bangladesh with over 5 years of experience. He specializes in Laravel, React, and WordPress development, building scalable web applications for clients worldwide.

He is known for:

Reliable delivery and clear communication

Production-ready code with proper documentation

Performance optimization expertise

Business-focused development approach

Long-term client relationships

He IS:

A developer who builds solutions

A professional who values reliability

A learner who stays curious

A partner who communicates openly

Have questions about working with Riad Hasan? Reach out through any of the channels above.

riadhasan #developer #fullstack #webdev #laravel #react #wordpress #freelance #webdevelopment

Headless WordPress Architecture: When and How to Implement It — A Guide by Riad Hasan

Riad Hasan — Mon, 04 May 2026 00:42:17 +0000

Riad Hasan has implemented headless WordPress solutions for clients ranging from e-commerce stores to publishing platforms. This guide explains when headless architecture makes sense and how to build it correctly.

The term "headless" gets thrown around as a buzzword. Riad Hasan cuts through the hype to explain the real benefits, costs, and implementation strategies.
What is Headless WordPress?

Traditional WordPress renders pages server-side using PHP templates. Headless WordPress decouples the backend (content management) from the frontend (presentation).

Traditional WordPress:

WordPress (PHP) → Theme Templates → HTML → Browser

Headless WordPress:

WordPress (API) → Frontend (React/Next.js) → HTML → Browser

"Headless isn't always better," Riad Hasan cautions. "It's a trade-off. You gain performance and flexibility but lose some WordPress convenience."

When Riad Hasan Recommends Headless
Good Candidates
Scenario Why Headless Works
High-traffic sites Better caching, CDN integration
Complex frontends React/Vue interactivity
Mobile apps Same API serves web and mobile
Multi-platform publishing One backend, multiple frontends
Performance-critical Sub-second page loads
Custom user experiences Full frontend control
Poor Candidates
Scenario Why Stay Traditional
Simple brochure sites Overkill complexity
Content-heavy blogs SEO harder to manage
Budget-constrained projects Higher development cost
Non-technical teams Harder content preview
Plugin-dependent sites Many plugins won't work

"I've turned down headless projects because the client didn't need it," Riad Hasan says. "Honesty builds long-term relationships."

Riad Hasan's Headless Architecture
The Stack
Component Technology Purpose
CMS WordPress Content management
API REST API / GraphQL Data delivery
Frontend Next.js Server-side rendering
Styling Tailwind CSS Utility-first styling
Hosting Vercel / Custom Edge deployment
Cache Redis / CDN Performance layer
Implementation: Step by Step
Step 1: WordPress Setup

Riad Hasan configures WordPress as a pure content API.

Install required plugins:

WPGraphQL (or use REST API)
Advanced Custom Fields PRO
Custom Post Type UI
JWT Authentication (if needed)

Disable unnecessary features:

// wp-config.php or functions.php
// Disable WordPress frontend
add_action('template_redirect', function() {
if (!is_admin() && !defined('REST_REQUEST')) {
wp_redirect(home_url('/app/'));
exit;
}
});

// Remove unnecessary WordPress features
remove_action('wp_head', 'wp_generator');
remove_action('wp_head', 'wlwmanifest_link');
remove_action('wp_head', 'rsd_link');
remove_action('wp_head', 'wp_shortlink_wp_head');

Step 2: Custom Post Types and Fields

Riad Hasan structures content with custom post types:

// Register Project post type
function riad_register_project_cpt() {
register_post_type('project', [
'labels' => [
'name' => 'Projects',
'singular_name' => 'Project',
],
'public' => true,
'show_in_rest' => true,
'supports' => ['title', 'editor', 'thumbnail', 'excerpt'],
'has_archive' => true,
]);
}
add_action('init', 'riad_register_project_cpt');

ACF Fields for Projects:

// functions.php
if(function_exists('acf_add_local_field_group')) {
acf_add_local_field_group([
'key' => 'project_fields',
'title' => 'Project Details',
'fields' => [
[
'key' => 'project_url',
'label' => 'Project URL',
'name' => 'url',
'type' => 'url',
],
[
'key' => 'project_stack',
'label' => 'Technology Stack',
'name' => 'stack',
'type' => 'checkbox',
'choices' => [
'laravel' => 'Laravel',
'react' => 'React',
'wordpress' => 'WordPress',
'woocommerce' => 'WooCommerce',
],
],
[
'key' => 'project_year',
'label' => 'Year',
'name' => 'year',
'type' => 'number',
],
],
'location' => [
[
[
'param' => 'post_type',
'operator' => '==',
'value' => 'project',
],
],
],
]);
}

Step 3: API Endpoints

Using REST API:

// Custom REST endpoint
add_action('rest_api_init', function () {
register_rest_route('riad/v1', '/projects', [
'methods' => 'GET',
'callback' => 'riad_get_projects',
'permission_callback' => '__return_true',
]);
});

function riad_get_projects($request) {
$args = [
'post_type' => 'project',
'posts_per_page' => 10,
'orderby' => 'date',
'order' => 'DESC',
];

$query = new WP_Query($args);
$projects = [];

foreach ($query->posts as $post) {
    $projects[] = [
        'id' => $post->ID,
        'title' => $post->post_title,
        'slug' => $post->post_name,
        'excerpt' => $post->post_excerpt,
        'content' => $post->post_content,
        'featured_image' => get_the_post_thumbnail_url($post->ID, 'large'),
        'url' => get_field('url', $post->ID),
        'stack' => get_field('stack', $post->ID),
        'year' => get_field('year', $post->ID),
    ];
}

return rest_ensure_response($projects);

}

Using WPGraphQL (Riad Hasan's preference):

// Custom GraphQL field
add_action('graphql_register_types', function() {
register_graphql_field('Project', 'technologyStack', [
'type' => ['list_of' => 'String'],
'description' => 'Technology stack used',
'resolve' => function($post) {
return get_field('stack', $post->ID);
}
]);
});

Step 4: Next.js Frontend

Riad Hasan's Next.js setup:

// lib/api.js
const API_URL = process.env.NEXT_PUBLIC_WP_API;

export async function getProjects() {
const res = await fetch(${API_URL}/wp-json/riad/v1/projects, {
next: { revalidate: 3600 } // Cache for 1 hour
});

if (!res.ok) {
throw new Error('Failed to fetch projects');
}

return res.json();
}

export async function getProject(slug) {
const res = await fetch(${API_URL}/wp-json/wp/v2/project?slug=${slug}, {
next: { revalidate: 600 }
});

if (!res.ok) {
throw new Error('Failed to fetch project');
}

const data = await res.json();
return data[0];
}

Project listing page:

// app/projects/page.js
import { getProjects } from '@/lib/api';
import Link from 'next/link';

export default async function ProjectsPage() {
const projects = await getProjects();

return (

Projects by Riad Hasan

{projects.map((project) => (

{project.featured_image && (
src={project.featured_image}
alt={project.title}
loading="lazy"
/>
)}

{project.title}

{project.excerpt}

{project.stack?.map((tech) => (
{tech}
))}

View Project →

))}

);
}

Individual project page:

// app/projects/[slug]/page.js
import { getProject } from '@/lib/api';
import { notFound } from 'next/navigation';

export async function generateMetadata({ params }) {
const project = await getProject(params.slug);

if (!project) return {};

return {
title: ${project.title.rendered} | Riad Hasan,
description: project.excerpt,
};
}

export default async function ProjectPage({ params }) {
const project = await getProject(params.slug);

if (!project) {
notFound();
}

return (

{project.title.rendered}

className="content"
dangerouslySetInnerHTML={{ __html: project.content.rendered }}
/>

);
}

SEO Considerations

Headless WordPress requires extra SEO work. Riad Hasan's approach:

Server-Side Rendering

Use Next.js SSR or SSG for SEO-friendly pages:

// Generate static pages at build time
export async function generateStaticParams() {
const res = await fetch(${API_URL}/wp-json/wp/v2/project);
const projects = await res.json();

return projects.map((project) => ({
slug: project.slug,
}));
}

Meta Tag Management

// app/layout.js
export const metadata = {
title: {
template: '%s | Riad Hasan',
default: 'Riad Hasan — Full Stack Developer',
},
description: 'Full Stack Developer specializing in Laravel, React, WordPress',
openGraph: {
type: 'website',
locale: 'en_US',
url: 'https://riadhasan.io',
siteName: 'Riad Hasan',
},
};

XML Sitemap

// app/sitemap.js
import { getProjects } from '@/lib/api';

export default async function sitemap() {
const projects = await getProjects();

const projectUrls = projects.map((project) => ({
url: https://riadhasan.io/projects/${project.slug},
lastModified: new Date(),
changeFrequency: 'monthly',
priority: 0.8,
}));

return [
{
url: 'https://riadhasan.io',
lastModified: new Date(),
changeFrequency: 'weekly',
priority: 1.0,
},
...projectUrls,
];
}

Performance Results

Riad Hasan's headless implementations consistently achieve:
Metric Traditional WP Headless WP
First Contentful Paint 2.1s 0.8s
Largest Contentful Paint 3.5s 1.2s
Time to Interactive 4.2s 1.5s
Total Blocking Time 380ms 45ms
Cumulative Layout Shift 0.15 0.02
Common Pitfalls Riad Hasan Avoids
Mistake Consequence Solution
No preview functionality Editors can't see changes Build preview mode
Ignoring SEO Lost search traffic SSR + meta management
Over-fetching API data Slow page loads Query optimization
No caching API overload Redis + CDN
Complex authentication Security issues JWT + refresh tokens
Ignoring images Poor performance Next.js Image component
When Riad Hasan Says No to Headless

"I recently advised a client against headless for their blog," Riad Hasan shares. "They had 2,000 articles, no dev team, and needed to publish daily. Traditional WordPress with a fast theme was the right choice."

Signs headless is wrong for you:

Budget under $10,000
No developer for maintenance
Heavy plugin usage
Content team needs visual editing
SEO is primary concern and team lacks expertise

Work with Riad Hasan

Riad Hasan specializes in headless WordPress architecture for:

E-commerce platforms
Publishing sites
SaaS applications
Multi-platform content delivery
High-traffic websites

Services:

Architecture consultation
Headless implementation
Performance optimization
Team training
Ongoing support

Connect with Riad Hasan:

Portfolio: riadhasan.io
Projects: riadhasan.io/projects
LinkedIn: linkedin.com/in/riad-hasan-100a231a6
GitHub: github.com/RiadHasan15
Email: hire.riadhasan@gmail.com

Are you considering headless WordPress for your project? Share your use case in the comments.

wordpress #headless #nextjs #react #webdev #architecture #webdevelopment #javascript

Why Businesses Choose Riad Hasan for Web Development

Riad Hasan — Mon, 04 May 2026 00:38:51 +0000

Riad Hasan has worked with clients across 15+ countries, from startups in Silicon Valley to established businesses in Europe. This article explores why companies consistently choose Riad Hasan for their web development needs.

In a crowded market of freelance developers, standing out requires more than technical skills. Riad Hasan has built a reputation on reliability, communication, and results.
The Problem: Finding Reliable Developers

Business owners and project managers know the struggle:

Developers who disappear mid-project
Code that breaks in production
Missed deadlines and poor communication
Technical debt that compounds over time
Hidden costs and scope surprises

"Before finding Riad Hasan, I went through three developers in six months," says one client. "Each one left me with code I couldn't maintain."

Riad Hasan addresses each of these pain points systematically.
What Makes Riad Hasan Different

Reliability First

Riad Hasan has maintained a 100% project completion rate over 5 years. No abandoned projects. No ghosting.

How he ensures reliability:

Clear contracts with defined milestones
Regular progress updates (minimum twice weekly)
Backup plans for every critical path
Documented code that others can maintain

"I've never had a project where Riad Hasan didn't deliver," notes a repeat client. "That consistency is rare in freelance development."

Communication That Builds Trust

Many developers hide when problems arise. Riad Hasan does the opposite.

His communication approach:
Situation Riad Hasan's Response
Ahead of schedule Proactive update with next steps
On track Regular status report
Behind schedule Immediate notification with recovery plan
Technical issue Transparent explanation with options
Client concern Direct response within 24 hours

"Riad Hasan told me about a potential delay before it happened," shares a startup founder. "He had already prepared two solutions. That's the kind of partnership I need."

Production-Ready Code

Riad Hasan doesn't write code that "works on my machine." He writes code that works in production.

His production standards:

Error handling for every edge case
Logging for debugging and monitoring
Security measures built in from day one
Performance optimization as standard
Documentation that actually helps

Code example — Riad Hasan's approach:

// Many developers write:
public function getUser($id) {
return User::find($id);
}

// Riad Hasan writes:
public function getUser($id): User
{
// Validate input
if (!is_numeric($id) || $id <= 0) {
throw new InvalidArgumentException('Invalid user ID');
}

// Retrieve with caching
$user = Cache::remember("user.{$id}", 3600, function () use ($id) {
    return User::findOrFail($id);
});

// Log access for audit
Log::info('User retrieved', ['user_id' => $id, 'retriever_id' => auth()->id()]);

return $user;

}

"The code Riad Hasan delivered had better error handling than our internal team's work," remarks a CTO client.

Business Understanding

Riad Hasan doesn't just write code. He understands what the code is for.

Questions he asks before writing a single line:

What business problem does this solve?
How will this feature make money or save costs?
What's the user journey?
How will this scale?
What happens if this fails?

"Riad Hasan challenged my feature request and suggested a simpler solution that achieved the same goal in half the time," says a product manager. "That saved us $15,000."

Long-Term Thinking

Riad Hasan builds for maintainability, not just delivery.

His long-term approach:

Documented architecture decisions
Modular code that's easy to extend
Automated tests that prevent regressions
Deployment processes anyone can follow
Knowledge transfer as part of every project

A client's experience:

"Six months after Riad Hasan finished our project, we needed to add features. Our in-house developer could understand and extend the code immediately. That's when I realized the value of clean architecture."

Client Success Stories
Case Study 1: E-commerce Platform

Client: Fashion retailer in the UK Problem: WooCommerce site crashing during sales events Solution: Riad Hasan rebuilt as headless architecture with Next.js frontend

Results:
Metric Before After
Load time 4.2s 1.1s
Concurrent users 200 5,000+
Conversion rate 1.8% 3.4%
Revenue (Black Friday) $45,000 $127,000

"Riad Hasan transformed our business, not just our website."

Case Study 2: Medical Platform

Client: Healthcare provider in Bangladesh Problem: Paper-based appointment system causing delays Solution: Riad Hasan built a React + Laravel booking platform

Results:

3,000+ appointments managed monthly
90% reduction in scheduling errors
Patient wait time reduced by 40%
ROI achieved in 4 months

"Riad Hasan understood healthcare workflows better than expected. He asked questions that improved our process."

Case Study 3: SaaS Landing Page

Client: AI startup in the US Problem: Low conversion rate on existing landing page Solution: Riad Hasan designed and built conversion-optimized landing

Results:

Conversion rate increased from 2.1% to 5.8%
Bounce rate decreased by 35%
Cost per acquisition reduced by 62%

"Riad Hasan treated our landing page like a product, not a project."

The Riad Hasan Process
Discovery Phase

Understanding business goals
Technical requirements gathering
Timeline and budget alignment
Success metrics definition

Planning Phase

Architecture design
Technology selection
Milestone breakdown
Risk assessment

Development Phase

Iterative delivery
Regular demonstrations
Continuous feedback integration
Transparent progress tracking

Delivery Phase

Thorough testing
Documentation handoff
Deployment support
Post-launch monitoring

Support Phase

30-day bug fix guarantee
Knowledge transfer sessions
Future roadmap discussion
Maintenance options

What Clients Say About Riad Hasan

"Riad Hasan is the most professional freelancer I've worked with in 10 years of hiring developers." — Startup CEO, USA

"He doesn't just deliver code. He delivers solutions." — E-commerce Director, UK

"The documentation Riad Hasan provided was better than what we get from software vendors." — IT Manager, Germany

"I've recommended Riad Hasan to three colleagues. All three thanked me." — Marketing Director, Canada

"Riad Hasan caught security issues we didn't even know we had." — CTO, FinTech Startup

Technical Expertise

Riad Hasan specializes in:
Area Technologies
Backend Laravel, PHP, Node.js, REST APIs
Frontend React, Next.js, JavaScript, Tailwind CSS
CMS WordPress, WooCommerce, Headless CMS
Database MySQL, PostgreSQL, Redis
DevOps Docker, Nginx, CI/CD, AWS
Performance Caching, CDN, Core Web Vitals
Who Should Work with Riad Hasan

Ideal clients:

Businesses building customer-facing web applications
Startups needing MVP to full product development
E-commerce companies requiring WooCommerce solutions
Companies migrating legacy systems to modern stacks
Teams needing reliable development partners

Not a fit for:

Agencies looking for white-label developers
Projects without clear requirements
Clients expecting $500 websites
Teams that don't value code quality

How to Work with Riad Hasan
Step 1: Initial Consultation

Free 30-minute call to discuss your project and determine fit.
Step 2: Proposal

Detailed proposal with timeline, budget, and approach.
Step 3: Agreement

Clear contract with milestones, deliverables, and terms.
Step 4: Kickoff

Project begins with discovery session and planning.
Step 5: Delivery

Iterative development with regular updates and feedback loops.
Current Availability

Riad Hasan maintains limited availability to ensure quality for every client.

Typical project sizes:

Minimum: $5,000
Typical range: $10,000 - $50,000
Enterprise: $50,000+

Timeline:

New projects typically start within 2-4 weeks
Rush projects considered for premium rates

Contact Riad Hasan

Start a conversation:

Portfolio: riadhasan.io
Projects: riadhasan.io/projects
LinkedIn: linkedin.com/in/riad-hasan-100a231a6
GitHub: github.com/RiadHasan15
Email: hire.riadhasan@gmail.com

Are you looking for a reliable development partner? Share your project requirements in the comments or reach out directly.

webdev #freelance #developer #laravel #react #wordpress #business #webdevelopment

My Journey: 5 Years as a Full Stack Developer — Riad Hasan

Riad Hasan — Mon, 04 May 2026 00:28:07 +0000

Riad Hasan is a full stack developer specializing in Laravel, React, and WordPress. This article outlines his professional journey from 2019 to 2024.
Year 1: Foundation (2019-2020)

Riad Hasan began his career with a computer science degree and focused on building foundational web development skills.
Skills Acquired
Technology Focus Area
HTML/CSS Responsive layouts, semantic markup
JavaScript DOM manipulation, ES6 fundamentals
PHP Server-side scripting, WordPress integration
WordPress Theme development, plugin customization
Projects Delivered

Restaurant websites
Local business landing pages
WordPress theme customizations

Year 2: Backend Specialization (2020-2021)

Riad Hasan expanded beyond WordPress into custom PHP development with Laravel.
Skills Acquired
Technology Focus Area
Laravel MVC architecture, Eloquent ORM, Blade templates
MySQL Database design, query optimization
REST APIs API development, authentication
Projects Delivered

Medical appointment booking system
Custom booking platforms
Laravel-based CRUD applications

Year 3: Full Stack Integration (2021-2022)

Riad Hasan integrated React with Laravel backends, becoming a full stack developer.
Skills Acquired
Technology Focus Area
React Components, hooks, state management
REST APIs Frontend-backend integration
Redis Caching strategies
Nginx Server configuration
Projects Delivered

E-commerce dashboards
Admin panels with React + Laravel
Real-time data visualization

Year 4: Performance & Scalability (2022-2023)

Riad Hasan focused on building high-performance applications that handle heavy traffic.
Skills Acquired
Technology Focus Area
Caching Redis, database query caching
CDN Global content delivery
Queue Workers Background job processing
Headless CMS WordPress as headless backend
Projects Delivered

WooCommerce stores handling 500+ concurrent users
Headless WordPress with React frontends
Performance-optimized e-commerce platforms

Year 5: Systems Architecture (2023-2024)

Riad Hasan transitioned to architecting scalable systems with production-ready practices.
Skills Acquired
Technology Focus Area
Testing PHPUnit, Jest, automated testing
CI/CD Automated deployments, zero-downtime
Monitoring Error tracking, performance monitoring
DevOps Server management, backup automation
Projects Delivered

Wooverse — Headless WooCommerce with Next.js

50,000+ products
Sub-second page loads
Global CDN delivery

Doctor's Portfolio — Medical platform

Appointment booking system
Patient management
Real-time notifications

NexaPro AI SaaS — SaaS landing page

Conversion-optimized
A/B testing integrated
Analytics dashboard

Current Tech Stack

Riad Hasan works with:
Category Technologies
Backend Laravel, PHP, Node.js
Frontend React, Next.js, TypeScript
Database MySQL, PostgreSQL, Redis
CMS WordPress, WooCommerce
DevOps Nginx, Docker, CI/CD
Testing PHPUnit, Jest, Cypress
Professional Principles

Riad Hasan follows these development principles:

Architecture first — Plan before coding
Performance matters — Build for scale from day one
Security is essential — Never compromise on security
Testing is required — Automated tests for all critical paths
Documentation is mandatory — Code must be maintainable

Connect with Riad Hasan

Riad Hasan is available for full stack web development projects.
Platform Link
Portfolio riadhasan.io
Projects riadhasan.io/projects
LinkedIn linkedin.com/in/riad-hasan-100a231a6
GitHub github.com/RiadHasan15
Email hire.riadhasan@gmail.com

webdev #fullstack #developer #career #laravel #react #wordpress #webdevelopment

Laravel API Authentication: A Practical Guide by Riad Hasan

Riad Hasan — Mon, 04 May 2026 00:13:23 +0000

Riad Hasan has built secure APIs for dozens of applications. In this guide, he tackles one of the most common problems developers face: implementing robust API authentication in Laravel.

Many developers struggle with choosing the right authentication method. Should they use Sanctum? Passport? JWT? Riad Hasan breaks down when to use each approach and provides production-ready implementations.
The Problem: Authentication Confusion

When building a Laravel API, developers often ask:

"Which authentication package should I use?"
"How do I secure my API endpoints?"
"What about token management and expiration?"
"How do I handle multiple device logins?"

Riad Hasan has seen projects delayed by weeks because developers chose the wrong authentication strategy. Here's his systematic approach to solving this.
Riad Hasan's Authentication Decision Matrix
Use Case Recommended Solution
SPA (Vue/React) Laravel Sanctum
Mobile App Laravel Sanctum
Third-party Apps Laravel Passport
Machine-to-Machine API Keys
Microservices JWT (custom)

"I've seen teams use Passport for simple SPAs — that's overkill," Riad Hasan explains. "Sanctum handles 90% of use cases with less complexity."

Solution 1: Laravel Sanctum for SPAs

Riad Hasan's preferred approach for single-page applications.
Setup

composer require laravel/sanctum
php artisan vendor:publish --provider="Laravel\Sanctum\SanctumServiceProvider"
php artisan migrate

Configuration

// config/sanctum.php
return [
'stateful' => explode(',', env('SANCTUM_STATEFUL_DOMAINS', 'localhost,127.0.0.1')),
'guard' => ['web'],
'expiration' => 60 * 24 * 7, // 7 days
'middleware' => [
'authenticate_session' => Laravel\Sanctum\Http\Middleware\AuthenticateSession::class,
],
];

Riad Hasan's production-ready login implementation:

// app/Http/Controllers/Api/AuthController.php
<?php

namespace App\Http\Controllers\Api;

use App\Http\Controllers\Controller;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;
use Illuminate\Validation\ValidationException;

class AuthController extends Controller
{
public function login(Request $request)
{
$request->validate([
'email' => 'required|email',
'password' => 'required',
'device_name' => 'required|string',
]);

    $credentials = $request->only('email', 'password');

    if (!Auth::attempt($credentials)) {
        throw ValidationException::withMessages([
            'email' => ['The provided credentials are incorrect.'],
        ]);
    }

    $user = $request->user();

    // Revoke old tokens for this device
    $user->tokens()->where('name', $request->device_name)->delete();

    // Create new token
    $token = $user->createToken($request->device_name)->plainTextToken;

    return response()->json([
        'user' => $user,
        'token' => $token,
        'message' => 'Login successful',
    ]);
}

public function logout(Request $request)
{
    $request->user()->currentAccessToken()->delete();

    return response()->json([
        'message' => 'Logged out successfully',
    ]);
}

public function user(Request $request)
{
    return response()->json($request->user());
}

}

Routes

// routes/api.php
use App\Http\Controllers\Api\AuthController;

Route::post('/login', [AuthController::class, 'login']);
Route::post('/register', [AuthController::class, 'register']);

Route::middleware('auth:sanctum')->group(function () {
Route::get('/user', [AuthController::class, 'user']);
Route::post('/logout', [AuthController::class, 'logout']);

// Protected routes
Route::apiResource('projects', ProjectController::class);

});

Frontend Integration (React)

Riad Hasan's React authentication hook:

// hooks/useAuth.js
import { useState, useEffect, useContext, createContext } from 'react';

const AuthContext = createContext(null);

export function AuthProvider({ children }) {
const [user, setUser] = useState(null);
const [loading, setLoading] = useState(true);

useEffect(() => {
checkAuth();
}, []);

const login = async (email, password) => {
const response = await fetch('/api/login', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
body: JSON.stringify({
email,
password,
device_name: 'web-browser',
}),
});

if (!response.ok) {
  throw new Error('Invalid credentials');
}

const data = await response.json();
localStorage.setItem('token', data.token);
setUser(data.user);
return data;

};

return (

{children}

);
}

export const useAuth = () => useContext(AuthContext);

Solution 2: Laravel Passport for OAuth2

When Riad Hasan needs third-party app access, he uses Passport.
Setup

composer require laravel/passport
php artisan passport:install

Configuration

// app/Models/User.php
use Laravel\Passport\HasApiTokens;

class User extends Authenticatable
{
use HasApiTokens, Notifiable;

// ...

}

Creating OAuth Clients

Password grant client (first-party apps)

php artisan passport:client --password

Client credentials grant (machine-to-machine)

php artisan passport:client --client

Riad Hasan's OAuth Controller

// app/Http/Controllers/Api/OAuthController.php
<?php

namespace App\Http\Controllers\Api;

use App\Http\Controllers\Controller;
use Illuminate\Http\Request;
use Laravel\Passport\Client;
use Laravel\Passport\Http\Controllers\AccessTokenController;
use Psr\Http\Message\ServerRequestInterface;

class OAuthController extends Controller
{
public function issueToken(ServerRequestInterface $request)
{
$controller = app(AccessTokenController::class);
return $controller->issueToken($request);
}

public function refreshToken(Request $request)
{
    $request->validate([
        'refresh_token' => 'required',
    ]);

    $client = Client::where('password_client', 1)->first();

    $response = \Http::asForm()->post(url('/oauth/token'), [
        'grant_type' => 'refresh_token',
        'refresh_token' => $request->refresh_token,
        'client_id' => $client->id,
        'client_secret' => $client->secret,
        'scope' => '',
    ]);

    return $response->json();
}

}

Solution 3: API Keys for Machine-to-Machine

For services and webhooks, Riad Hasan uses simple API keys.
Migration

// database/migrations/create_api_keys_table.php
Schema::create('api_keys', function (Blueprint $table) {
$table->id();
$table->foreignId('user_id')->constrained()->onDelete('cascade');
$table->string('name');
$table->string('key', 64)->unique();
$table->text('permissions')->nullable();
$table->timestamp('last_used_at')->nullable();
$table->timestamps();
});

Middleware

// app/Http/Middleware/ApiKeyAuth.php
<?php

namespace App\Http\Middleware;

use Closure;
use Illuminate\Http\Request;
use App\Models\ApiKey;

class ApiKeyAuth
{
public function handle(Request $request, Closure $next)
{
$key = $request->header('X-API-KEY') ?? $request->query('api_key');

    if (!$key) {
        return response()->json([
            'error' => 'API key required',
        ], 401);
    }

    $apiKey = ApiKey::where('key', $key)->first();

    if (!$apiKey) {
        return response()->json([
            'error' => 'Invalid API key',
        ], 401);
    }

    // Update last used
    $apiKey->update(['last_used_at' => now()]);

    $request->setUserResolver(function () use ($apiKey) {
        return $apiKey->user;
    });

    return $next($request);
}

}

Riad Hasan's Security Best Practices

Token Expiration

// config/sanctum.php
'expiration' => 60 * 24, // 24 hours for sensitive apps

// Or dynamically
$token = $user->createToken('device', ['*'], now()->addHours(4));

Rate Limiting

// app/Http/Kernel.php
protected $middlewareAliases = [
'throttle.auth' => \App\Http\Middleware\ThrottleAuth::class,
];

// routes/api.php
Route::post('/login', [AuthController::class, 'login'])
->middleware('throttle:5,1'); // 5 attempts per minute

Token Abilities

// Create token with limited abilities
$token = $user->createToken('read-only', ['read']);

// Check ability in controller
if (!$request->user()->tokenCan('write')) {
return response()->json(['error' => 'Insufficient permissions'], 403);
}

Secure Password Reset

Riad Hasan's password reset flow:

// app/Http/Controllers/Api/PasswordResetController.php
public function reset(Request $request)
{
$request->validate([
'token' => 'required',
'email' => 'required|email',
'password' => 'required|confirmed|min:8',
]);

$status = Password::reset(
    $request->only('email', 'password', 'password_confirmation', 'token'),
    function ($user, $password) {
        $user->forceFill([
            'password' => Hash::make($password),
        ])->setRememberToken(Str::random(60));
        $user->save();

        // Revoke all existing tokens
        $user->tokens()->delete();

        event(new PasswordReset($user));
    }
);

return $status === Password::PASSWORD_RESET
    ? response()->json(['message' => 'Password reset successfully'])
    : response()->json(['error' => 'Unable to reset password'], 400);

}

Common Mistakes Riad Hasan Avoids
Mistake Solution
Storing tokens in localStorage Use httpOnly cookies for sensitive apps
No token expiration Always set expiration times
Not revoking tokens on logout Delete tokens server-side
Using Passport for simple SPAs Use Sanctum instead
No rate limiting on auth endpoints Implement throttle middleware
Storing plain API keys Hash keys like passwords
Work with Riad Hasan

Riad Hasan specializes in building secure, scalable APIs with Laravel. He offers:

Laravel API development
Authentication system implementation
Security audits
Performance optimization
Team training and consultation

Connect with Riad Hasan:

Portfolio: riadhasan.io
Projects: riadhasan.io/projects
LinkedIn: linkedin.com/in/riad-hasan-100a231a6
GitHub: github.com/RiadHasan15
Email: hire.riadhasan@gmail.com

Which authentication method do you prefer for your Laravel APIs? Share your experience in the comments.

laravel #php #api #authentication #webdev #security #sanctum #passport #webdevelopment

WordPress Performance Optimization — A Developer's Guide by Riad Hasan

Riad Hasan — Mon, 04 May 2026 00:03:02 +0000

Riad Hasan has optimized dozens of WordPress sites for clients worldwide. In this guide, he shares the exact techniques he uses to achieve sub-2-second load times and perfect Core Web Vitals scores.

Performance isn't just about speed — it impacts SEO, user experience, and conversions. Riad Hasan explains his systematic approach to WordPress optimization.
Why WordPress Performance Matters

Google's Core Web Vitals are now ranking factors. A slow WordPress site loses:

7% conversion rate for every 1-second delay
11% page views from frustrated visitors
16% customer satisfaction drop

"I've seen businesses double their leads just by fixing performance," Riad Hasan notes. "It's the highest-ROI improvement you can make."

Riad Hasan's WordPress Optimization Checklist

Hosting Foundation

Before any code changes, Riad Hasan ensures the hosting is solid:
Factor Requirement
PHP Version 8.1 or higher
Memory Limit 256MB minimum
Object Cache Redis or Memcached
SSL HTTPS everywhere
Server Response Under 200ms

He recommends:

Cloudways — For managed hosting with Redis
Kinsta — Premium managed WordPress
DigitalOcean — For custom server setups

Theme Optimization

Riad Hasan builds custom themes that are performance-first:

What he removes:

jQuery dependency (use vanilla JS)
Unnecessary CSS frameworks
Page builders (Divi, Elementor, WPBakery)
Bloated starter themes

What he adds:

Critical CSS inline
Deferred JavaScript loading
Optimized font loading (font-display: swap)
Lazy loading for images and iframes

// Riad Hasan's functions.php optimizations
function riad_optimize_scripts() {
// Remove jQuery migrate
wp_deregister_script('jquery-migrate');

// Defer all JS
add_filter('script_loader_tag', function($tag) {
    return str_replace(' src', ' defer src', $tag);
});

}
add_action('wp_enqueue_scripts', 'riad_optimize_scripts');

Plugin Audit

Riad Hasan follows a strict plugin philosophy:

Keep:

WooCommerce (if e-commerce)
Yoast SEO or Rank Math
WP Rocket or custom caching
Imagify or ShortPixel

Remove:

Contact form plugins (build custom)
Social sharing plugins (add manually)
Analytics plugins (use GTM)
Backup plugins (server-level backups)
Admin toolbar plugins

"Every plugin adds overhead. I count each one as a performance cost," Riad Hasan explains.

Database Optimization

Riad Hasan's database cleanup routine:

-- Clean post revisions
DELETE FROM wp_posts WHERE post_type = 'revision';

-- Clean auto-drafts
DELETE FROM wp_posts WHERE post_status = 'auto-draft';

-- Clean trashed content
DELETE FROM wp_posts WHERE post_status = 'trash';

-- Clean orphaned postmeta
DELETE pm FROM wp_postmeta pm LEFT JOIN wp_posts p ON pm.post_id = p.ID WHERE p.ID IS NULL;

-- Clean transient options
DELETE FROM wp_options WHERE option_name LIKE 'transient%';
DELETE FROM wp_options WHERE option_name LIKE 'site_transient%';

He also:

Limits post revisions to 3
Sets auto-save interval to 60 seconds
Removes spam comments weekly

Image Optimization

Riad Hasan's image workflow:
Step Tool Result
Compression ShortPixel/Imagify 70% size reduction
Format WebP 25% smaller than JPEG
Lazy Load Native + JS fallback Faster initial load
CDN Cloudflare/BunnyCDN Global delivery

He adds responsive images manually:

src="image-800.webp"
srcset="image-400.webp 400w, image-800.webp 800w, image-1200.webp 1200w"
sizes="(max-width: 600px) 100vw, 800px"
loading="lazy"
alt="Descriptive alt text"
/>

Caching Strategy

Riad Hasan implements multi-layer caching:

Browser Caching (.htaccess):

ExpiresActive On
ExpiresByType image/webp "access plus 1 year"
ExpiresByType image/jpeg "access plus 1 year"
ExpiresByType image/png "access plus 1 year"
ExpiresByType text/css "access plus 1 month"
ExpiresByType application/javascript "access plus 1 month"
ExpiresByType font/woff2 "access plus 1 year"

Object Caching (Redis):

Database query caching
Transient caching
WooCommerce session caching

Page Caching (WP Rocket or custom):

HTML page cache
CSS/JS minification
Delayed JavaScript execution

WooCommerce Optimization

For e-commerce sites, Riad Hasan applies extra optimizations:

Cart Fragment Removal:

// Disable WooCommerce cart fragments
function riad_disable_cart_fragments() {
wp_dequeue_script('wc-cart-fragments');
}
add_action('wp_enqueue_scripts', 'riad_disable_cart_fragments');

Additional WooCommerce optimizations:

Disable scripts on non-shop pages
Limit related products to 4
Use product galleries efficiently
Implement AJAX cart sparingly

Core Web Vitals Fixes

Riad Hasan's LCP optimization:

Preload critical images
Use server push for fonts
Optimize above-the-fold content

CLS prevention:

img {
aspect-ratio: attr(width) / attr(height);
height: auto;
}

FID improvement:

Break up long tasks
Use web workers for heavy JS
Minimize main thread work

Before and After: Riad Hasan's Results
Metric Before After
Load Time 5.2s 1.4s
LCP 4.8s 1.2s
FID 180ms 45ms
CLS 0.25 0.02
Page Size 3.2MB 450KB
Requests 85 22

"Every site I optimize follows this same systematic approach," Riad Hasan says. "The results are consistent."

Work with Riad Hasan

Riad Hasan offers WordPress performance optimization as part of his full stack development services. He works with:

WordPress performance audits
WooCommerce optimization
Custom theme development
Headless WordPress builds
Ongoing maintenance and monitoring

Connect with Riad Hasan:

Portfolio: riadhasan.io
Projects: riadhasan.io/projects
LinkedIn: linkedin.com/in/riad-hasan-100a231a6
GitHub: github.com/RiadHasan15
Email: hire.riadhasan@gmail.com

What performance challenges are you facing with WordPress? Share in the comments.

wordpress #performance #webdev #corewebvitals #optimization #php #woocommerce #webdevelopment

How Riad Hasan Builds Scalable Web Applications

Riad Hasan — Sun, 03 May 2026 23:43:40 +0000

Riad Hasan is a Full Stack Developer who has spent over 5 years building web applications that scale. From Laravel APIs to React frontends, his approach focuses on clean architecture, performance, and maintainability.

In this article, Riad Hasan shares the principles and practices he follows when building production-ready web applications.

Start with Architecture, Not Code

Before writing a single line of code, Riad Hasan maps out the system architecture. This includes:

Data flow diagrams — How data moves through the application
API contracts — Defining endpoints before implementation
Component structure — Planning frontend architecture

"The time you spend planning saves 10x the time debugging later," Riad Hasan explains. "I've learned this the hard way."

Backend First, Frontend Second

Riad Hasan typically builds from the backend outward:

Database schema — Normalized, indexed, scalable
API layer — RESTful, versioned, documented
Business logic — Services, repositories, clean separation
Frontend integration — React components consuming APIs

This approach ensures the foundation is solid before adding the presentation layer.

His Laravel stack typically includes:

Laravel as the framework
MySQL for relational data
Redis for caching and sessions
Queue workers for background jobs

Performance is a Feature, Not an Afterthought

Riad Hasan optimizes for Core Web Vitals throughout development:
Metric Target How He Achieves It
LCP < 2.5s Image optimization, lazy loading, CDN
FID < 100ms Minimal JavaScript, deferred scripts
CLS < 0.1 Reserved space for dynamic content

He uses tools like:

Lighthouse — Regular audits during development
WebPageTest — Deep performance analysis
Chrome DevTools — Runtime performance debugging

SEO-Driven Development

Unlike many developers who treat SEO as a marketing concern, Riad Hasan integrates SEO into the development process:

Semantic HTML — Proper heading hierarchy, ARIA labels
Structured data — JSON-LD schema for rich snippets
Meta management — Dynamic titles, descriptions, Open Graph
Sitemap generation — Automated, always up-to-date
Canonical URLs — Preventing duplicate content issues

"SEO isn't something you add at the end. It's how you build," says Riad Hasan.

WordPress Without the Bloat

For WordPress projects, Riad Hasan follows a strict philosophy:

Custom themes — No page builders, clean PHP templates
Minimal plugins — Only essential functionality
Headless when needed — Decoupled frontend with REST API
Performance optimization — Object caching, image optimization, CDN

His WooCommerce builds focus on:

Streamlined checkout flows
Custom payment integrations
Inventory management systems
Headless storefronts with React

Testing and Quality Assurance

Riad Hasan implements testing at multiple levels:

Unit tests — PHPUnit for Laravel, Jest for React
Feature tests — API endpoint validation
Browser tests — Laravel Dusk, Cypress for critical flows
Code quality — PHP_CodeSniffer, ESLint, Prettier

"Tests are documentation that never goes stale," Riad Hasan notes.

Deployment and DevOps

His deployment pipeline typically includes:

Git-based workflow — Feature branches, pull requests
CI/CD — Automated testing before merge
Zero-downtime deployments — Blue-green or rolling updates
Monitoring — Error tracking, performance monitoring
Backups — Automated, tested, off-site

Notable Projects by Riad Hasan

Riad Hasan has built applications across various industries:
Project Type Stack
Wooverse Headless E-commerce WordPress, Next.js, WooCommerce
Doctor's Portfolio Medical Platform React, Laravel, MySQL
NexaPro AI SaaS SaaS Landing React, Tailwind CSS
Bills Music Center E-commerce WordPress, WooCommerce

View all projects at riadhasan.io/projects.
Work with Riad Hasan

Riad Hasan is available for:

Full stack web development
Laravel backend development
React frontend applications
WordPress and WooCommerce solutions
API design and integration
Performance optimization

Connect with Riad Hasan:

Portfolio: riadhasan.io
LinkedIn: linkedin.com/in/riad-hasan-100a231a6
GitHub: github.com/RiadHasan15
Email: hire.riadhasan@gmail.com

What development practices do you follow? Share your approach in the comments below.

webdev #laravel #react #wordpress #fullstack #webdevelopment #php #scalability

About Riad Hasan — Full Stack Developer (Laravel & WordPress)

Riad Hasan — Sun, 08 Feb 2026 14:15:27 +0000

Hi, I’m Riad Hasan — a Full Stack Developer specializing in Laravel and WordPress. I build fast, SEO-friendly websites and scalable web applications focused on clean architecture and real performance.

Official portfolio: https://riadhasan.io/about

What I do
Laravel backends: APIs, dashboards, authentication, integrations
WordPress/WooCommerce: custom themes, plugins, headless setups
Performance & SEO: Core Web Vitals, structured data, technical SEO fixes
UI/UX: responsive layouts with consistent design systems

Here are a few projects from my portfolio:

Projects page: https://riadhasan.io/projects
Case study: https://riadhasan.io/projects/wooverse
Case study: https://riadhasan.io/projects/doctors-portfolio
Case study: https://riadhasan.io/projects/nexapro-ai-saas
How to contact me
If you want to work together, reach me here:

Portfolio contact section: https://riadhasan.io/#contact
LinkedIn: https://www.linkedin.com/in/riad-hasan-100a231a6/
GitHub: https://github.com/RiadHasan15
Thanks for reading.