Building an E-Commerce Website with Laravel: Complete Step-by-Step Guide
E-commerce is the most requested project type for PHP Laravel developers in Nepal and globally. Whether you are a freelancer building online stores for clients or a developer joining a company that sells products online, knowing how to build an e-commerce application with Laravel is a career-defining skill. This guide walks you through building a complete e-commerce website from scratch, covering everything from database design and product management to shopping cart functionality, checkout processing, and order management. By the end, you will have a working e-commerce application that demonstrates production-level Laravel skills and serves as a powerful portfolio piece for job applications or client pitches.
How Do You Set Up a Laravel Project for E-Commerce?
Set up a Laravel e-commerce project by installing Laravel with Composer, configuring your database connection, installing authentication scaffolding with Breeze, and adding essential packages for image handling, payment processing, and search functionality.
Start with a fresh Laravel installation and the packages you will need:
# Create new Laravel project
composer create-project laravel/laravel ecommerce-store
cd ecommerce-store
# Install authentication scaffolding
composer require laravel/breeze --dev
php artisan breeze:install blade
# Install essential packages
composer require intervention/image # Image processing
composer require darryldecode/cart # Shopping cart
composer require spatie/laravel-sluggable # URL slugs
composer require spatie/laravel-medialibrary # Media management
# Configure database in .env
# DB_CONNECTION=mysql
# DB_HOST=127.0.0.1
# DB_PORT=3306
# DB_DATABASE=ecommerce_store
# DB_USERNAME=root
# DB_PASSWORD=
# Run migrations
php artisan migrate
# Install frontend dependencies
npm install && npm run build
Your project structure should follow Laravel conventions with additional organization for e-commerce logic:
app/
├── Http/
│ ├── Controllers/
│ │ ├── ProductController.php
│ │ ├── CartController.php
│ │ ├── CheckoutController.php
│ │ ├── OrderController.php
│ │ └── Admin/
│ │ ├── ProductController.php
│ │ └── OrderController.php
│ └── Middleware/
│ └── AdminMiddleware.php
├── Models/
│ ├── Product.php
│ ├── Category.php
│ ├── Order.php
│ ├── OrderItem.php
│ └── User.php
└── Services/
├── CartService.php
└── OrderService.php
How Do You Design the Database Schema for E-Commerce?
Design the e-commerce database with tables for products, categories, orders, order items, and users, using proper relationships, indexes, and data types that support filtering, searching, and reporting efficiently.
The database design is the foundation of your e-commerce application. Get this right and everything else becomes easier:
// database/migrations/create_categories_table.php
public function up(): void
{
Schema::create('categories', function (Blueprint $table) {
$table->id();
$table->string('name');
$table->string('slug')->unique();
$table->text('description')->nullable();
$table->string('image')->nullable();
$table->foreignId('parent_id')->nullable()->constrained('categories')->nullOnDelete();
$table->boolean('is_active')->default(true);
$table->integer('sort_order')->default(0);
$table->timestamps();
});
}
// database/migrations/create_products_table.php
public function up(): void
{
Schema::create('products', function (Blueprint $table) {
$table->id();
$table->string('name');
$table->string('slug')->unique();
$table->text('description');
$table->text('short_description')->nullable();
$table->decimal('price', 10, 2);
$table->decimal('compare_price', 10, 2)->nullable();
$table->string('sku')->unique();
$table->integer('stock')->default(0);
$table->foreignId('category_id')->constrained()->cascadeOnDelete();
$table->boolean('is_active')->default(true);
$table->boolean('is_featured')->default(false);
$table->json('attributes')->nullable();
$table->timestamps();
$table->index(['is_active', 'is_featured']);
$table->index('price');
});
}
// database/migrations/create_orders_table.php
public function up(): void
{
Schema::create('orders', function (Blueprint $table) {
$table->id();
$table->string('order_number')->unique();
$table->foreignId('user_id')->constrained()->cascadeOnDelete();
$table->enum('status', ['pending', 'processing', 'shipped', 'delivered', 'cancelled'])
->default('pending');
$table->decimal('subtotal', 10, 2);
$table->decimal('shipping_cost', 10, 2)->default(0);
$table->decimal('tax', 10, 2)->default(0);
$table->decimal('total', 10, 2);
$table->string('shipping_name');
$table->string('shipping_phone');
$table->text('shipping_address');
$table->string('shipping_city');
$table->string('payment_method');
$table->string('payment_status')->default('pending');
$table->text('notes')->nullable();
$table->timestamps();
});
Schema::create('order_items', function (Blueprint $table) {
$table->id();
$table->foreignId('order_id')->constrained()->cascadeOnDelete();
$table->foreignId('product_id')->constrained();
$table->string('product_name');
$table->decimal('price', 10, 2);
$table->integer('quantity');
$table->decimal('total', 10, 2);
$table->timestamps();
});
}
Now create the Eloquent models with relationships:
// app/Models/Product.php
namespace App\Models;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\BelongsTo;
use Spatie\Sluggable\HasSlug;
use Spatie\Sluggable\SlugOptions;
class Product extends Model
{
use HasSlug;
protected $fillable = [
'name', 'slug', 'description', 'short_description',
'price', 'compare_price', 'sku', 'stock',
'category_id', 'is_active', 'is_featured', 'attributes',
];
protected $casts = [
'price' => 'decimal:2',
'compare_price' => 'decimal:2',
'is_active' => 'boolean',
'is_featured' => 'boolean',
'attributes' => 'array',
];
public function getSlugOptions(): SlugOptions
{
return SlugOptions::create()
->generateSlugsFrom('name')
->saveSlugsTo('slug');
}
public function category(): BelongsTo
{
return $this->belongsTo(Category::class);
}
public function isInStock(): bool
{
return $this->stock > 0;
}
public function hasDiscount(): bool
{
return $this->compare_price && $this->compare_price > $this->price;
}
public function discountPercentage(): int
{
if (!$this->hasDiscount()) return 0;
return (int) round(
(($this->compare_price - $this->price) / $this->compare_price) * 100
);
}
public function scopeActive($query)
{
return $query->where('is_active', true);
}
public function scopeFeatured($query)
{
return $query->where('is_featured', true);
}
public function scopeInStock($query)
{
return $query->where('stock', '>', 0);
}
}
// app/Models/Order.php
namespace App\Models;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\BelongsTo;
use Illuminate\Database\Eloquent\Relations\HasMany;
class Order extends Model
{
protected $fillable = [
'order_number', 'user_id', 'status', 'subtotal',
'shipping_cost', 'tax', 'total', 'shipping_name',
'shipping_phone', 'shipping_address', 'shipping_city',
'payment_method', 'payment_status', 'notes',
];
public static function generateOrderNumber(): string
{
return 'ORD-' . date('Ymd') . '-' . strtoupper(substr(uniqid(), -6));
}
public function user(): BelongsTo
{
return $this->belongsTo(User::class);
}
public function items(): HasMany
{
return $this->hasMany(OrderItem::class);
}
}
How Do You Build the Product Listing and Search?
Build product listings with Laravel's Eloquent query builder using scopes for filtering, pagination for performance, eager loading to prevent N+1 queries, and full-text search for finding products by name and description.
// app/Http/Controllers/ProductController.php
namespace App\Http\Controllers;
use App\Models\Product;
use App\Models\Category;
use Illuminate\Http\Request;
class ProductController extends Controller
{
public function index(Request $request)
{
$query = Product::active()->inStock()->with('category');
// Category filter
if ($request->filled('category')) {
$query->whereHas('category', function ($q) use ($request) {
$q->where('slug', $request->category);
});
}
// Price range filter
if ($request->filled('min_price')) {
$query->where('price', '>=', $request->min_price);
}
if ($request->filled('max_price')) {
$query->where('price', '<=', $request->max_price);
}
// Search
if ($request->filled('search')) {
$search = $request->search;
$query->where(function ($q) use ($search) {
$q->where('name', 'like', "%{$search}%")
->orWhere('description', 'like', "%{$search}%")
->orWhere('sku', 'like', "%{$search}%");
});
}
// Sorting
$sortField = $request->get('sort', 'created_at');
$sortDirection = $request->get('direction', 'desc');
$allowedSorts = ['price', 'name', 'created_at'];
if (in_array($sortField, $allowedSorts)) {
$query->orderBy($sortField, $sortDirection);
}
$products = $query->paginate(12)->withQueryString();
$categories = Category::active()->withCount('products')->get();
return view('products.index', compact('products', 'categories'));
}
public function show(string $slug)
{
$product = Product::where('slug', $slug)
->active()
->with('category')
->firstOrFail();
$relatedProducts = Product::active()
->inStock()
->where('category_id', $product->category_id)
->where('id', '!=', $product->id)
->limit(4)
->get();
return view('products.show', compact('product', 'relatedProducts'));
}
}
How Do You Implement a Shopping Cart in Laravel?
Implement a shopping cart using either session-based storage for guest users or database storage for authenticated users, with methods to add, update, remove items, and calculate totals including taxes and shipping costs.
// app/Services/CartService.php
namespace App\Services;
use App\Models\Product;
use Illuminate\Support\Collection;
use Illuminate\Support\Facades\Session;
class CartService
{
private string $sessionKey = 'shopping_cart';
public function getItems(): Collection
{
return collect(Session::get($this->sessionKey, []));
}
public function addItem(int $productId, int $quantity = 1): void
{
$product = Product::findOrFail($productId);
if (!$product->isInStock()) {
throw new \Exception('Product is out of stock.');
}
$cart = $this->getItems();
$existingItem = $cart->firstWhere('product_id', $productId);
if ($existingItem) {
$newQuantity = $existingItem['quantity'] + $quantity;
if ($newQuantity > $product->stock) {
throw new \Exception("Only {$product->stock} items available.");
}
$cart = $cart->map(function ($item) use ($productId, $newQuantity) {
if ($item['product_id'] === $productId) {
$item['quantity'] = $newQuantity;
$item['total'] = $item['price'] * $newQuantity;
}
return $item;
});
} else {
$cart->push([
'product_id' => $product->id,
'name' => $product->name,
'price' => $product->price,
'quantity' => $quantity,
'total' => $product->price * $quantity,
'image' => $product->image,
]);
}
Session::put($this->sessionKey, $cart->toArray());
}
public function updateQuantity(int $productId, int $quantity): void
{
$product = Product::findOrFail($productId);
if ($quantity > $product->stock) {
throw new \Exception("Only {$product->stock} items available.");
}
if ($quantity <= 0) {
$this->removeItem($productId);
return;
}
$cart = $this->getItems()->map(function ($item) use ($productId, $quantity) {
if ($item['product_id'] === $productId) {
$item['quantity'] = $quantity;
$item['total'] = $item['price'] * $quantity;
}
return $item;
});
Session::put($this->sessionKey, $cart->toArray());
}
public function removeItem(int $productId): void
{
$cart = $this->getItems()->reject(function ($item) use ($productId) {
return $item['product_id'] === $productId;
});
Session::put($this->sessionKey, $cart->values()->toArray());
}
public function getSubtotal(): float
{
return $this->getItems()->sum('total');
}
public function getShippingCost(): float
{
$subtotal = $this->getSubtotal();
// Free shipping over NPR 5000
return $subtotal >= 5000 ? 0 : 150;
}
public function getTax(): float
{
// 13% VAT in Nepal
return round($this->getSubtotal() * 0.13, 2);
}
public function getTotal(): float
{
return $this->getSubtotal() + $this->getShippingCost() + $this->getTax();
}
public function getItemCount(): int
{
return $this->getItems()->sum('quantity');
}
public function clear(): void
{
Session::forget($this->sessionKey);
}
}
// app/Http/Controllers/CartController.php
namespace App\Http\Controllers;
use App\Services\CartService;
use Illuminate\Http\Request;
class CartController extends Controller
{
public function __construct(private CartService $cartService) {}
public function index()
{
$items = $this->cartService->getItems();
$subtotal = $this->cartService->getSubtotal();
$shipping = $this->cartService->getShippingCost();
$tax = $this->cartService->getTax();
$total = $this->cartService->getTotal();
return view('cart.index', compact('items', 'subtotal', 'shipping', 'tax', 'total'));
}
public function add(Request $request)
{
$request->validate([
'product_id' => 'required|exists:products,id',
'quantity' => 'integer|min:1|max:10',
]);
try {
$this->cartService->addItem(
$request->product_id,
$request->get('quantity', 1)
);
return back()->with('success', 'Product added to cart!');
} catch (\Exception $e) {
return back()->with('error', $e->getMessage());
}
}
public function update(Request $request, int $productId)
{
$request->validate(['quantity' => 'required|integer|min:0|max:10']);
try {
$this->cartService->updateQuantity($productId, $request->quantity);
return back()->with('success', 'Cart updated!');
} catch (\Exception $e) {
return back()->with('error', $e->getMessage());
}
}
public function remove(int $productId)
{
$this->cartService->removeItem($productId);
return back()->with('success', 'Item removed from cart.');
}
}
How Do You Build the Checkout and Order Processing?
Build checkout by collecting shipping information through a validated form, creating an order record with associated items, reducing product stock, clearing the cart, and sending confirmation notifications to the customer.
// app/Http/Controllers/CheckoutController.php
namespace App\Http\Controllers;
use App\Models\Order;
use App\Models\OrderItem;
use App\Models\Product;
use App\Services\CartService;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;
class CheckoutController extends Controller
{
public function __construct(private CartService $cartService)
{
$this->middleware('auth');
}
public function index()
{
$items = $this->cartService->getItems();
if ($items->isEmpty()) {
return redirect()->route('cart.index')
->with('error', 'Your cart is empty.');
}
return view('checkout.index', [
'items' => $items,
'subtotal' => $this->cartService->getSubtotal(),
'shipping' => $this->cartService->getShippingCost(),
'tax' => $this->cartService->getTax(),
'total' => $this->cartService->getTotal(),
]);
}
public function process(Request $request)
{
$validated = $request->validate([
'shipping_name' => 'required|string|max:255',
'shipping_phone' => 'required|string|max:20',
'shipping_address' => 'required|string|max:500',
'shipping_city' => 'required|string|max:100',
'payment_method' => 'required|in:cod,esewa,khalti',
'notes' => 'nullable|string|max:1000',
]);
$items = $this->cartService->getItems();
if ($items->isEmpty()) {
return redirect()->route('cart.index')
->with('error', 'Your cart is empty.');
}
try {
$order = DB::transaction(function () use ($validated, $items) {
// Verify stock availability
foreach ($items as $item) {
$product = Product::lockForUpdate()->find($item['product_id']);
if (!$product || $product->stock < $item['quantity']) {
throw new \Exception(
"Sorry, {$item['name']} does not have enough stock."
);
}
}
// Create order
$order = Order::create([
'order_number' => Order::generateOrderNumber(),
'user_id' => auth()->id(),
'subtotal' => $this->cartService->getSubtotal(),
'shipping_cost' => $this->cartService->getShippingCost(),
'tax' => $this->cartService->getTax(),
'total' => $this->cartService->getTotal(),
'shipping_name' => $validated['shipping_name'],
'shipping_phone' => $validated['shipping_phone'],
'shipping_address' => $validated['shipping_address'],
'shipping_city' => $validated['shipping_city'],
'payment_method' => $validated['payment_method'],
'notes' => $validated['notes'] ?? null,
]);
// Create order items and reduce stock
foreach ($items as $item) {
OrderItem::create([
'order_id' => $order->id,
'product_id' => $item['product_id'],
'product_name' => $item['name'],
'price' => $item['price'],
'quantity' => $item['quantity'],
'total' => $item['total'],
]);
Product::where('id', $item['product_id'])
->decrement('stock', $item['quantity']);
}
return $order;
});
// Clear the cart after successful order
$this->cartService->clear();
return redirect()->route('orders.confirmation', $order->order_number)
->with('success', 'Order placed successfully!');
} catch (\Exception $e) {
return back()->with('error', $e->getMessage());
}
}
}
How Do You Build an Admin Panel for Managing Products and Orders?
Build the admin panel using Laravel's built-in features or Filament for rapid development, with CRUD operations for products, order management with status updates, sales dashboard with analytics, and role-based access control.
// app/Http/Controllers/Admin/ProductController.php
namespace App\Http\Controllers\Admin;
use App\Http\Controllers\Controller;
use App\Models\Product;
use App\Models\Category;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Storage;
class ProductController extends Controller
{
public function index(Request $request)
{
$products = Product::with('category')
->when($request->search, function ($query, $search) {
$query->where('name', 'like', "%{$search}%")
->orWhere('sku', 'like', "%{$search}%");
})
->when($request->category, function ($query, $categoryId) {
$query->where('category_id', $categoryId);
})
->latest()
->paginate(20);
$categories = Category::all();
return view('admin.products.index', compact('products', 'categories'));
}
public function store(Request $request)
{
$validated = $request->validate([
'name' => 'required|string|max:300',
'description' => 'required|string',
'short_description' => 'nullable|string|max:500',
'price' => 'required|numeric|min:0',
'compare_price' => 'nullable|numeric|min:0',
'sku' => 'required|string|unique:products,sku',
'stock' => 'required|integer|min:0',
'category_id' => 'required|exists:categories,id',
'image' => 'nullable|image|mimes:jpg,png,webp|max:2048',
'is_active' => 'boolean',
'is_featured' => 'boolean',
]);
if ($request->hasFile('image')) {
$validated['image'] = $request->file('image')
->store('products', 'public');
}
Product::create($validated);
return redirect()->route('admin.products.index')
->with('success', 'Product created successfully!');
}
public function update(Request $request, Product $product)
{
$validated = $request->validate([
'name' => 'required|string|max:300',
'description' => 'required|string',
'price' => 'required|numeric|min:0',
'compare_price' => 'nullable|numeric|min:0',
'sku' => "required|string|unique:products,sku,{$product->id}",
'stock' => 'required|integer|min:0',
'category_id' => 'required|exists:categories,id',
'image' => 'nullable|image|mimes:jpg,png,webp|max:2048',
'is_active' => 'boolean',
'is_featured' => 'boolean',
]);
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('admin.products.index')
->with('success', 'Product updated successfully!');
}
}
Set up the routes for your entire e-commerce application:
// routes/web.php
use App\Http\Controllers\ProductController;
use App\Http\Controllers\CartController;
use App\Http\Controllers\CheckoutController;
use App\Http\Controllers\OrderController;
use App\Http\Controllers\Admin\ProductController as AdminProductController;
use App\Http\Controllers\Admin\OrderController as AdminOrderController;
// Public routes
Route::get('/', [ProductController::class, 'index'])->name('home');
Route::get('/products', [ProductController::class, 'index'])->name('products.index');
Route::get('/products/{slug}', [ProductController::class, 'show'])->name('products.show');
// Cart routes
Route::prefix('cart')->name('cart.')->group(function () {
Route::get('/', [CartController::class, 'index'])->name('index');
Route::post('/add', [CartController::class, 'add'])->name('add');
Route::patch('/{productId}', [CartController::class, 'update'])->name('update');
Route::delete('/{productId}', [CartController::class, 'remove'])->name('remove');
});
// Authenticated routes
Route::middleware('auth')->group(function () {
Route::get('/checkout', [CheckoutController::class, 'index'])->name('checkout.index');
Route::post('/checkout', [CheckoutController::class, 'process'])->name('checkout.process');
Route::get('/orders', [OrderController::class, 'index'])->name('orders.index');
Route::get('/orders/{orderNumber}', [OrderController::class, 'show'])->name('orders.confirmation');
});
// Admin routes
Route::middleware(['auth', 'admin'])->prefix('admin')->name('admin.')->group(function () {
Route::resource('products', AdminProductController::class);
Route::resource('orders', AdminOrderController::class)->only(['index', 'show', 'update']);
});
What the Reddit Community Says
E-commerce with Laravel is one of the most discussed topics on r/laravel. The community strongly recommends building from scratch for learning purposes: "Every developer should build an e-commerce system at least once. It teaches you about transactions, race conditions, inventory management, and payment processing all at once." However, for client projects, many recommend starting with packages like Bagisto or Aimeos: "If a client needs a store tomorrow, use Bagisto. If you are building a unique shopping experience, build from scratch with Laravel."
On r/PHP, developers emphasize the importance of database transactions for order processing: "The number one mistake in e-commerce codebases is not wrapping order creation in a transaction. One failed insert and you have orphaned records everywhere." This advice directly applies to the checkout implementation above.
In r/Nepal, developers report that e-commerce projects are among the most common freelance requests: "Every other client wants an online store. If you can build one well with Laravel, you will never run out of work in Nepal." Another user noted: "Understanding Nepali payment gateways like eSewa and Khalti is a differentiator. International tutorials only cover Stripe and PayPal."
Practical Takeaway
Building an e-commerce application with Laravel is one of the best portfolio projects you can create. Here is your implementation plan:
Week 1: Set up the project, design the database schema, create models with relationships, build the admin panel for product management.
Week 2: Build the product listing with filtering, search, and pagination. Create the product detail page with related products.
Week 3: Implement the shopping cart with add, update, and remove functionality. Build the checkout flow with form validation.
Week 4: Add order processing with database transactions, stock management, and order confirmation. Implement the user order history page.
Week 5: Polish the UI, add error handling, implement basic payment integration (start with COD, then add eSewa or Khalti), and deploy.
Focus on getting the core flow working first: browse products, add to cart, checkout, place order. Then add features like search, filtering, featured products, and payment integration incrementally.
Frequently Asked Questions
How long does it take to build an e-commerce site with Laravel?
A basic but functional e-commerce site takes 4-6 weeks for a single developer. This includes product management, cart, checkout, and order processing. Adding features like payment integration, email notifications, and a polished UI adds another 2-4 weeks.
Should I use a package like Bagisto or build from scratch?
Build from scratch for your portfolio and learning. Use Bagisto or similar packages for client projects where speed matters. Understanding the underlying concepts from building your own helps you debug and customize any e-commerce solution.
How do I integrate eSewa or Khalti payment in Laravel?
Both eSewa and Khalti provide PHP SDKs and REST APIs. You send payment details to their API, redirect the user to their payment page, and receive a callback when payment completes. The integration typically takes 1-2 days per payment gateway.
Is Laravel suitable for large-scale e-commerce?
Yes, with proper architecture. Laravel with Redis caching, queue workers, and database optimization can handle thousands of concurrent users. For very large scale (millions of users), consider microservices architecture with Laravel components.
How do I handle product images in Laravel?
Use Laravel's built-in file storage with the public disk for product images. For better performance, integrate with a CDN or use Spatie's Media Library package for advanced image management including thumbnails and conversions.
Build Production-Ready Laravel Applications at Swift Academy
Ready to build e-commerce applications and other production-level Laravel projects? Swift Academy's Laravel course in Pokhara teaches you everything from PHP fundamentals through advanced Laravel development, including e-commerce projects with real payment integration. Graduate with a portfolio that proves you can build applications businesses actually need. Visit swiftacademy.com.np or come to our Pokhara campus.
Related Articles
- Laravel vs CodeIgniter vs Symfony: Which PHP Framework Should You Choose?
- Is PHP Dead in 2026? Here's Why 77% of Websites Still Run on It
- How to Start Freelancing with PHP Laravel: Land Your First Client in 30 Days
Suggested Images
- Alt: "Laravel e-commerce website product listing page showing category filters search bar and product grid with prices"
- Alt: "Database schema diagram for Laravel e-commerce application showing products orders categories and users tables with relationships"
- Alt: "Shopping cart and checkout flow wireframe for a Laravel e-commerce application with Nepal payment gateway integration"
