DEV Community: Chirag Patel

Build a Rule-Based Product Tag Manager in Laravel 12.x — Step-by-Step Guide

Chirag Patel — Thu, 19 Mar 2026 18:00:49 +0000

In this article, we'll build a Product Tag Manager module in Laravel 12.x from scratch — step by step.

The idea is simple:

Admin adds products (name, price, SKU, vendor, type, image, etc.)
Admin creates rules with conditions like vendor == Supp.X AND price > 10
When the admin clicks Apply Rule, the system scans all products, checks all conditions, and if all match → it auto-applies tags to that product

No manual tagging. Pure rule-based automation.

Github Repo: github.com/chiragpatel009/product-tag-manager

🧱 Tech Stack

Category	Technology / Requirement
Backend Framework	Laravel 12.x
Programming Language	PHP 8.2+
Database	MySQL 8.0+
Frontend	Blade + TailwindCSS (CDN)
Rich Text Editor	Quill.js (via CDN)
Architecture Pattern	Laravel Resource Controllers
File Storage	Laravel Storage (image upload)

Step 1 — Create the Project

composer create-project laravel/laravel product-tag-manager
cd product-tag-manager

Configure your .env:

APP_NAME="Product Tag Manager"
APP_URL=http://localhost:8000

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=product_tag_manager
DB_USERNAME=root
DB_PASSWORD=

Create the database:

CREATE DATABASE product_tag_manager CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;

Step 2 — Migrations

Generate the migration files:

php artisan make:migration create_products_table
php artisan make:migration create_rules_table
php artisan make:migration create_rule_conditions_table

File: create_products_table

public function up(): void
    {
        Schema::create('products', function (Blueprint $table) {
            $table->id();
            $table->string('name');
            $table->longText('description')->nullable();
            $table->decimal('price', 10, 2);
            $table->string('sku')->unique();
            $table->unsignedInteger('qty')->default(0);
            $table->string('type')->nullable();
            $table->string('vendor')->nullable();
            $table->string('image')->nullable();
            $table->string('tags')->nullable(); // comma-separated, non-editable, set by rules
            $table->timestamps();
        });
    }

File: create_rules_table

public function up(): void
    {
        Schema::create('rules', function (Blueprint $table) {
            $table->id();
            $table->string('name');
            $table->string('apply_tags'); // comma-separated tag values
            $table->timestamps();
        });
    }

File: create_rule_conditions_table

public function up(): void
    {
        Schema::create('rule_conditions', function (Blueprint $table) {
            $table->id();
            $table->foreignId('rule_id')->constrained()->cascadeOnDelete();
            $table->enum('product_selector', ['type', 'sku', 'vendor', 'price', 'qty']);
            $table->enum('operator', ['==', '>', '<']);
            $table->string('value');
            $table->timestamps();
        });
    }

Run migrations:

php artisan migrate

Step 3 — Models

Generate the model files:

php artisan make:model Product
php artisan make:model Rule
php artisan make:model RuleCondition

File: app/Models/Product.php

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Product extends Model
{
    protected $fillable = [
        'name', 'description', 'price', 'sku',
        'qty', 'type', 'vendor', 'image', 'tags',
    ];
}

File: app/Models/Rule.php

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Rule extends Model
{
    protected $fillable = ['name', 'apply_tags'];

    public function conditions()
    {
        return $this->hasMany(RuleCondition::class);
    }
}

File: app/Models/RuleCondition.php

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class RuleCondition extends Model
{
    protected $fillable = ['rule_id', 'product_selector', 'operator', 'value'];

    public function rule()
    {
        return $this->belongsTo(Rule::class);
    }
}

Step 4 — Resource Controllers

Generate the controller files:

php artisan make:controller ProductController --resource
php artisan make:controller RuleController --resource

File: app/Http/Controllers/ProductController.php

<?php

namespace App\Http\Controllers;

use App\Models\Product;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Storage;

class ProductController extends Controller
{
    /**
     * Display a listing of the resource.
     */
    public function index()
    {
        $products = Product::latest()->paginate(10);
        return view('products.index', compact('products'));
    }

    /**
     * Show the form for creating a new resource.
     */
    public function create()
    {
        return view('products.create');
    }

    /**
     * Store a newly created resource in storage.
     */
    public function store(Request $request)
    {
        $validated = $request->validate([
            'name'        => 'required|string|max:255',
            'description' => 'nullable|string',
            'price'       => 'required|numeric|min:0',
            'sku'         => 'required|string|unique:products,sku',
            'qty'         => 'required|integer|min:0',
            'type'        => 'nullable|string|max:255',
            'vendor'      => 'nullable|string|max:255',
            'image'       => 'nullable|image|max:2048',
        ]);

        if ($request->hasFile('image')) {
            $validated['image'] = $request->file('image')->store('products', 'public');
        }

        Product::create($validated);

        return redirect()->route('products.index')
            ->with('success', 'Product added successfully.');
    }

    /**
     * Display the specified resource.
     */
    public function show(Product $product)
    {
        return redirect()->route('products.index');
    }

    /**
     * Show the form for editing the specified resource.
     */
    public function edit(Product $product)
    {
        return view('products.edit', compact('product'));
    }

    /**
     * Update the specified resource in storage.
     */
    public function update(Request $request, Product $product)
    {
        $validated = $request->validate([
            'name'        => 'required|string|max:255',
            'description' => 'nullable|string',
            'price'       => 'required|numeric|min:0',
            'sku'         => 'required|string|unique:products,sku,' . $product->id,
            'qty'         => 'required|integer|min:0',
            'type'        => 'nullable|string|max:255',
            'vendor'      => 'nullable|string|max:255',
            'image'       => 'nullable|image|max:2048',
        ]);

        if ($request->hasFile('image')) {
            if ($product->image) {
                Storage::disk('public')->delete($product->image);
            }
            $validated['image'] = $request->file('image')->store('products', 'public');
        }

        $product->update($validated);

        return redirect()->route('products.index')
            ->with('success', 'Product updated successfully.');
    }

    /**
     * Remove the specified resource from storage.
     */
    public function destroy(Product $product)
    {
        if ($product->image) {
            Storage::disk('public')->delete($product->image);
        }
        $product->delete();

        return redirect()->route('products.index')
            ->with('success', 'Product deleted.');
    }
}

File: app/Http/Controllers/RuleController.php

<?php

namespace App\Http\Controllers;

use App\Models\Product;
use App\Models\Rule;
use Illuminate\Http\Request;

class RuleController extends Controller
{
    /**
     * Display a listing of the resource.
     */
    public function index()
    {
        $rules = Rule::with('conditions')->latest()->paginate(10);
        return view('rules.index', compact('rules'));
    }

    /**
     * Show the form for creating a new resource.
     */
    public function create()
    {
        return view('rules.create');
    }

    /**
     * Store a newly created resource in storage.
     */
    public function store(Request $request)
    {
        $request->validate([
            'name'                        => 'required|string|max:255',
            'apply_tags'                  => 'required|string',
            'conditions'                  => 'required|array|min:1',
            'conditions.*.product_selector' => 'required|in:type,sku,vendor,price,qty',
            'conditions.*.operator'       => 'required|in:==,>,<',
            'conditions.*.value'          => 'required|string',
        ]);

        $rule = Rule::create([
            'name'       => $request->name,
            'apply_tags' => $request->apply_tags,
        ]);

        foreach ($request->conditions as $condition) {
            $rule->conditions()->create($condition);
        }

        return redirect()->route('rules.index')
            ->with('success', 'Rule created successfully.');
    }

    /**
     * Display the specified resource.
     */
    public function show(Rule $rule)
    {
        return redirect()->route('rules.index');
    }

    /**
     * Show the form for editing the specified resource.
     */
    public function edit(Rule $rule)
    {
        $rule->load('conditions');
        return view('rules.edit', compact('rule'));
    }

    /**
     * Update the specified resource in storage.
     */
    public function update(Request $request, Rule $rule)
    {
        $request->validate([
            'name'                        => 'required|string|max:255',
            'apply_tags'                  => 'required|string',
            'conditions'                  => 'required|array|min:1',
            'conditions.*.product_selector' => 'required|in:type,sku,vendor,price,qty',
            'conditions.*.operator'       => 'required|in:==,>,<',
            'conditions.*.value'          => 'required|string',
        ]);

        $rule->update([
            'name'       => $request->name,
            'apply_tags' => $request->apply_tags,
        ]);

        // Replace all old conditions
        $rule->conditions()->delete();
        foreach ($request->conditions as $condition) {
            $rule->conditions()->create($condition);
        }

        return redirect()->route('rules.index')
            ->with('success', 'Rule updated successfully.');
    }

    /**
     * Remove the specified resource from storage.
     */
    public function destroy(Rule $rule)
    {
        $rule->conditions()->delete();
        $rule->delete();

        return redirect()->route('rules.index')
            ->with('success', 'Rule deleted.');
    }

    /**
     * Apply a rule: match all conditions against every product.
     * If ALL conditions match a product, append the rule's tags to it.
     */
    public function applyRule(Rule $rule)
    {
        $rule->load('conditions');
        $products = Product::all();
        $appliedCount = 0;

        foreach ($products as $product) {
            $allMatch = true;

            foreach ($rule->conditions as $condition) {
                $field    = $condition->product_selector; // type, sku, vendor, price, qty
                $operator = $condition->operator;         // ==, >, <
                $value    = $condition->value;
                $actual   = $product->$field;

                $match = match ($operator) {
                    '=='    => strtolower((string)$actual) == strtolower($value),
                    '>'     => is_numeric($actual) && (float)$actual > (float)$value,
                    '<'     => is_numeric($actual) && (float)$actual < (float)$value,
                    default => false,
                };

                if (!$match) {
                    $allMatch = false;
                    break;
                }
            }

            if ($allMatch) {
                // Merge tags (avoid duplicates)
                $existingTags = $product->tags
                    ? array_map('trim', explode(',', $product->tags))
                    : [];

                $newTags = array_map('trim', explode(',', $rule->apply_tags));
                $merged  = array_unique(array_merge($existingTags, $newTags));
                $merged  = array_filter($merged); // remove empties

                $product->tags = implode(', ', $merged);
                $product->save();
                $appliedCount++;
            }
        }

        return redirect()->route('rules.index')
            ->with('success', "Rule applied. Tags added to {$appliedCount} product(s).");
    }
}

Step 5 — Routes

File: routes/web.php

<?php

use App\Http\Controllers\ProductController;
use App\Http\Controllers\RuleController;
use Illuminate\Support\Facades\Route;

Route::get('/', function () {
    return redirect()->route('products.index');
});

// Product Resource Routes
Route::resource('products', ProductController::class)->except(['show']);
Route::get('products/{product}', [ProductController::class, 'show']); // optional

// Rule Resource Routes
Route::resource('rules', RuleController::class)->except(['show']);
Route::post('rules/{rule}/apply', [RuleController::class, 'applyRule'])->name('rules.apply');

Step 6 — Blade Views

Create this folder structure under resources/views/:

layouts/
  app.blade.php
products/
  index.blade.php
  create.blade.php
  edit.blade.php
rules/
  index.blade.php
  create.blade.php
  edit.blade.php

Master Layout — `layouts/app.blade.php`

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Product Tag Manager</title>
    <!-- TailwindCSS CDN -->
    <script src="https://cdn.tailwindcss.com"></script>
    <!-- Quill.js (Rich Editor) -->
    <link href="https://cdn.quilljs.com/1.3.7/quill.snow.css" rel="stylesheet">
    <script src="https://cdn.quilljs.com/1.3.7/quill.min.js"></script>
    <style>
        .ql-container { min-height: 120px; }
    </style>
</head>
<body class="bg-gray-100 min-h-screen font-sans">

    <!-- Top Navigation -->
    <nav class="bg-white shadow-sm border-b border-gray-200">
        <div class="max-w-7xl mx-auto px-4 sm:px-6 lg:px-8">
            <div class="flex items-center justify-between h-16">
                <span class="text-xl font-bold text-blue-700 tracking-tight">
                    Product Tag Manager
                </span>
                <div class="flex space-x-2">
                    <a href="{{ route('products.index') }}"
                    class="px-4 py-2 rounded-md text-sm font-medium transition-colors 
                    {{ request()->routeIs('products.*') ? 'bg-blue-600 text-white' : 'text-gray-600 hover:bg-gray-100' }}">
                        Product Manager
                    </a>

                    <a href="{{ route('rules.index') }}"
                    class="px-4 py-2 rounded-md text-sm font-medium transition-colors 
                    {{ request()->routeIs('rules.*') ? 'bg-blue-600 text-white' : 'text-gray-600 hover:bg-gray-100' }}">
                        Rule Manager
                    </a>
                </div>
            </div>
        </div>
    </nav>

    <!-- Flash Messages -->
    <div class="max-w-7xl mx-auto px-4 pt-4">
        @if(session('success'))
            <div class="bg-green-100 border border-green-300 text-green-800 px-4 py-3 rounded-md mb-4 flex items-center justify-between">
                <span>{{ session('success') }}</span>
                <button onclick="this.parentElement.remove()" class="text-green-600 font-bold ml-4">×</button>
            </div>
        @endif
        @if($errors->any())
            <div class="bg-red-100 border border-red-300 text-red-800 px-4 py-3 rounded-md mb-4">
                <ul class="list-disc list-inside text-sm">
                    @foreach($errors->all() as $error)
                        <li>{{ $error }}</li>
                    @endforeach
                </ul>
            </div>
        @endif
    </div>

    <!-- Page Content -->
    <main class="max-w-7xl mx-auto px-4 sm:px-6 lg:px-8 py-6">
        @yield('content')
    </main>

</body>
</html>

Product Manager Views

File: products/index.blade.php

@extends('layouts.app')

@section('content')
<div class="flex items-center justify-between mb-6">
    <h1 class="text-2xl font-bold text-gray-800">Product Manager</h1>
    <a href="{{ route('products.create') }}"
       class="bg-blue-600 hover:bg-blue-700 text-white px-4 py-2 rounded-md text-sm font-medium transition">
        + Add Product
    </a>
</div>

<div class="bg-white shadow rounded-lg overflow-hidden">
    <table class="min-w-full divide-y divide-gray-200 text-sm">
        <thead class="bg-gray-50">
            <tr>
                <th class="px-4 py-3 text-left font-semibold text-gray-600">#</th>
                <th class="px-4 py-3 text-left font-semibold text-gray-600">Product Name</th>
                <th class="px-4 py-3 text-left font-semibold text-gray-600">SKU</th>
                <th class="px-4 py-3 text-left font-semibold text-gray-600">Price</th>
                <th class="px-4 py-3 text-left font-semibold text-gray-600">Vendor</th>
                <th class="px-4 py-3 text-left font-semibold text-gray-600">Qty</th>
                <th class="px-4 py-3 text-left font-semibold text-gray-600">Type</th>
                <th class="px-4 py-3 text-left font-semibold text-gray-600">Tags</th>
                <th class="px-4 py-3 text-left font-semibold text-gray-600">Action</th>
            </tr>
        </thead>
        <tbody class="divide-y divide-gray-100">
            @forelse($products as $product)
            <tr class="hover:bg-gray-50">
                <td class="px-4 py-3 text-gray-500">{{ $loop->iteration }}</td>
                <td class="px-4 py-3 font-medium text-gray-800">{{ $product->name }}</td>
                <td class="px-4 py-3 text-gray-600">{{ $product->sku }}</td>
                <td class="px-4 py-3 text-gray-600">${{ number_format($product->price, 2) }}</td>
                <td class="px-4 py-3 text-gray-600">{{ $product->vendor ?? '—' }}</td>
                <td class="px-4 py-3 text-gray-600">{{ $product->qty ?? '—' }}</td>
                <td class="px-4 py-3 text-gray-600">{{ $product->type ?? '—' }}</td>
                <td class="px-4 py-3">
                    @if($product->tags)
                        @foreach(explode(',', $product->tags) as $tag)
                            <span class="inline-block bg-blue-100 text-blue-700 text-xs px-2 py-0.5 rounded-full mr-1">
                                {{ trim($tag) }}
                            </span>
                        @endforeach
                    @else
                        <span class="text-gray-400 text-xs">No tags</span>
                    @endif
                </td>
                <td class="px-4 py-3 flex items-center space-x-2">
                    <a href="{{ route('products.edit', $product) }}"
                       class="text-blue-600 hover:underline text-xs font-medium">Edit</a>
                    <form action="{{ route('products.destroy', $product) }}" method="POST"
                          onsubmit="return confirm('Delete this product?')">
                        @csrf @method('DELETE')
                        <button type="submit"
                                class="text-red-500 hover:underline text-xs font-medium">Delete</button>
                    </form>
                </td>
            </tr>
            @empty
            <tr>
                <td colspan="8" class="px-4 py-8 text-center text-gray-400">
                    No products found. <a href="{{ route('products.create') }}" class="text-blue-600 underline">Add one</a>.
                </td>
            </tr>
            @endforelse
        </tbody>
    </table>
</div>

@if($products->hasPages())
<div class="mt-4">{{ $products->links() }}</div>
@endif
@endsection

File: products/create.blade.php

@extends('layouts.app')

@section('content')
<div class="flex items-center justify-between mb-6">
    <h1 class="text-2xl font-bold text-gray-800">Add Product</h1>
    <a href="{{ route('products.index') }}" class="text-sm text-blue-600 hover:underline">← Back to list</a>
</div>

<div class="bg-white shadow rounded-lg p-6 max-w-3xl">
    <form action="{{ route('products.store') }}" method="POST" enctype="multipart/form-data">
        @csrf

        <!-- Product Name -->
        <div class="mb-4">
            <label class="block text-sm font-medium text-gray-700 mb-1">Product Name <span class="text-red-500">*</span></label>
            <input type="text" name="name" value="{{ old('name') }}"
                   class="w-full border border-gray-300 rounded-md px-3 py-2 text-sm focus:outline-none focus:ring-2 focus:ring-blue-400"
                   placeholder="Enter product name">
        </div>

        <!-- Product Description (Quill Editor) -->
        <div class="mb-4">
            <label class="block text-sm font-medium text-gray-700 mb-1">Product Description</label>
            <div id="quill-editor" class="bg-white border border-gray-300 rounded-md"></div>
            <input type="hidden" name="description" id="description-input">
        </div>

        <!-- Price & SKU -->
        <div class="grid grid-cols-2 gap-4 mb-4">
            <div>
                <label class="block text-sm font-medium text-gray-700 mb-1">Product Price <span class="text-red-500">*</span></label>
                <input type="number" name="price" step="0.01" value="{{ old('price') }}"
                       class="w-full border border-gray-300 rounded-md px-3 py-2 text-sm focus:outline-none focus:ring-2 focus:ring-blue-400"
                       placeholder="0.00">
            </div>
            <div>
                <label class="block text-sm font-medium text-gray-700 mb-1">Product SKU <span class="text-red-500">*</span></label>
                <input type="text" name="sku" value="{{ old('sku') }}"
                       class="w-full border border-gray-300 rounded-md px-3 py-2 text-sm focus:outline-none focus:ring-2 focus:ring-blue-400"
                       placeholder="e.g. WA001">
            </div>
        </div>

        <!-- Qty & Type -->
        <div class="grid grid-cols-2 gap-4 mb-4">
            <div>
                <label class="block text-sm font-medium text-gray-700 mb-1">Product Qty <span class="text-red-500">*</span></label>
                <input type="number" name="qty" value="{{ old('qty', 0) }}"
                       class="w-full border border-gray-300 rounded-md px-3 py-2 text-sm focus:outline-none focus:ring-2 focus:ring-blue-400">
            </div>
            <div>
                <label class="block text-sm font-medium text-gray-700 mb-1">Product Type</label>
                <input type="text" name="type" value="{{ old('type') }}"
                       class="w-full border border-gray-300 rounded-md px-3 py-2 text-sm focus:outline-none focus:ring-2 focus:ring-blue-400"
                       placeholder="e.g. Type1">
            </div>
        </div>

        <!-- Vendor -->
        <div class="mb-4">
            <label class="block text-sm font-medium text-gray-700 mb-1">Product Vendor</label>
            <input type="text" name="vendor" value="{{ old('vendor') }}"
                   class="w-full border border-gray-300 rounded-md px-3 py-2 text-sm focus:outline-none focus:ring-2 focus:ring-blue-400"
                   placeholder="e.g. Supp.X">
        </div>

        <!-- Product Image -->
        <div class="mb-4">
            <label class="block text-sm font-medium text-gray-700 mb-1">Product Image</label>
            <input type="file" name="image" accept="image/*"
                   class="w-full border border-gray-300 rounded-md px-3 py-2 text-sm bg-white focus:outline-none focus:ring-2 focus:ring-blue-400">
        </div>

        <!-- Product Tags (non-editable) -->
        <div class="mb-6">
            <label class="block text-sm font-medium text-gray-700 mb-1">Product Tags
                <span class="text-gray-400 text-xs">(set automatically by rules, non-editable)</span>
            </label>
            <input type="text" disabled value=""
                   class="w-full border border-gray-200 bg-gray-50 rounded-md px-3 py-2 text-sm text-gray-400 cursor-not-allowed"
                   placeholder="Tags will be applied by rules">
        </div>

        <button type="submit"
                class="bg-blue-600 hover:bg-blue-700 text-white px-6 py-2 rounded-md font-medium text-sm transition">
            SUBMIT PRODUCT
        </button>
    </form>
</div>

<script>
    const quill = new Quill('#quill-editor', { theme: 'snow' });
    document.querySelector('form').addEventListener('submit', function () {
        document.getElementById('description-input').value = quill.root.innerHTML;
    });
</script>
@endsection

File: products/edit.blade.php

@extends('layouts.app')

@section('content')
<div class="flex items-center justify-between mb-6">
    <h1 class="text-2xl font-bold text-gray-800">Edit Product</h1>
    <a href="{{ route('products.index') }}" class="text-sm text-blue-600 hover:underline">← Back to list</a>
</div>

<div class="bg-white shadow rounded-lg p-6 max-w-3xl">
    <form action="{{ route('products.update', $product) }}" method="POST" enctype="multipart/form-data">
        @csrf @method('PUT')

        <div class="mb-4">
            <label class="block text-sm font-medium text-gray-700 mb-1">Product Name <span class="text-red-500">*</span></label>
            <input type="text" name="name" value="{{ old('name', $product->name) }}"
                   class="w-full border border-gray-300 rounded-md px-3 py-2 text-sm focus:outline-none focus:ring-2 focus:ring-blue-400">
        </div>

        <div class="mb-4">
            <label class="block text-sm font-medium text-gray-700 mb-1">Product Description</label>
            <div id="quill-editor" class="bg-white border border-gray-300 rounded-md"></div>
            <input type="hidden" name="description" id="description-input">
        </div>

        <div class="grid grid-cols-2 gap-4 mb-4">
            <div>
                <label class="block text-sm font-medium text-gray-700 mb-1">Product Price <span class="text-red-500">*</span></label>
                <input type="number" name="price" step="0.01" value="{{ old('price', $product->price) }}"
                       class="w-full border border-gray-300 rounded-md px-3 py-2 text-sm focus:outline-none focus:ring-2 focus:ring-blue-400">
            </div>
            <div>
                <label class="block text-sm font-medium text-gray-700 mb-1">Product SKU <span class="text-red-500">*</span></label>
                <input type="text" name="sku" value="{{ old('sku', $product->sku) }}"
                       class="w-full border border-gray-300 rounded-md px-3 py-2 text-sm focus:outline-none focus:ring-2 focus:ring-blue-400">
            </div>
        </div>

        <div class="grid grid-cols-2 gap-4 mb-4">
            <div>
                <label class="block text-sm font-medium text-gray-700 mb-1">Product Qty <span class="text-red-500">*</span></label>
                <input type="number" name="qty" value="{{ old('qty', $product->qty) }}"
                       class="w-full border border-gray-300 rounded-md px-3 py-2 text-sm focus:outline-none focus:ring-2 focus:ring-blue-400">
            </div>
            <div>
                <label class="block text-sm font-medium text-gray-700 mb-1">Product Type</label>
                <input type="text" name="type" value="{{ old('type', $product->type) }}"
                       class="w-full border border-gray-300 rounded-md px-3 py-2 text-sm focus:outline-none focus:ring-2 focus:ring-blue-400">
            </div>
        </div>

        <div class="mb-4">
            <label class="block text-sm font-medium text-gray-700 mb-1">Product Vendor</label>
            <input type="text" name="vendor" value="{{ old('vendor', $product->vendor) }}"
                   class="w-full border border-gray-300 rounded-md px-3 py-2 text-sm focus:outline-none focus:ring-2 focus:ring-blue-400">
        </div>

        <div class="mb-4">
            <label class="block text-sm font-medium text-gray-700 mb-1">Product Image</label>
            @if($product->image)
                <div class="mb-2">
                    <img src="{{ Storage::url($product->image) }}" alt="Current Image"
                         class="h-20 w-20 object-cover rounded border">
                    <p class="text-xs text-gray-400 mt-1">Current image. Upload new to replace.</p>
                </div>
            @endif
            <input type="file" name="image" accept="image/*"
                   class="w-full border border-gray-300 rounded-md px-3 py-2 text-sm bg-white focus:outline-none focus:ring-2 focus:ring-blue-400">
        </div>

        <!-- Tags — non-editable display -->
        <div class="mb-6">
            <label class="block text-sm font-medium text-gray-700 mb-1">Product Tags
                <span class="text-gray-400 text-xs">(managed by rules only)</span>
            </label>
            <input type="text" disabled value="{{ $product->tags }}"
                   class="w-full border border-gray-200 bg-gray-50 rounded-md px-3 py-2 text-sm text-gray-500 cursor-not-allowed">
        </div>

        <button type="submit"
                class="bg-blue-600 hover:bg-blue-700 text-white px-6 py-2 rounded-md font-medium text-sm transition">
            UPDATE PRODUCT
        </button>
    </form>
</div>

<script>
    const quill = new Quill('#quill-editor', { theme: 'snow' });
    quill.root.innerHTML = `{!! addslashes($product->description ?? '') !!}`;
    document.querySelector('form').addEventListener('submit', function () {
        document.getElementById('description-input').value = quill.root.innerHTML;
    });
</script>
@endsection

Rule Manager Views

File: rules/index.blade.php

@extends('layouts.app')

@section('content')
<div class="flex items-center justify-between mb-6">
    <h1 class="text-2xl font-bold text-gray-800">Rule Manager</h1>
    <a href="{{ route('rules.create') }}"
       class="bg-blue-600 hover:bg-blue-700 text-white px-4 py-2 rounded-md text-sm font-medium transition">
        + Add Rule
    </a>
</div>

<div class="bg-white shadow rounded-lg overflow-hidden">
    <table class="min-w-full divide-y divide-gray-200 text-sm">
        <thead class="bg-gray-50">
            <tr>
                <th class="px-4 py-3 text-left font-semibold text-gray-600">#</th>
                <th class="px-4 py-3 text-left font-semibold text-gray-600">Rule Name</th>
                <th class="px-4 py-3 text-left font-semibold text-gray-600">Apply Tags</th>
                <th class="px-4 py-3 text-left font-semibold text-gray-600">Action (Edit)</th>
                <th class="px-4 py-3 text-left font-semibold text-gray-600">Action</th>
            </tr>
        </thead>
        <tbody class="divide-y divide-gray-100">
            @forelse($rules as $rule)
            <tr class="hover:bg-gray-50">
                <td class="px-4 py-3 text-gray-500">{{ $loop->iteration }}</td>
                <td class="px-4 py-3 font-medium text-gray-800">{{ $rule->name }}</td>
                <td class="px-4 py-3">
                    @foreach(explode(',', $rule->apply_tags) as $tag)
                        <span class="inline-block bg-green-100 text-green-700 text-xs px-2 py-0.5 rounded-full mr-1">
                            {{ trim($tag) }}
                        </span>
                    @endforeach
                </td>
                <td class="px-4 py-3 flex items-center space-x-2">
                    <a href="{{ route('rules.edit', $rule) }}"
                       class="text-blue-600 hover:underline text-xs font-medium">Edit</a>
                    <form action="{{ route('rules.destroy', $rule) }}" method="POST"
                          onsubmit="return confirm('Delete this rule?')">
                        @csrf @method('DELETE')
                        <button type="submit" class="text-red-500 hover:underline text-xs font-medium">Delete</button>
                    </form>
                </td>
                <td class="px-4 py-3">
                    <form action="{{ route('rules.apply', $rule) }}" method="POST">
                        @csrf
                        <button type="submit"
                                class="bg-blue-600 hover:bg-blue-700 text-white text-xs px-3 py-1.5 rounded font-medium transition">
                            Apply Rule
                        </button>
                    </form>
                </td>
            </tr>
            @empty
            <tr>
                <td colspan="5" class="px-4 py-8 text-center text-gray-400">
                    No rules found. <a href="{{ route('rules.create') }}" class="text-blue-600 underline">Create one</a>.
                </td>
            </tr>
            @endforelse
        </tbody>
    </table>
</div>

@if($rules->hasPages())
<div class="mt-4">{{ $rules->links() }}</div>
@endif
@endsection

File: rules/create.blade.php

@extends('layouts.app')

@section('content')
<div class="flex items-center justify-between mb-6">
    <h1 class="text-2xl font-bold text-gray-800">Create Rule</h1>
    <a href="{{ route('rules.index') }}" class="text-sm text-blue-600 hover:underline">← Back to list</a>
</div>

<div class="bg-white shadow rounded-lg p-6 max-w-3xl">
    <form action="{{ route('rules.store') }}" method="POST" id="rule-form">
        @csrf

        <!-- Rule Name -->
        <div class="mb-4">
            <label class="block text-sm font-medium text-gray-700 mb-1">Rule Name <span class="text-red-500">*</span></label>
            <input type="text" name="name" value="{{ old('name') }}"
                   class="w-full border border-gray-300 rounded-md px-3 py-2 text-sm focus:outline-none focus:ring-2 focus:ring-blue-400"
                   placeholder="e.g. VIP Products">
        </div>

        <!-- Rule Conditions -->
        <div class="mb-4">
            <label class="block text-sm font-medium text-gray-700 mb-2">
                Rule Conditions <span class="text-red-500">*</span>
                <span class="text-gray-400 text-xs font-normal">(All conditions must match)</span>
            </label>

            <div id="conditions-wrapper" class="space-y-3">
                <!-- Condition Row Template (first row) -->
                <div class="condition-row flex items-center gap-2 bg-gray-50 p-3 rounded-md border border-gray-200">
                    <select name="conditions[0][product_selector]"
                            class="border border-gray-300 rounded-md px-2 py-1.5 text-sm focus:outline-none focus:ring-2 focus:ring-blue-400">
                        <option value="">Choose Selector</option>
                        <option value="type">Type</option>
                        <option value="sku">SKU</option>
                        <option value="vendor">Vendor</option>
                        <option value="price">Price</option>
                        <option value="qty">Qty</option>
                    </select>

                    <select name="conditions[0][operator]"
                            class="border border-gray-300 rounded-md px-2 py-1.5 text-sm focus:outline-none focus:ring-2 focus:ring-blue-400">
                        <option value="">Operator</option>
                        <option value="==">==</option>
                        <option value=">">&gt;</option>
                        <option value="<">&lt;</option>
                    </select>

                    <input type="text" name="conditions[0][value]" placeholder="Value"
                           class="flex-1 border border-gray-300 rounded-md px-2 py-1.5 text-sm focus:outline-none focus:ring-2 focus:ring-blue-400">

                    <button type="button" onclick="removeCondition(this)"
                            class="text-red-400 hover:text-red-600 font-bold text-lg leading-none px-1">×</button>
                </div>
            </div>

            <button type="button" onclick="addCondition()"
                    class="mt-3 flex items-center gap-1 text-sm text-blue-600 hover:text-blue-800 font-medium">
                <span class="text-lg leading-none">+</span> Add More Conditions
            </button>
        </div>

        <!-- Apply Tags -->
        <div class="mb-6">
            <label class="block text-sm font-medium text-gray-700 mb-1">
                Apply Tags <span class="text-red-500">*</span>
                <span class="text-gray-400 text-xs font-normal">(comma-separated)</span>
            </label>
            <input type="text" name="apply_tags" value="{{ old('apply_tags') }}"
                   class="w-full border border-gray-300 rounded-md px-3 py-2 text-sm focus:outline-none focus:ring-2 focus:ring-blue-400"
                   placeholder="e.g. VIP, Gold, Premium">
        </div>

        <button type="submit"
                class="bg-blue-600 hover:bg-blue-700 text-white px-6 py-2 rounded-md font-medium text-sm transition">
            SAVE RULE
        </button>
    </form>
</div>

<script>
let conditionIndex = 1;

function addCondition() {
    const wrapper = document.getElementById('conditions-wrapper');
    const idx = conditionIndex++;
    const row = document.createElement('div');
    row.className = 'condition-row flex items-center gap-2 bg-gray-50 p-3 rounded-md border border-gray-200';
    row.innerHTML = `
        <select name="conditions[${idx}][product_selector]"
                class="border border-gray-300 rounded-md px-2 py-1.5 text-sm focus:outline-none focus:ring-2 focus:ring-blue-400">
            <option value="">Choose Selector</option>
            <option value="type">Type</option>
            <option value="sku">SKU</option>
            <option value="vendor">Vendor</option>
            <option value="price">Price</option>
            <option value="qty">Qty</option>
        </select>
        <select name="conditions[${idx}][operator]"
                class="border border-gray-300 rounded-md px-2 py-1.5 text-sm focus:outline-none focus:ring-2 focus:ring-blue-400">
            <option value="">Operator</option>
            <option value="==">==</option>
            <option value=">">&gt;</option>
            <option value="<">&lt;</option>
        </select>
        <input type="text" name="conditions[${idx}][value]" placeholder="Value"
               class="flex-1 border border-gray-300 rounded-md px-2 py-1.5 text-sm focus:outline-none focus:ring-2 focus:ring-blue-400">
        <button type="button" onclick="removeCondition(this)"
                class="text-red-400 hover:text-red-600 font-bold text-lg leading-none px-1">×</button>
    `;
    wrapper.appendChild(row);
}

function removeCondition(btn) {
    const rows = document.querySelectorAll('.condition-row');
    if (rows.length > 1) {
        btn.closest('.condition-row').remove();
    } else {
        alert('At least one condition is required.');
    }
}
</script>
@endsection

File: rules/edit.blade.php

@extends('layouts.app')

@section('content')
<div class="flex items-center justify-between mb-6">
    <h1 class="text-2xl font-bold text-gray-800">Edit Rule</h1>
    <a href="{{ route('rules.index') }}" class="text-sm text-blue-600 hover:underline">← Back to list</a>
</div>

<div class="bg-white shadow rounded-lg p-6 max-w-3xl">
    <form action="{{ route('rules.update', $rule) }}" method="POST" id="rule-form">
        @csrf @method('PUT')

        <div class="mb-4">
            <label class="block text-sm font-medium text-gray-700 mb-1">Rule Name <span class="text-red-500">*</span></label>
            <input type="text" name="name" value="{{ old('name', $rule->name) }}"
                   class="w-full border border-gray-300 rounded-md px-3 py-2 text-sm focus:outline-none focus:ring-2 focus:ring-blue-400">
        </div>

        <div class="mb-4">
            <label class="block text-sm font-medium text-gray-700 mb-2">
                Rule Conditions <span class="text-red-500">*</span>
            </label>
            <div id="conditions-wrapper" class="space-y-3">
                @foreach($rule->conditions as $i => $condition)
                <div class="condition-row flex items-center gap-2 bg-gray-50 p-3 rounded-md border border-gray-200">
                    <select name="conditions[{{ $i }}][product_selector]"
                            class="border border-gray-300 rounded-md px-2 py-1.5 text-sm">
                        @foreach(['type','sku','vendor','price','qty'] as $opt)
                            <option value="{{ $opt }}" {{ $condition->product_selector === $opt ? 'selected' : '' }}>
                                {{ ucfirst($opt) }}
                            </option>
                        @endforeach
                    </select>
                    <select name="conditions[{{ $i }}][operator]"
                            class="border border-gray-300 rounded-md px-2 py-1.5 text-sm">
                        @foreach(['==','>','<'] as $op)
                            <option value="{{ $op }}" {{ $condition->operator === $op ? 'selected' : '' }}>{{ $op }}</option>
                        @endforeach
                    </select>
                    <input type="text" name="conditions[{{ $i }}][value]" value="{{ $condition->value }}"
                           class="flex-1 border border-gray-300 rounded-md px-2 py-1.5 text-sm">
                    <button type="button" onclick="removeCondition(this)"
                            class="text-red-400 hover:text-red-600 font-bold text-lg leading-none px-1">×</button>
                </div>
                @endforeach
            </div>
            <button type="button" onclick="addCondition()"
                    class="mt-3 flex items-center gap-1 text-sm text-blue-600 hover:text-blue-800 font-medium">
                <span class="text-lg leading-none">+</span> Add More Conditions
            </button>
        </div>

        <div class="mb-6">
            <label class="block text-sm font-medium text-gray-700 mb-1">
                Apply Tags <span class="text-red-500">*</span>
                <span class="text-gray-400 text-xs font-normal">(comma-separated)</span>
            </label>
            <input type="text" name="apply_tags" value="{{ old('apply_tags', $rule->apply_tags) }}"
                   class="w-full border border-gray-300 rounded-md px-3 py-2 text-sm focus:outline-none focus:ring-2 focus:ring-blue-400">
        </div>

        <button type="submit"
                class="bg-blue-600 hover:bg-blue-700 text-white px-6 py-2 rounded-md font-medium text-sm transition">
            UPDATE RULE
        </button>
    </form>
</div>

<script>
let conditionIndex = {{ $rule->conditions->count() }};

function addCondition() {
    const wrapper = document.getElementById('conditions-wrapper');
    const idx = conditionIndex++;
    const row = document.createElement('div');
    row.className = 'condition-row flex items-center gap-2 bg-gray-50 p-3 rounded-md border border-gray-200';
    row.innerHTML = `
        <select name="conditions[${idx}][product_selector]"
                class="border border-gray-300 rounded-md px-2 py-1.5 text-sm">
            <option value="">Choose Selector</option>
            <option value="type">Type</option>
            <option value="sku">SKU</option>
            <option value="vendor">Vendor</option>
            <option value="price">Price</option>
            <option value="qty">Qty</option>
        </select>
        <select name="conditions[${idx}][operator]"
                class="border border-gray-300 rounded-md px-2 py-1.5 text-sm">
            <option value="">Operator</option>
            <option value="==">==</option>
            <option value=">">&gt;</option>
            <option value="<">&lt;</option>
        </select>
        <input type="text" name="conditions[${idx}][value]" placeholder="Value"
               class="flex-1 border border-gray-300 rounded-md px-2 py-1.5 text-sm">
        <button type="button" onclick="removeCondition(this)"
                class="text-red-400 hover:text-red-600 font-bold text-lg px-1">×</button>
    `;
    wrapper.appendChild(row);
}

function removeCondition(btn) {
    const rows = document.querySelectorAll('.condition-row');
    if (rows.length > 1) {
        btn.closest('.condition-row').remove();
    } else {
        alert('At least one condition is required.');
    }
}
</script>
@endsection

Step 7 — Storage Link for Images

php artisan storage:link

Make sure config/filesystems.php has this (default in Laravel):

'public' => [
    'driver'     => 'local',
    'root'       => storage_path('app/public'),
    'url'        => env('APP_URL').'/storage',
    'visibility' => 'public',
],

Step 8 — Run & Test

php artisan serve

Visit http://localhost:8000 and test the flow:

Add Products → fill in name, price, SKU, vendor, type, qty, image
Note the Tags field is disabled (non-editable — only rules can set it)
Go to Rule Manager → Create a rule with conditions like vendor == Supp.X AND price > 10
Set Apply Tags to VIP, Gold
Click Apply Rule
Go back to products → matching products will now have VIP, Gold in their Tags column

Step 9 — Push to GitHub

git init
git add .
git commit -m "First Commit"
git remote add origin https://github.com/YOUR_USERNAME/product-tag-manager.git
git branch -M main
git push -u origin main

How the Rule Engine Works

When Apply Rule is clicked, RuleController::applyRule() runs this logic:

For each Product:
  → Check ALL rule conditions
  → condition: product.{selector} {operator} {value}
     == → case-insensitive string/numeric match
     >  → numeric greater-than
     <  → numeric less-than
  → If ALL pass → merge tags (no duplicates) → save
  → If ANY fail → skip product

The tags are merged, not replaced — so a product can accumulate tags from multiple rules without losing previously applied ones.

File Structure

app/Http/Controllers/
  ProductController.php     ← Resource CRUD + image upload
  RuleController.php        ← Resource CRUD + applyRule()
app/Models/
  Product.php
  Rule.php                  ← hasMany(RuleCondition)
  RuleCondition.php         ← belongsTo(Rule)
database/migrations/
  create_products_table.php
  create_rules_table.php
  create_rule_conditions_table.php
resources/views/
  layouts/app.blade.php
  products/ → index, create, edit
  rules/    → index, create, edit
routes/web.php

That's it! You now have a fully working rule-based product tagging system in Laravel.

Github Repo: github.com/chiragpatel009/product-tag-manager

If you found this helpful, drop a ❤️ and follow for more Laravel practicals!

🎮 Why Simple Web Games Still Work (and What I Learned Building One)

Chirag Patel — Wed, 07 Jan 2026 09:49:46 +0000

Update: This game reached Top-10 on Product Hunt and was featured in the PH Daily Newsletter after launch. v1.1 shipped based on community feedback.

When we think about games, we often imagine complex graphics, heavy engines, and massive codebases.
But some of the most addictive games ever made are surprisingly simple - especially on the web.

Games like Wordle, Cookie Clicker, Flappy Bird, and A Dark Room prove that you don’t need complexity to keep users engaged.

What you need is one strong emotion.

As a developer, this idea pushed me to experiment and build a small web game of my own - not to go viral, but to understand why simple games work.

What Makes Simple Web Games Addictive?

Let’s quickly look at a few popular examples:

• Wordle
One puzzle per day. No ads. No distractions.
→ Scarcity + routine.

• Cookie Clicker
Just clicking — yet progression systems make it impossible to stop.
→ Numbers going up = dopamine.

• Flappy Bird
No instructions. Brutally difficult.
→ Failure itself becomes the gameplay.

• A Dark Room
Minimal UI, mystery-driven progression.
→ Curiosity beats visuals.

All these games focus on one dominant emotion:
frustration, curiosity, obsession, or surprise.

My Experiment: Turning Frustration Into a Game

Inspired by these patterns, I built a small browser game called Too Many Buttons.

The idea is intentionally simple:

The screen is filled with buttons
Only one button actually works
Every other click triggers chaos — fake alerts, screen shakes, sounds, distractions

There are no instructions.
The wrong click isn’t a mistake - it’s the experience.

This approach was inspired by games like Flappy Bird and Getting Over It, where players keep going because it’s frustrating.

👉 You can play it here: https://onebuttongame.com

🧠 What I Learned While Building It

Frustration Can Be Fun (When It’s Honest)
Players accept frustration when it feels intentional, not broken.
Removing Instructions Increases Exploration
With no tutorial, users experiment more and feel ownership over discovery.
Feedback Matters More Than Graphics
Simple sounds, animations, and reactions made clicks feel meaningful.
You Don’t Need a Heavy Game Engine
The game is built using:

React
TypeScript
CSS

Simple tools were enough to ship and iterate fast.

🚀 Sharing It & Getting Real Feedback

After testing with friends, I decided to share Too Many Buttons on Product Hunt - mainly to get honest feedback from people I don’t know.

If you try the game and have a moment:

You can click through to the Product Hunt page
Share what felt fun, frustrating, or confusing
And if you genuinely enjoy it, an upvote would really help

Not for rankings — but for motivation.

Seeing real people interact with something I built pushes me to keep learning and building better projects in the future.

👉 Product Hunt link: Click Here

Every comment helps more than you might think.

Final Thoughts

Web games don’t need to be perfect.
They need to be interesting.

If you’re a developer thinking about building a game or a side project:

Start small
Focus on one emotion
Ship early
Learn from real users

And if chaotic browser games sound fun, feel free to try Too Many Buttons and share your thoughts.

Happy building 👋

🚀 How to Install Supabase CLI on Windows (The Right Way) — A Simple Guide for Everyone

Chirag Patel — Sun, 16 Nov 2025 11:24:50 +0000

If you're working with Supabase for the first time — especially on Windows — you’ll eventually need to run commands like:

supabase login
supabase link
supabase db push

But the first hurdle many of us hit is simply installing the Supabase CLI
And if you try installing it using the old method:

npm install -g supabase

You’ll see this error:

"Installing Supabase CLI as a global module is not supported."

This confuses everyone:

Students and beginners trying Supabase for the first time
Freshers exploring backend tools
Experienced developers who just expect npm to work
Anyone cloning a project that already uses Supabase

This article gives you the full, correct, and simplest way to install the Supabase CLI on Windows, with clear steps and no technical chaos.

Why Supabase CLI Matters

Supabase CLI allows you to:

Manage migrations
Push database schema to your remote Supabase project
Manage local development
Link your local files with your hosted project
Automate DB tasks

If you're cloning a project or working with a team, CLI becomes mandatory.

Why Does `npm install -g supabase` Fail?

Earlier, you could install it with npm.
But that caused too many problems on Windows:
❌ Wrong PATH settings
❌ Broken CLI after Node updates
❌ Inconsistent global installs
❌ Antivirus conflicts
❌ Permissions issues

To avoid all these headaches, Supabase officially removed npm installation support.

Now the recommended and most stable way is through Scoop.

What is Scoop (and Why Windows Developers Need It?)

If you're used to macOS (Homebrew) or Linux (APT), installing dev tools feels easy.

Windows didn’t have a similar experience — until Scoop.

Scoop is a package manager for Windows
It lets you install command-line tools in one clean command:

scoop install supabase

No installers.
No registry entries.
No messing with PATH.
No "next → next → next".

Scoop is perfect because:
✔ No admin rights required
✔ Automatically manages PATH
✔ Installs clean & isolated binaries
✔ Makes updating CLI simple
✔ Trusted by the Windows developer community

Supabase recommends Scoop for exactly these reasons.

Step 1 — Enable Script Permissions

Open PowerShell (Run as Administrator) and run:

Set-ExecutionPolicy RemoteSigned -Scope CurrentUser

Press Y to confirm.
This allows safe scripts like Scoop to run.

Step 2 — Install Scoop

iwr -useb get.scoop.sh | iex

After installation, check:

scoop --version

If you see a version number → Scoop is ready.

Step 3 — Install Supabase CLI

Now, install the official Supabase CLI for Windows:

scoop install supabase

This downloads the precompiled supabase.exe.

Check installation:

supabase --version

If you see something like:

If you see something like:

🎉 You’re done! The CLI is now working perfectly.

Step 4 — Log in to Supabase

supabase login

A browser window opens → log in → return to the terminal.

Step 5 — Link Your Local Project

Navigate to your cloned project:

cd path/to/your/project

Then link:

supabase link --project-ref <your-project-id>

Find the project reference in:
Supabase Dashboard → Project Settings → General Setting section

Step 6 — Push Migrations to Your Remote Supabase

If your local project contains:

supabase/migrations/

Run:

supabase db push

This will:

Compare migrations
Apply only pending ones
Update your remote Supabase PostgreSQL safely

Exactly what most real projects need.

🎉 You're Ready to Work with Supabase on Windows

You now have:

A fully working Supabase CLI
The correct installation method for Windows
Ability to push migrations
A setup that won’t break on updates
A clean dev environment that beginners and pros can trust

⭐ Extra Tips for Developers

Update Supabase CLI:

scoop update supabase

Uninstall Supabase CLI:

scoop uninstall supabase

See available Scoop apps:

scoop search supabase

💬 Final Thoughts

Many developers — new or experienced — get stuck because older tutorials still mention npm installation.
This article gives the updated, correct, and officially recommended way to install Supabase CLI on Windows.

If you’re using Supabase in your projects, especially with frameworks like:

Next.js
Bold.new
Astro
Svelte
Laravel
Flutter

…this setup will save you hours of debugging.

Fix Angular and Node Version Mismatch Using NVM on Windows

Chirag Patel — Thu, 13 Nov 2025 13:00:56 +0000

Many developers face a common issue while working with Angular projects — everything runs smoothly one day, and suddenly the next day the project refuses to start.

This usually happens due to a Node.js version mismatch.
Angular CLI and framework versions depend on specific Node versions, and if the system updates or the global Node version changes, the build commands can fail unexpectedly.

This guide explains how to manage and switch Node versions using NVM (Node Version Manager) on Windows to fix Angular version compatibility issues.

Why This Happens

Each Angular version officially supports certain Node.js versions.

For example:

Angular Version	Compatible Node Version
Angular 20	Node 20
Angular 18	Node 18
Angular 17	Node 18

If the wrong Node version is active, the following errors may appear:

"Your Node.js version is not supported"
"Cannot find module @angular/cli"
npm install fails due to version conflicts

Step 1: Check Current Node Version

To check the current Node version, run:

node -v

Example output:

v18.20.8

If the project requires Node 20, switch versions using NVM.

Step 2: Check Installed Node Versions

List all installed Node versions:

nvm list

Example:

20.19.5
20.19.0
* 18.20.8 (Currently using 64-bit executable)

If Node 20 isn’t installed yet:

nvm install 20

Step 3: Switch to the Required Node Version

Activate Node 20:

nvm use 20

Confirm the active version:

node -v

Expected output:

v20.x.x

If the version does not change, it may indicate a global Node installation conflict.

Step 4: Fix PATH Conflicts on Windows

To identify which Node executable is being used, run:

where node

If the result includes both paths below, there’s a PATH conflict:

C:\Program Files\nodejs\node.exe
C:\Users\<username>\AppData\Roaming\nvm\v20.19.5\node.exe

To fix:

Open Control Panel → System → Advanced system settings → Environment Variables
Edit the **Path **variable under “System variables”
Remove this entry (if it exists):

C:\Program Files\nodejs\

Save and restart the terminal
Run:

nvm use 20
node -v

Now Node 20 should be active.

Step 5: Install the Matching Angular CLI Version

To install Angular CLI compatible with Angular 20:

npm install -g @angular/cli@20

Inside the project folder:

npm install

Verify:

ng version

The CLI and framework should both show version 20.

Step 6: Run the Project

Start the Angular development server:

ng serve

npm start

If the setup is correct, the project should compile and run without errors.

💡 Bonus Tip: Use .nvmrc for Per-Project Node Version Management

Create a .nvmrc file in the project’s root directory and add the Node version number:

Then simply run:

nvm use

This automatically switches to the correct Node version for that specific project.

🎯 Conclusion

Using NVM (Node Version Manager) simplifies working with multiple Angular projects that require different Node versions.

With this setup:

Node and Angular versions remain compatible
Version conflicts are easy to fix
Projects stay consistent across development environments

No more unexpected “version mismatch” errors — just smooth Angular development 🚀

How to Set Up a Laravel Project on Local After Clone

Chirag Patel — Thu, 06 Nov 2025 10:21:54 +0000

So you just cloned a Laravel project from GitHub, but the app isn’t working on your local system?
Don’t worry — you're not alone. Every Laravel developer goes through this the first time.

In this guide, we’ll walk through step-by-step how to set up a Laravel project locally after git clone.
This works on Windows, macOS, and Linux.

✅ Beginner-friendly
✅ Copy-paste ready commands

1. Clone the Laravel Project

Open your terminal and clone the repo:

git clone https://github.com/your-username/your-laravel-project.git
cd your-laravel-project

2. Install PHP Dependencies

Laravel uses Composer to manage PHP packages. Run:

composer install

If you see composer command not found, install it first: Composer Install

3. Create `.env` File

Copy the sample environment file:

cp .env.example .env

Windows users:

copy .env.example .env

Now open .env and update:

Database name
Database username
Password

Example:

DB_DATABASE=laravel_app
DB_USERNAME=root
DB_PASSWORD=

4. Generate Application Key

php artisan key:generate

This secures your session & app data.

5. Run Database Migrations (If applicable)

php artisan migrate

If you see database errors, make sure the DB exists. Create it manually or via command (MySQL):

CREATE DATABASE laravel_app;

6. Link Storage (For uploads & images)

php artisan storage:link

7. Install Node Dependencies (If project has frontend)

npm install
npm run dev  # or npm run build for production

8. Serve the Project

Start Laravel local server:

php artisan serve

Open in browser:

http://127.0.0.1:8000

🎉 Your Laravel app is running!

🧠 Common Errors & Fixes

Error	Quick Fix
`Class not found`	Run `composer dump-autoload`
`.env file not loading`	Delete cache: `php artisan config:clear`
`500 error after migration`	Check DB credentials & run `php artisan migrate:fresh`
`npm not found`	Install Node.js: https://nodejs.org/

✅ Final Checklist

Task	Status
Clone project	✅
Install composer deps	✅
Setup `.env`	✅
Generate key	✅
Run migrations	✅
Install npm	✅
Run server	✅

🎯 Conclusion

Setting up a Laravel project locally after cloning is simple once you know the process:

Task	Command
Clone project	`git clone 'link projer github'`
Install composer deps	`composer install`
Setup `.env`	`cp .env.example .env` or `copy .env.example .env`
Configure DB	Now open `.env` and update: Database name, Database username, Password
Generate key	`php artisan key:generate`
Run migrations	`php artisan migrate`
Install npm(optional)	`npm install`
Run server	`php artisan serve`

Bookmark this guide — it will save you time on every project!

💬 Have Questions?

Drop a comment — happy to help!
And if you found this useful, smash the ❤️ and follow for more Laravel tips.

🔁 Bonus: Full Setup Script (Linux/Mac)

git clone repo-url project
cd project
composer install
cp .env.example .env
php artisan key:generate
npm install && npm run dev
php artisan migrate
php artisan serve

Stop Sending JSON to LLMs - Try This Instead

Chirag Patel — Tue, 04 Nov 2025 10:58:48 +0000

When working with LLMs, most developers send structured data as JSON.
It's standard, familiar, and perfect for APIs — but not always efficient for language models.

LLMs don't parse JSON like software does.
They simply read it as text, and we pay for every token — quotes, brackets, spaces, commas, everything.

Result?
Unnecessary cost + slower responses.

This is exactly why TOON (Token-Oriented Object Notation) was created.

What is TOON?

TOON = a compact data format designed for LLM input.
It aims to:

reduce token usage
remain human-readable
preserve structure without heavy syntax

TOON borrows ideas from:

Format	Borrowed Concept
YAML	indentation for structure
CSV	table-like lists for repeated fields

The goal: minimum characters, maximum clarity.

Example

JSON

{ "tags": ["chill", "lofi", "study"] }

TOON

tags(3) - chill - lofi - study

Same meaning.
Fewer tokens.

Why TOON Matters

Benefit	Impact
Token-efficient	~30–60% fewer tokens in tests
Faster prompts	Less text to process
Readable	Easier debugging + tracing
LLM-aware format	Designed for prompt input, not APIs

Token Comparison (Real Test)

Flat user dataset → query LLM

Format	Prompt Tokens	Total Tokens
JSON	757	797
TOON	460	500 ✅

~40% reduction with zero data loss.

Example Workflow

JSON approach

const input = JSON.stringify(data)
sendToLLM(input)

TOON approach

import { encode } from "@microsoft/tone"

const input = encode(data)
sendToLLM(input)

Clearer. Smaller. Faster.

⚠️ Important — TOON Works Best With Flat Data

Flat JSON → TOON ✅ efficient
Nested JSON → TOON ❌ can cost more tokens

If your data has nested objects, flatten first before encoding.

When to Use TOON

Use TOON for:
✅ passing structured data in prompts
✅ RAG agents and memory context
✅ large dynamic input payloads
✅ debugging structured prompt data

Don’t use TOON for:
❌ APIs
❌ storage
❌ LLM output format

Final Thoughts

TOON isn’t replacing JSON — both have roles.

JSON	TOON
Best for machines & APIs	Best for LLM input payloads
Heavy syntax	Lightweight
Universal	Optimized for tokens

As LLM workloads scale, token efficiency becomes engineering.

TOON is a practical optimization worth exploring for real-world AI development.

⚠️ The SQL Query That Nearly Crashed Our Production Server

Chirag Patel — Tue, 28 Oct 2025 05:28:51 +0000

Launch day.
Traffic was peaking.
Dashboards were green.
Everything looked perfect… for about 10 minutes.

Then—boom.
Our site slowed to a crawl and went completely offline.

🚨 The Villain? A Single SQL Query

Here’s the innocent-looking line that brought our system to its knees:

SELECT * FROM orders WHERE status = 'pending';

In our development setup, this ran instantly.
Why wouldn’t it? We only had about 500 dummy records.

But in production, the story was very different:

Over 60,000+ orders
Each row around 12 KB (including customer info, items, metadata, and logs)
That’s roughly 720 MB being pulled into memory

And that one query triggered a chain reaction:

🧠 Memory pressure: DB tried to load hundreds of MB into RAM
🌐 Network choke: 700MB+ transferred across the wire = 30–40s latency
🔒 Connection lock: Slow queries kept DB connections occupied
💥 Concurrency collapse: Dozens of users triggered the same query = total overload All because of one tiny SELECT *.

Why `SELECT *` Is a Production Trap

It feels convenient — but it’s a ticking bomb under load.

Here’s why:

You fetch way more than needed: Images, logs, metadata — all pulled even if you don’t use them.
Schemas evolve silently: Add a new column later, and every query gets heavier without warning.
Indexes become less effective: The query planner can’t optimize wide rows efficiently.
Memory + bandwidth waste: Every unnecessary byte eats CPU cycles and RAM.
Concurrency death spiral: Multiply those inefficiencies by hundreds of simultaneous users = meltdown.

How We Fixed It (and What You Should Do Instead)

1. Select only what you need

SELECT id, customer_id, total_price
FROM orders
WHERE status = 'pending'
LIMIT 50 OFFSET 0;

Always be explicit. Pull only the fields you’ll actually use.

2. Paginate aggressively

Never fetch thousands of rows in a single request.
Use LIMIT + OFFSET or better — keyset pagination for large tables.

3. Cache frequent queries

If certain data is read-heavy (e.g., pending orders, popular products), store it in Redis or Memcached.
You’ll offload 70–80% of traffic from your database instantly.

4. Inspect with `EXPLAIN`

Before deploying, always check query plans:

EXPLAIN SELECT ...

You’ll quickly spot missing indexes or full table scans.

5. Enable slow query logs

Set up slow query logging in MySQL/Postgres.
Anything over 200ms deserves your attention.

6. Test at scale

Your dev DB with 500 records won’t expose real bottlenecks.
Clone anonymized production data or use synthetic generators.

7. Enforce query timeouts

Never allow one rogue query to monopolize resources forever.

Pre-Deployment Checklist 🧩

Before any SQL hits production, ask yourself:

Are you selecting only the columns you need?
Is pagination in place?
Are your WHERE/JOIN clauses indexed?
Have you tested on production-scale data?
Do you have slow query logs + timeouts enabled?

Bonus tip → Cache hot queries and watch your DB load drop by 80%+.

🧠 Key Takeaway

In production, every byte matters.
That one harmless-looking SELECT * might seem fine locally...
…but at scale, it can choke your entire system.

Build and test as if you already have a million users.
That mindset will save you more than any optimization later.

Have you ever faced a similar “small bug, massive blast radius” moment?
Drop your story below — let’s learn from each other’s war stories. 💬

Every Developer Should Know These Essential Project Files

Chirag Patel — Tue, 14 Oct 2025 07:07:50 +0000

Stop ignoring those config files! Whether you're building a simple React app or deploying a full-stack MERN application, understanding your project's essential files is the difference between a smooth workflow and configuration chaos.

Let's dive into the files that power modern frontend and full-stack development. 💪

📦 Package Management Files

`package.json` - Your Project's DNA

The heart of every Node.js project. This file defines your project metadata, dependencies, and scripts.

{
  "name": "my-awesome-app",
  "version": "1.0.0",
  "type": "module",
  "scripts": {
    "dev": "vite",
    "build": "vite build",
    "preview": "vite preview",
    "test": "vitest",
    "lint": "eslint . --ext js,jsx --report-unused-disable-directives --max-warnings 0"
  },
  "dependencies": {
    "react": "^18.3.1",
    "react-dom": "^18.3.1",
    "react-router-dom": "^6.26.0"
  },
  "devDependencies": {
    "@vitejs/plugin-react": "^4.3.1",
    "vite": "^5.4.2",
    "vitest": "^2.0.5"
  },
  "engines": {
    "node": ">=20.0.0",
    "npm": ">=10.0.0"
  }
}

🔥 Pro Tips:

Use "type": "module" for native ES6 modules
Specify engines to prevent version conflicts
Keep dependencies minimal - audit regularly with npm audit
Use exact versions in production (npm install --save-exact)

`package-lock.json` / `yarn.lock` / `pnpm-lock.yaml`

Lock files ensure everyone on your team installs the exact same dependency versions.

Lock File	Package Manager	Status
`package-lock.json`	npm	✅ Standard
`yarn.lock`	Yarn	✅ Popular
`pnpm-lock.yaml`	pnpm	🔥 Rising Star (fastest!)
`bun.lockb`	Bun	⚡ New & Blazing Fast

💡 Best Practice: Always commit your lock files to version control!

⚙️ Build Tool Configuration

`vite.config.js` - The Modern Choice

Vite has become the go-to build tool, replacing Create React App.

import { defineConfig } from 'vite'
import react from '@vitejs/plugin-react'
import path from 'path'

export default defineConfig({
  plugins: [react()],
  resolve: {
    alias: {
      '@': path.resolve(__dirname, './src'),
      '@components': path.resolve(__dirname, './src/components'),
      '@utils': path.resolve(__dirname, './src/utils')
    }
  },
  server: {
    port: 3000,
    proxy: {
      '/api': {
        target: 'http://localhost:5000',
        changeOrigin: true
      }
    }
  },
  build: {
    outDir: 'dist',
    sourcemap: true,
    rollupOptions: {
      output: {
        manualChunks: {
          vendor: ['react', 'react-dom', 'react-router-dom']
        }
      }
    }
  }
})

🎯 Why Vite?

Lightning-fast HMR (Hot Module Replacement)
Native ES modules support
Out-of-the-box TypeScript support
Optimized production builds with Rollup

`webpack.config.js` - The OG (Still Relevant)

const path = require('path');
const HtmlWebpackPlugin = require('html-webpack-plugin');

module.exports = {
  entry: './src/index.js',
  output: {
    path: path.resolve(__dirname, 'dist'),
    filename: '[name].[contenthash].js',
    clean: true
  },
  module: {
    rules: [
      {
        test: /\.(js|jsx)$/,
        exclude: /node_modules/,
        use: {
          loader: 'babel-loader'
        }
      },
      {
        test: /\.css$/,
        use: ['style-loader', 'css-loader', 'postcss-loader']
      }
    ]
  },
  plugins: [
    new HtmlWebpackPlugin({
      template: './public/index.html'
    })
  ]
}

🎨 Code Quality & Formatting

`.eslintrc.json` - Catch Bugs Before They Catch You

{
  "env": {
    "browser": true,
    "es2024": true,
    "node": true
  },
  "extends": [
    "eslint:recommended",
    "plugin:react/recommended",
    "plugin:react-hooks/recommended",
    "plugin:jsx-a11y/recommended"
  ],
  "parserOptions": {
    "ecmaVersion": "latest",
    "sourceType": "module",
    "ecmaFeatures": {
      "jsx": true
    }
  },
  "rules": {
    "react/react-in-jsx-scope": "off",
    "react/prop-types": "warn",
    "no-unused-vars": "warn",
    "no-console": ["warn", { "allow": ["warn", "error"] }]
  },
  "settings": {
    "react": {
      "version": "detect"
    }
  }
}

`.prettierrc` - Consistent Formatting, Zero Arguments

{
  "semi": true,
  "trailingComma": "es5",
  "singleQuote": true,
  "printWidth": 80,
  "tabWidth": 2,
  "useTabs": false,
  "arrowParens": "avoid",
  "endOfLine": "lf"
}

⚡ Combo: ESLint + Prettier + Husky = Code Quality Nirvana

`.prettierignore`

# Dependencies
node_modules
package-lock.json
yarn.lock

# Build outputs
dist
build
.next
out

# Cache
.cache
.parcel-cache

🔧 TypeScript Configuration

`tsconfig.json` - Type Safety FTW

TypeScript adoption continues to grow. Here's a modern config:

{
  "compilerOptions": {
    "target": "ES2022",
    "lib": ["ES2023", "DOM", "DOM.Iterable"],
    "module": "ESNext",
    "moduleResolution": "bundler",
    "resolveJsonModule": true,
    "allowJs": true,
    "checkJs": false,
    "jsx": "react-jsx",
    "strict": true,
    "noUnusedLocals": true,
    "noUnusedParameters": true,
    "noFallthroughCasesInSwitch": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "baseUrl": ".",
    "paths": {
      "@/*": ["./src/*"],
      "@components/*": ["./src/components/*"],
      "@hooks/*": ["./src/hooks/*"]
    }
  },
  "include": ["src"],
  "exclude": ["node_modules", "dist", "build"]
}

🌍 Environment Variables

`.env` Files - Keep Secrets Secret

# .env.local (never commit this!)
VITE_API_URL=http://localhost:5000/api
VITE_FIREBASE_API_KEY=your_actual_key_here
VITE_STRIPE_PUBLIC_KEY=pk_test_xxxxx

# Database
MONGODB_URI=mongodb://localhost:27017/myapp
JWT_SECRET=your_super_secret_key_here
PORT=5000
NODE_ENV=development

`.env.example` - Template for Team

# Copy this to .env.local and fill in your values
VITE_API_URL=
VITE_FIREBASE_API_KEY=
VITE_STRIPE_PUBLIC_KEY=

# Backend
MONGODB_URI=
JWT_SECRET=
PORT=5000
NODE_ENV=development

🚨 Critical: Always use environment-specific prefixes:

Vite: VITE_
Create React App: REACT_APP_
Next.js: NEXT_PUBLIC_ (for public vars)

🐳 Docker & Containerization

`Dockerfile` - Containerize Everything

# Multi-stage build for React app
FROM node:20-alpine AS builder

WORKDIR /app

COPY package*.json ./
RUN npm ci --only=production

COPY . .
RUN npm run build

# Production stage
FROM nginx:alpine

COPY --from=builder /app/dist /usr/share/nginx/html
COPY nginx.conf /etc/nginx/conf.d/default.conf

EXPOSE 80

CMD ["nginx", "-g", "daemon off;"]

`docker-compose.yml` - Full MERN Stack

version: '3.9'

services:
  # MongoDB
  mongodb:
    image: mongo:7
    restart: always
    ports:
      - "27017:27017"
    environment:
      MONGO_INITDB_ROOT_USERNAME: admin
      MONGO_INITDB_ROOT_PASSWORD: password
    volumes:
      - mongodb_data:/data/db

  # Backend (Node.js + Express)
  backend:
    build: ./server
    restart: always
    ports:
      - "5000:5000"
    environment:
      MONGODB_URI: mongodb://admin:password@mongodb:27017
      NODE_ENV: production
    depends_on:
      - mongodb
    volumes:
      - ./server:/app
      - /app/node_modules

  # Frontend (React)
  frontend:
    build: ./client
    restart: always
    ports:
      - "3000:80"
    depends_on:
      - backend

volumes:
  mongodb_data:

🚀 Deployment Configuration

`vercel.json` - Deploy React in Seconds

{
  "version": 2,
  "builds": [
    {
      "src": "package.json",
      "use": "@vercel/static-build",
      "config": {
        "distDir": "dist"
      }
    }
  ],
  "routes": [
    {
      "src": "/api/(.*)",
      "dest": "/api/$1"
    },
    {
      "src": "/(.*)",
      "dest": "/$1"
    }
  ],
  "rewrites": [
    {
      "source": "/((?!api).*)",
      "destination": "/index.html"
    }
  ]
}

`netlify.toml` - Another Popular Choice

[build]
  command = "npm run build"
  publish = "dist"

[[redirects]]
  from = "/*"
  to = "/index.html"
  status = 200

[build.environment]
  NODE_VERSION = "20"

[[headers]]
  for = "/*"
  [headers.values]
    X-Frame-Options = "DENY"
    X-XSS-Protection = "1; mode=block"
    X-Content-Type-Options = "nosniff"

`render.yaml` - Full-Stack MERN on Render

services:
  # Backend API
  - type: web
    name: api
    runtime: node
    buildCommand: cd server && npm install
    startCommand: cd server && npm start
    envVars:
      - key: NODE_ENV
        value: production
      - key: MONGODB_URI
        fromDatabase:
          name: mongodb
          property: connectionString

  # Frontend
  - type: web
    name: frontend
    runtime: static
    buildCommand: cd client && npm install && npm run build
    staticPublishPath: client/dist
    routes:
      - type: rewrite
        source: /*
        destination: /index.html

databases:
  - name: mongodb
    databaseName: myapp
    user: myapp_user

🔒 Security & Git

`.gitignore` - The Gatekeeper

# Dependencies
node_modules/
.pnp
.pnp.js

# Testing
coverage/
.nyc_output/

# Production
build/
dist/
.next/
out/

# Environment variables
.env
.env.local
.env.development.local
.env.test.local
.env.production.local

# Logs
npm-debug.log*
yarn-debug.log*
yarn-error.log*
.pnpm-debug.log*

# Editor
.vscode/
.idea/
*.swp
*.swo
*~

# OS
.DS_Store
Thumbs.db

# Misc
.cache/
.parcel-cache/
.turbo/

`.gitattributes` - Consistent Line Endings

* text=auto eol=lf
*.{cmd,[cC][mM][dD]} text eol=crlf
*.{bat,[bB][aA][tT]} text eol=crlf

🎯 Modern Frontend Essentials

`postcss.config.js` - CSS Superpowers

export default {
  plugins: {
    tailwindcss: {},
    autoprefixer: {},
    cssnano: process.env.NODE_ENV === 'production' ? {} : false
  }
}

`tailwind.config.js` - Utility-First CSS

/** @type {import('tailwindcss').Config} */
export default {
  content: [
    "./index.html",
    "./src/**/*.{js,ts,jsx,tsx}",
  ],
  theme: {
    extend: {
      colors: {
        brand: {
          50: '#f0f9ff',
          500: '#0ea5e9',
          900: '#0c4a6e',
        }
      },
      fontFamily: {
        sans: ['Inter var', 'sans-serif'],
      }
    },
  },
  plugins: [],
  darkMode: 'class'
}

🧪 Testing Configuration

`vitest.config.js` - Fast Unit Tests

import { defineConfig } from 'vitest/config'
import react from '@vitejs/plugin-react'

export default defineConfig({
  plugins: [react()],
  test: {
    environment: 'jsdom',
    globals: true,
    setupFiles: './src/test/setup.js',
    coverage: {
      provider: 'v8',
      reporter: ['text', 'json', 'html'],
      exclude: [
        'node_modules/',
        'src/test/',
      ]
    }
  }
})

`jest.config.js` - The Classic

export default {
  testEnvironment: 'jsdom',
  setupFilesAfterEnv: ['<rootDir>/src/setupTests.js'],
  moduleNameMapper: {
    '^@/(.*)$': '<rootDir>/src/$1',
    '\\.(css|less|scss|sass)$': 'identity-obj-proxy'
  },
  transform: {
    '^.+\\.(js|jsx|ts|tsx)$': ['@swc/jest']
  },
  collectCoverageFrom: [
    'src/**/*.{js,jsx,ts,tsx}',
    '!src/**/*.d.ts',
    '!src/**/*.stories.{js,jsx,ts,tsx}'
  ]
}

📊 Quick Reference Table

File	Purpose	Stack	Must Have?
`package.json`	Project metadata & dependencies	All	✅
`vite.config.js`	Build configuration	React/Vue	✅
`.eslintrc.json`	Code linting	All	✅
`.prettierrc`	Code formatting	All	✅
`tsconfig.json`	TypeScript config	TypeScript	✅
`.env`	Environment variables	All	✅
`.gitignore`	Git exclusions	All	✅
`Dockerfile`	Containerization	Production	🔶
`vercel.json`	Vercel deployment	Hosting	🔶
`docker-compose.yml`	Multi-container apps	MERN	🔶

Legend: ✅ Essential | 🔶 Recommended

💡 Why This Matters

Understanding these files isn't just about following conventions—it's about:

🏎️ Faster Onboarding: New team members can understand your project structure instantly
🐛 Fewer Bugs: Proper linting and TypeScript catch issues before they hit production
🚀 Smoother Deployments: Correct configuration files mean one-click deployments
🤝 Better Collaboration: Consistent formatting and structure reduce merge conflicts
📈 Scalability: Well-organized projects grow without becoming unmanageable

🎓 Final Thoughts

These configuration files might seem tedious, but they're the backbone of professional development. Start with the essentials (package.json, .gitignore, .eslintrc.json) and gradually add more as your project grows.

Remember: Good configuration is invisible. You set it up once, and it quietly makes your development life better every single day.

Now go forth and configure! 🚀

📚 Resources:

Have questions or tips to share? Drop them in the comments below! 👇

The Problem Every Developer Faces

Chirag Patel — Fri, 10 Oct 2025 07:00:56 +0000

You're coding late at night. Everything's working fine until... BAM! 💥

TypeError: Cannot read property 'map' of undefined

You know the drill:

Copy error message
Google it
Open 10 Stack Overflow tabs
Try random solutions
Still broken
Repeat...

Sound familiar?

What if You Could Just Screenshot the Error?

That's why I built AI Visual Debugger - a free tool where you:

📸 Screenshot your error
📝 Paste your code
🤖 Get AI-powered fix with explanation

No more tab-hopping. No more guessing.

Why It's Different

Most AI tools only read text. But when you're debugging, you're looking at:

Error messages on screen
Console output
Your actual code
Line numbers and file paths

This tool analyzes everything together - just like a real developer would.

How It Works

Step 1: Submit Your Error
Paste your logs, stack traces, or code snippets in the text area.

Step 2: Upload Screenshots
Drag and drop error screenshots (up to 6 files). The AI analyzes the visual context.

Step 3: Click "Analyze Error"
Let the AI do its magic in 2-5 seconds...

Step 4: Get Your Fix
You'll receive:

✅ Extracted Errors - Clear summary of error messages

🔍 Possible Causes - Likely reasons behind the error explained simply

🛠️ Fix Steps - Step-by-step guide with corrected code snippets

💡 Additional Notes - Best practices and tips to prevent future errors

Why Developers Will Love It

🎯 Context-Aware
Analyzes screenshots + code + logs together, not just text.

📚 Learn While Fixing
Explains WHY errors happen, not just HOW to fix them.

⚡ Lightning Fast
Get solutions in 2-5 seconds, not 2 hours.

🔒 100% Private

No data storage
No data sharing
Analysis-only processing

🆓 Completely Free
Open source. No subscriptions. Just need a free Gemini API key.

Try It Now (Takes 2 Minutes)

Option 1: Online (Easiest) 🌐

👉 Launch AI Visual Debugger

Works instantly in your browser. No installation needed.

Option 2: Run Locally 💻

# Clone the repo
git clone https://github.com/chiragpatel009/ai-visual-debugger.git
cd ai-visual-debugger

# Install
npm install

# Add your Gemini API key to .env.local
GEMINI_API_KEY=your_key_here

# Run
npm run dev

Get Free Gemini API Key: Google AI Studio

Pro Tips for Best Results

📸 Screenshot Tips
✅ Capture full error message
✅ Include line numbers and file names
✅ Show console output
❌ Don't crop important context

📝 Code Tips
✅ Paste complete function/component
✅ Include imports and dependencies
✅ Add comments about expected behaviour
❌ Don't send fragments without context

🔐 Security Tips
⚠️ Remove API keys before uploading
⚠️ Remove credentials and tokens
⚠️ Remove sensitive data

Who Is This For?

✅ Beginners learning to debug
✅ Bootcamp students stuck on projects
✅ Self-taught devs needing guidance
✅ Pro developers saving time
✅ Teams documenting bug fixes

What's Coming Next?

Based on feedback, I'm planning:

🔜 Multiple AI providers (OpenAI, Claude)
🔜 VS Code extension
🔜 Code diff visualization
🔜 Support for more languages
🔜 Team collaboration features

What would YOU want? 👇

I Need Your Help! 🙏

This is an early version and I want your feedback to make it better.

Try it and tell me:

✅ Did it help solve your error?
❌ What didn't work well?
💡 What features should I add?
🐛 Any bugs you found?

Comment below or open a GitHub Issue

Want to Contribute?

This is open source and contributions are welcome!

Ways to Help:

🐛 Report bugs
💡 Suggest features
🔧 Submit PRs
📖 Improve docs
⭐ Star the repo
🔄 Share with other devs

GitHub: https://github.com/chiragpatel009/ai-visual-debugger

Quick FAQ

Q: Is it really free?
A: Yes! 100% free. You just need a free Gemini API key.

Q: Is my code safe?
A: Absolutely. Nothing is stored or shared. Analysis only.

Q: Can I use it offline?
A: You need internet for AI analysis, but the app runs locally.

Q: What if the AI is wrong?
A: AI is helpful but not perfect. Always review suggestions. Report issues on GitHub.

Try It Right Now! 🚀

Don't waste another hour debugging.

👉 Live Demo: https://chiragpatel009.github.io/ai-visual-debugger/

⭐ GitHub: https://github.com/chiragpatel009/ai-visual-debugger

Your Turn!

Have you tried it? Drop a comment below with:

Your experience
Feature requests
Bugs you found
How it helped you

If you found this useful:

⭐ Star the repo
🔄 Share with a dev friend
💬 Leave feedback

Let's make debugging less painful together! 🐛✨

Built by a developer tired of debugging the old way. Questions? Feedback? Let's chat in the comments! 👇

7 Types of APIs Every Developer Should Know

Chirag Patel — Tue, 30 Sep 2025 06:10:19 +0000

APIs are the digital backbone of the internet. They power everything—from the apps on your phone to secure online banking.

But here’s the catch: not all APIs are the same. Just like people communicate in different ways, APIs also come in many forms. Knowing these differences helps you build faster, smarter, and more reliable applications.

In this guide, we’ll explore the most important API types, how they work, and when to use them.

What Is an API?

An API (Application Programming Interface) is like a digital waiter:

You (the app) place an order.
The API (the waiter) delivers the request to the kitchen (the server).
The kitchen prepares the food (data) and sends it back.

You don’t need to know how the kitchen works—you just get what you ordered.

That’s exactly how apps, websites, and servers communicate through APIs.

Common Types of APIs

Here are the API types every developer should know:

1. REST API

The most popular API style on the web.

Uses HTTP methods you already know:
- GET → retrieve data
- POST → create new data
- PUT → update data
- DELETE → remove data
Returns data in JSON (easy for apps to parse).
Stateless: every request is independent.
Platform-independent: works on mobile, web, or IoT devices.

👉 REST APIs are great for scalable, cross-platform apps.

2. SOAP API

The formal, rules-heavy API still used in industries like banking, healthcare, and government.

Messages are wrapped in XML.
Built-in support for:
- Security
- Error handling
- Transaction safety
Protocol independent (works over HTTP, SMTP, TCP, etc.).

👉 Use SOAP when reliability and security are more important than speed.

3. gRPC API

The Formula 1 race car of APIs, built by Google.

Uses Protocol Buffers (Protobuf) for super-fast binary data transfer.
Runs on HTTP/2, supporting multiple requests at once.
Communication patterns:
- Request → Response
- Server Streaming
- Client Streaming
- Bidirectional Streaming

👉 Perfect for real-time, high-performance apps (Netflix, Uber, trading systems).

4. GraphQL API

Created by Facebook to solve REST’s overfetching/underfetching problem.

Ask for exactly the data you need (no more, no less).
One endpoint, one request.
Supports real-time subscriptions.
Self-documenting with built-in query playgrounds.

👉 Great for front-end developers building fast apps on mobile and web.

5. WebHooks

The reverse API—instead of you asking the server for updates, the server pushes events to you.

Setup: provide a callback URL.
Example uses:
- GitHub → notify when code is pushed.
- Shopify → alert when an order is placed.
- Slack bots → respond to events instantly.

👉 WebHooks are efficient for real-time notifications and automation.

6. WebSockets

Think of this as a permanent phone line between client and server.

Starts with an HTTP handshake, then stays open.
Two-way, real-time communication.
Supports text, JSON, and even binary data.

👉 Ideal for:

Live chat apps
Multiplayer games
Stock/crypto dashboards
Collaborative editors

7. WebRTC

A full framework for peer-to-peer communication.

Powers video calls, file sharing, and real-time collaboration.
Works directly between devices—no central server needed.
Adapts quality based on internet speed.

👉 The foundation of tools like Zoom, Google Meet, and online gaming.

Conclusion

APIs are the invisible engine of the internet.

REST: scalable and simple.
SOAP: secure and reliable.
gRPC: ultra-fast and real-time.
GraphQL: precise and flexible.
WebHooks: instant event delivery.
WebSockets: continuous live updates.
WebRTC: peer-to-peer communication.

Each type has its place. Choosing the right API depends on what you’re building—whether it’s a mobile app, enterprise system, or real-time multiplayer game.

The more you understand these API types, the better you’ll be at designing modern, connected applications.

KendoReact: How to Activate 30-Day Free Trial License Key (Remove Watermark Guide)

Chirag Patel — Tue, 23 Sep 2025 05:37:03 +0000

If you’ve added KendoReact components to your React project and noticed a watermark, it means you’re using a paid component without activating a license. Don’t worry — Telerik provides a 30-day free trial license so you can explore all premium components with full functionality and a clean UI.

This post will guide you through the simple steps to activate the license and get rid of the watermark.

Why You Need to Activate the License

KendoReact has two tiers:

Free tier – 50+ free components.
Paid tier – 120+ premium components (requires a license).

If you use a paid component without activating a license, you’ll see a watermark. Activating the trial license gives you 30 days of full premium access.

Steps to Activate the 30-Day Trial License Key

1. Log in to Your Telerik Account

Go to Telerik Account.
If you don’t have one, create a free account.

2. Start Your Free Trial

In your Telerik account, go to Your Licenses.
There, you will see the License Keys section.

3. Download Your License Key

Click on 'Download License Key' button.
The downloaded file will be named telerik-license.txt.
Place it in your project’s root folder (where package.json is located).

Alternatively, you can copy the license key’s contents into an environment variable named TELERIK_LICENSE.

4. Install the Licensing Package
In your project, install the licensing package:

npm install @progress/kendo-licensing

(or)

yarn add @progress/kendo-licensing

5. Activate the License
Run the activation command in your project root:

npx kendo-ui-license activate

(or)

yarn run kendo-ui-license activate

6. Verify Activation

Restart your dev server.
The watermark should now be gone.
If issues persist, try cleaning your project by running:

rm -rf node_modules package-lock.json
npm install

Then re-run the activation command.

Final Thoughts

By following these steps, you’ll:

Remove the trial watermark.
Unlock all KendoReact premium components for 30 days.
Give your project a more professional and polished UI.

👉 Official documentation: Activate KendoReact License

Happy coding! 🚀

Encoding, Hashing, and Encryption: Clearing Up the Confusion

Chirag Patel — Mon, 22 Sep 2025 09:29:07 +0000

Many people, even experienced software engineers, sometimes mix up the terms Encoding, Hashing, and Encryption. These concepts are important for how data works online, from how your web browser shows information to how your passwords stay safe. This guide will break down each concept, show you how they are different, and explain why they are all vital in our digital world. By the end, you will understand their real-life uses and never confuse them again.

What is Encoding?

Think about the last time you typed something into a search engine. You might have noticed that your web browser changed your search query slightly in the address bar. For example, a space often turns into %20, and a question mark becomes %3F. This happens because URLs (web addresses) can only use a limited set of characters. Spaces and other symbols are not part of this allowed set. So, the browser transforms your input into a format that the web can understand and send.

This type of transformation is called encoding. Encoding changes data from one form to another. Its main purpose is to make sure data can be stored or transmitted correctly, especially when moving between different systems. The original data must fit into a character set that all systems agree on.

Encoding is not just for URLs. You can convert text like "HELLO" into many forms. These include:

Binary: A series of 0s and 1s, which computers understand directly.
Hexadecimal: A system that uses 16 symbols (0-9 and A-F), often used for its compact way of representing numbers.
Base64: A common encoding scheme that turns binary data into an ASCII string format, often used for embedding images or other files within text.

How We Use Encoding Every Day
Encoding plays a hidden role in many daily tasks. For instance, if you work with website design using CSS, you often see color codes for websites. These color values, which specify red, green, and blue (RGB), are usually written in hexadecimal. This makes the codes much shorter and easier to handle than writing them out in decimal numbers.

Another example comes from HTML, the language for building web pages. When you add images, you usually link to where the image file is stored. But for very small images, developers can embed the image directly into the HTML or CSS code using the Base64 format. This avoids an extra step where the browser has to request the image file separately, making the page load faster.

The most important thing to remember about encoding is that it is always reversible. Anyone who sees %20 in a URL can easily decode it back to a space. Encoding is about changing how data looks for proper handling, not about keeping it secret. It focuses on the structure and readability of data for machines. Examples of encoding standards include UTF8, binary, hexadecimal, and Base64.

What is Hashing?

Now, let's talk about a concept often confused with encoding, but with a very different purpose: hashing. Whenever you create an account online, the password you choose is never stored directly as plain text. Instead, it gets changed into a fixed-length string of characters. This new string is called a hash. From this hash alone, it is impossible to figure out what the original password was.

This one-way transformation comes from a process called hashing. Hashing uses a special mathematical formula, known as a hashing algorithm, to convert any piece of data into a unique, fixed-size output. This process is designed to be irreversible. So, when you log in, the password you type is hashed again. The system then compares this new hash to the one it has stored. If they match, you are granted access.

Hashing has three key characteristics:
1. One-Way: You cannot reverse a hash to get the original data back. It is a one-way street.
2. Deterministic: The same input will always produce the exact same hash output. If you hash the word "password" twice using the same algorithm, you will get the identical hash both times.
3. Fixed-Length: No matter how long your original data is (a short word or a long document), the hash it produces will always be the same specific length.

Hashing is not just for passwords. It has other important uses. For example, when you download a file, you might see a hash provided for it. After your download finishes, you can generate a hash of the file you received. If your calculated hash matches the original hash, you know the file is complete and has not been damaged or changed during download. If the hashes do not match, the file is corrupt.

What is Encryption?

What if you need a transformation that is not one-way like hashing, but two-way, meaning you can get the original data back, but only for certain people or systems? This is where encryption comes in.

Imagine you have a private document on your computer. Without any protection, anyone who gets access to your computer can read it. Encryption changes your document or data into a scrambled, unreadable form. To turn it back into its original, readable state, you need a special piece of information called a key. Only someone with the correct key can unlock and read the data. If someone tries to open the encrypted document without the key, they will only see gibberish.

One of the earliest and simplest examples of encryption dates back over 2,000 years to Julius Caesar. He used a basic method called the Caesar Cipher, also known as the Shift Cipher. The idea was simple: shift each letter in the message by a fixed number of positions in the alphabet. For instance, if the shift was three positions, "H" would become "K," "E" would become "H," and so on. So, "HELLO" would become "KHOOR." To anyone intercepting this message without knowing the shift, it looked like nonsense. But a recipient who knew the shift was "three" could easily reverse the process and decrypt the message back to "HELLO."

While the Caesar Cipher is very easy to crack with today's computers, it perfectly shows the main idea of encryption: the message is only readable by someone who has the key.

Modern encryption is much more complex. Instead of simple letter shifts, it uses advanced mathematical algorithms designed to be extremely difficult to break without the right key, even with powerful computers. Think about how you send messages on apps like WhatsApp. Every message you send is encrypted on your device before it even leaves your phone. If someone tries to listen in on the network, they will only see jumbled, meaningless data. Only the person you are messaging, who has the matching decryption key, can turn that noise back into your actual words. This is how secure messaging apps protect your conversations, keeping them private even from their own servers.

Encryption is all about confidentiality. It locks your data in a way that only the right key can unlock it, making sure that sensitive information stays private.

Comparing Encoding, Hashing, and Encryption

Feature	Encoding	Hashing	Encryption
Purpose	Data format for transmission/storage	Data integrity check, password storage	Confidentiality, secure communication
Reversibility	Always reversible	Not reversible (one-way)	Reversible (with the correct key)
Security	Not for security; provides no secrecy	Provides integrity; protects original data	Provides secrecy; protects data content
Output Length	Varies depending on original data and format	Fixed length, regardless of input size	Varies depending on original data and key
Key Use	No key involved	No key involved (uses an algorithm)	Requires a key for decryption
Example	URL encoding (%20), Base64, Hexadecimal	Password storage, file integrity checks	Secure messages (WhatsApp), sensitive documents

As you can see, encoding is like translating data into another language so computers can handle it properly. It is not about secrecy; it is about proper representation. Hashing is like creating a unique digital fingerprint for your data. This fingerprint does not reveal the original data and cannot be traced back. It is perfect for checking if data has been tampered with or for securely storing passwords. Encryption is about making your data private. It scrambles the data, but only temporarily. You can always get the original data back if you have the right key. This makes it ideal for securing communications and private information.

Conclusion

Understanding the differences between encoding, hashing, and encryption is vital in today's digital world. While all three involve transforming data, they serve distinct purposes. Encoding focuses on making data usable across systems. Hashing ensures data integrity and offers one-way protection for things like passwords. Encryption provides confidentiality, securing data so only authorized users with the right key can access it.

These concepts are fundamental to many technologies you use every day, from browsing the web to sending secure messages. Knowing how they work helps you better understand the digital protections in place and why they are so important. By grasping these engineering basics, you are better prepared to navigate and contribute to the secure and functional online environment of 2025.

DEV Community: Chirag Patel

Build a Rule-Based Product Tag Manager in Laravel 12.x — Step-by-Step Guide

🧱 Tech Stack

Step 1 — Create the Project

Step 2 — Migrations

Step 3 — Models

Step 4 — Resource Controllers

Step 5 — Routes

Step 6 — Blade Views

Master Layout — layouts/app.blade.php

Product Manager Views

Rule Manager Views

Step 7 — Storage Link for Images

Step 8 — Run & Test

Step 9 — Push to GitHub

How the Rule Engine Works

File Structure

🎮 Why Simple Web Games Still Work (and What I Learned Building One)

What Makes Simple Web Games Addictive?

My Experiment: Turning Frustration Into a Game

🧠 What I Learned While Building It

🚀 Sharing It & Getting Real Feedback

Final Thoughts

🚀 How to Install Supabase CLI on Windows (The Right Way) — A Simple Guide for Everyone

Why Supabase CLI Matters

Why Does npm install -g supabase Fail?

What is Scoop (and Why Windows Developers Need It?)

Step 1 — Enable Script Permissions

Step 2 — Install Scoop

Step 3 — Install Supabase CLI

Step 4 — Log in to Supabase

Step 5 — Link Your Local Project

Step 6 — Push Migrations to Your Remote Supabase

🎉 You're Ready to Work with Supabase on Windows

⭐ Extra Tips for Developers

💬 Final Thoughts

Fix Angular and Node Version Mismatch Using NVM on Windows

Why This Happens

Step 1: Check Current Node Version

Step 2: Check Installed Node Versions

Step 3: Switch to the Required Node Version

Step 4: Fix PATH Conflicts on Windows

To fix:

Step 5: Install the Matching Angular CLI Version

Step 6: Run the Project

💡 Bonus Tip: Use .nvmrc for Per-Project Node Version Management

🎯 Conclusion

How to Set Up a Laravel Project on Local After Clone

1. Clone the Laravel Project

2. Install PHP Dependencies

3. Create .env File

4. Generate Application Key

5. Run Database Migrations (If applicable)

6. Link Storage (For uploads & images)

7. Install Node Dependencies (If project has frontend)

8. Serve the Project

🧠 Common Errors & Fixes

✅ Final Checklist

🎯 Conclusion

💬 Have Questions?

🔁 Bonus: Full Setup Script (Linux/Mac)

Stop Sending JSON to LLMs - Try This Instead

What is TOON?

Example

Why TOON Matters

Token Comparison (Real Test)

Example Workflow

⚠️ Important — TOON Works Best With Flat Data

When to Use TOON

Final Thoughts

⚠️ The SQL Query That Nearly Crashed Our Production Server

🚨 The Villain? A Single SQL Query

Why SELECT * Is a Production Trap

How We Fixed It (and What You Should Do Instead)

1. Select only what you need

2. Paginate aggressively

3. Cache frequent queries

4. Inspect with EXPLAIN

5. Enable slow query logs

6. Test at scale

Master Layout — `layouts/app.blade.php`

Why Does `npm install -g supabase` Fail?

3. Create `.env` File

Why `SELECT *` Is a Production Trap

4. Inspect with `EXPLAIN`

`package.json` - Your Project's DNA

`package-lock.json` / `yarn.lock` / `pnpm-lock.yaml`

`vite.config.js` - The Modern Choice

`webpack.config.js` - The OG (Still Relevant)

`.eslintrc.json` - Catch Bugs Before They Catch You

`.prettierrc` - Consistent Formatting, Zero Arguments

`.prettierignore`

`tsconfig.json` - Type Safety FTW

`.env` Files - Keep Secrets Secret

`.env.example` - Template for Team

`Dockerfile` - Containerize Everything

`docker-compose.yml` - Full MERN Stack

`vercel.json` - Deploy React in Seconds

`netlify.toml` - Another Popular Choice

`render.yaml` - Full-Stack MERN on Render

`.gitignore` - The Gatekeeper

`.gitattributes` - Consistent Line Endings

`postcss.config.js` - CSS Superpowers

`tailwind.config.js` - Utility-First CSS

`vitest.config.js` - Fast Unit Tests

`jest.config.js` - The Classic