How to Develop a Webapplications with Laravel and Continuous Delivery

/ CI/CD Branching Strategy / By

Why Laravel and Continuous Delivery?

Imagine launching a new web application in days, not weeks, with built-in security, scalability, and a thriving community at your back. That’s the promise of Laravel, the PHP framework that’s become a favorite for developers and businesses worldwide. But building is only half the battle—delivering updates quickly and reliably is just as crucial. Enter Continuous Delivery (CD), a practice that automates deployment, reduces errors, and keeps your users happy with fresh features.

In this guide, you’ll learn how to develop a modern webpage using Laravel, set up a robust CI/CD pipeline with GitHub Actions, automate regular updates, leverage commercial-grade templates, and configure professional email for your web app.

Why Laravel? Advantages and Key Differentiators

  • Rapid Development: Elegant syntax and pre-built components speed up coding and reduce time-to-market.
  • Robust Security: Built-in protection against common vulnerabilities like SQL injection and XSS.
  • Scalability: Modular structure and caching make Laravel suitable for both startups and enterprise apps.
  • Cost-Effective: Open-source, with a huge ecosystem of free packages and tools.
  • Seamless Integration: Works smoothly with front-end frameworks (Vue.js, React, Angular) and APIs.
  • Active Community: Extensive documentation, tutorials, and support from a global developer base.
  • Easy Maintenance: MVC architecture and clear code separation simplify updates and scaling.
  • Localization & SEO: Multilingual support and SEO-friendly routing out of the box.

Key Differentiators

  • Blade Templating Engine: Powerful, lightweight, and flexible for building dynamic UIs.
  • Eloquent ORM: Intuitive database abstraction for rapid data modeling without complex SQL.
  • Artisan CLI: Automates repetitive tasks, migrations, and testing with simple commands.
  • API-First Design: Resource controllers and token-based authentication (Sanctum, Passport) make API development a breeze.
  • Continuous Updates: Regular releases keep Laravel aligned with the latest PHP standards and security practices.

Real-World Examples of Laravel in Action

  • Startups: Laracasts—the “Netflix for developers”—is built on Laravel, delivering video content to thousands of users daily.
  • Enterprise: Startups.com uses Laravel to manage a suite of business tools for entrepreneurs, handling complex workflows and integrations.
  • eCommerce: Bagisto is an open-source eCommerce platform powered by Laravel, enabling rapid online store launches.

Step-by-Step: Installing and Configuring Laravel

Prerequisites

  • PHP 8.1 or higher
  • Composer (PHP dependency manager)
  • Web server (Apache or Nginx)
  • Database (MySQL, PostgreSQL, SQLite, or SQL Server)
  • Git (for version control)

1. Install PHP and Composer


sudo apt update && sudo apt install php php-cli php-fpm php-mysql php-xml php-mbstring composer git unzip curl

2. Install Laravel Globally


composer global require laravel/installer

Verify installation:


laravel --version

3. Create a New Laravel Project


sudo apt update
sudo apt install php8.3-sqlite3

cd /var/www
sudo composer create-project --prefer-dist laravel/laravel stonetusker
cd stonetusker

4. Configure Environment


sudo cp .env.example .env
sudo php artisan key:generate

# Do the below in case ufw firewall is enabled
sudo ufw allow 8000/tcp

Edit .env to set your database and app settings.

5. Start the Development Server



php artisan serve --host=0.0.0.0 --port=8000

Visit http://127.0.0.1:8000 to see your new Laravel app.

6. Set Up Database

  • Create a database in MySQL or your preferred DBMS.
  • Update .env with DB credentials.
  • Run migrations:


# Here example is to do it using MySQL , Ensure your MySQL server is started and permission given


Stop the php artisan serve --host=0.0.0.0 --port=8000 execution

# update .env as below
#
DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=laravel
DB_USERNAME=root
DB_PASSWORD=your_password_here


php artisan migrate
php artisan serve --host=0.0.0.0 --port=8000

7. Deploying to Hostinger VPS

  1. SSH into your VPS.
  2. Clone your project from GitHub:
    3. 
cd /var/www/html
git clone https://github.com/yourusername/your-laravel-app.git
cd your-laravel-app
composer install
cp .env.example .env
php artisan key:generate
php artisan migrate
  3. Set permissions:
    4. 
sudo chown -R www-data:www-data /var/www/html/your-laravel-app
sudo chmod -R 755 /var/www/html/your-laravel-app/storage
  4. Configure Apache or Nginx virtual host to point to public/ directory.

Hosting a Demo application

In this examples, we are hosting Open source personal CRM. 

    
# 1. Install system dependencies (Ubuntu example)
sudo apt update
sudo apt install -y git apache2 mysql-server php php-cli php-fpm php-mysql php-xml php-mbstring php-zip php-bcmath php-intl php-curl php-gd php-gmp curl unzip nodejs npm
npm install -g yarn

# 2. Prepare the database
sudo mysql
# In MySQL shell:
CREATE DATABASE monicadb CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
CREATE USER 'monica'@'localhost' IDENTIFIED BY 'strongpassword';
GRANT ALL ON monicadb.* TO 'monica'@'localhost';
FLUSH PRIVILEGES;
EXIT;

# 3. Clone MonicaHQ repository
cd /var/www
git clone https://github.com/monicahq/monica.git
cd monica
git fetch --all --tags
git checkout tags/v3.7.0  # (or latest tag)

# 4. Configure environment
cp .env.example .env
# Edit .env and set:
APP_ENV=production
APP_URL=http://your-domain.com
DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=monicadb
DB_USERNAME=monica
DB_PASSWORD=strongpassword
MAIL_MAILER=smtp
MAIL_HOST=smtp.yourprovider.com
MAIL_PORT=587
MAIL_USERNAME=your_username
MAIL_PASSWORD=your_password
MAIL_ENCRYPTION=tls
MAIL_FROM_ADDRESS=your@email.com
MAIL_FROM_NAME="Your App Name"

# 5. Install PHP and JS dependencies
composer install --no-interaction --no-dev
yarn install --immutable

# 6. Build frontend assets
yarn build

# 7. Generate application key
php artisan key:generate

# 8. Run Monica setup (creates DB tables and admin user)
php artisan setup:production --email=your@email.com --password=yourpassword -v

##Additional changes to fine-tune
# (Optional) Configure Apache/Nginx to point to /var/www/monica/public
# (Optional) Set up cron for scheduled tasks
# As www-data user:
crontab -e
# Add:
* * * * * php /var/www/monica/artisan schedule:run >> /dev/null 2>&1

# 12. Start Laravel’s built-in server for testing
php artisan serve --host=0.0.0.0 --port=8000
Expected Outout while accessing your machine using browser with your IP . Example: http://172.16.115.130:8000/ MonicaHQ Login Page

Setting Up CI/CD with GitHub Actions on Hostinger VPS

What is CI/CD?

Continuous Integration (CI) automates testing and building your code every time you push changes. Continuous Delivery (CD) takes it further by automating deployment to your server, ensuring your app is always up-to-date and reliable.

Now you can also add additional Nginx service as Reverse Proxy.

Step-by-Step CI/CD Pipeline for Laravel

  1. Push your Laravel project to a GitHub repository.
  2. Set up SSH keys for deployment and add them as GitHub secrets.
  3. Configure GitHub Actions workflow to build, test, and deploy your app on push.
  4. Finalize VPS permissions and test your pipeline by pushing changes.

# .github/workflows/laravel-deploy.yml
name: Laravel Deployment

on:
  push:
    branches: [ "main" ]

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Setup PHP
        uses: shivammathur/setup-php@v2
        with:
          php-version: '8.2'
          extensions: mbstring, bcmath, zip
      - name: Install Composer Dependencies
        run: composer install --no-interaction --prefer-dist
      - name: Install NPM Dependencies
        run: npm install
      - name: Build Frontend
        run: npm run build
      - name: Prepare Environment File
        run: |
          echo "${{ secrets.DEPLOYMENT_ENV_FILE }}" | base64 --decode > .env
      - name: Deploy to VPS
        uses: appleboy/ssh-action@master
        with:
          host: ${{ secrets.VPS_HOST }}
          username: ${{ secrets.VPS_USER }}
          key: ${{ secrets.SSH_PRIVATE_KEY }}
          script: |
            cd ${{ secrets.SERVER_DESTINATION }}
            git pull origin main
            composer install --no-interaction
            php artisan migrate --force
            php artisan config:clear
            php artisan cache:clear
            npm install
            npm run build
            sudo systemctl restart nginx

Automating Regular Database and Webpage Updates

Automating Database Updates with Laravel Scheduler

Laravel’s built-in scheduler allows you to automate regular database updates, backups, and maintenance tasks. Define scheduled tasks in routes/console.php or app/Console/Kernel.php: 


// Example: Update product prices daily at 2 AM
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Schedule;

Schedule::call(function () {
    DB::table('products')->update(['price' => DB::raw('price * 1.02')]);
})->dailyAt('2:00');

To run the scheduler, add this cron entry to your server: 


* * * * * cd /path-to-your-project && php artisan schedule:run >> /dev/null 2>&1

You can schedule any Artisan command, queued job, or closure for regular execution—such as cleaning up old records, sending reports, or updating cached data[22].

Automating Webpage Content Updates

  • Use AJAX or front-end frameworks (Vue.js, React) to fetch and display updated data without reloading the page.
  • Set up resource controllers and API endpoints to serve dynamic content.
  • Leverage Laravel’s event broadcasting (with Pusher or Laravel Echo) for real-time updates if needed.

// Example: Fetch latest comments via AJAX
$.get('/api/comments', function(data) {
    $('#comments-section').html(data);
});

Famous Templates for Commercial Web Applications

Choosing the right template accelerates development and ensures a professional look. Here are some of the most popular Laravel templates for commercial web apps[6]:

  • Stack: Multi-purpose, robust, and packed with reusable components for complex interfaces.
  • Mooli: Clean, minimal admin template with multiple layouts—great for dashboards.
  • Oculux: Modern design, widgets, and components for sophisticated web apps.
  • Qovex: Minimal, reusable components—ideal for SaaS, eCommerce, and analytics apps.
  • Dastone: Dark/Light layouts, RTL support, perfect for analytics and admin panels.
  • Ubold: Premium, 150+ pages, 500+ UI components, light/dark mode, and more.
  • Gull Dashboard: Modern Bootstrap 4 admin template, responsive, and feature-rich[9].

These templates are customizable, responsive, and come with pre-built pages for dashboards, eCommerce, analytics, and more.

Email Configuration for Commercial Web Applications

Step-by-Step Email Setup in Laravel

  1. Configure SMTP in .env: 
    
MAIL_MAILER=smtp
MAIL_HOST=smtp.yourprovider.com
MAIL_PORT=587
MAIL_USERNAME=your_username
MAIL_PASSWORD=your_password
MAIL_ENCRYPTION=tls
MAIL_FROM_ADDRESS="[email@example.com]"
MAIL_FROM_NAME="${APP_NAME}"
  2. Check config/mail.php: 
    
'from' => [
    'address' => env('MAIL_FROM_ADDRESS', 'hello@example.com'),
    'name' => env('MAIL_FROM_NAME', 'Example'),
],
  3. Create a Mailable Class: 
    
php artisan make:mail WelcomeMail

    Edit app/Mail/WelcomeMail.php:

    
public function build()
{
    return $this->from('[email@example.com]')
                ->subject('Welcome to Our App')
                ->view('emails.welcome');
}
  4. Create an Email Blade Template: 
    

<h1>Welcome, {{ $user->name }}!</h1>
<p>Thank you for joining our platform.</p>
  5. Send Email: 
    
use App\Mail\WelcomeMail;
use Illuminate\Support\Facades\Mail;

Mail::to($user->email)->send(new WelcomeMail($user));

You can customize and publish Laravel’s default email templates for password resets, order confirmations, and more. For advanced needs, use packages like simplepleb/laravel-email-templates for ready-made commercial templates[29].

Advantages of Laravel Microservices with Docker

  • Independent Deployment: Update or scale services without downtime for the whole app.
  • Strong Module Boundaries: Each service is isolated, improving reliability and maintainability.
  • Easy Scaling: Scale only the services that need more resources.
  • Consistent Environments: Docker eliminates “works on my machine” issues[11][12].
  • CI/CD Compatibility: Works seamlessly with GitHub Actions, Jenkins, and other pipelines.
  • Technology Flexibility: Mix Laravel, Lumen, Node.js, or other stacks as needed[13].

When to Use Microservices with Laravel

  • Your app is growing in complexity or user base.
  • You need to scale specific features independently.
  • Multiple teams are working on different parts of the app.
  • You want to future-proof your architecture for rapid changes.

If your app is simple, a monolith may be easier to manage. But for most modern, scalable web applications, microservices offer clear long-term benefits[10][13].

Best Practices for Laravel Microservices Architecture

  • Define Clear Service Boundaries: Each microservice should handle a single business function (e.g., authentication, orders, products)[28].
  • Database Per Service: Each service manages its own database for true independence.
  • Inter-Service Communication: Use REST APIs for synchronous calls, message queues (RabbitMQ, Redis) for async tasks.
  • API Gateway: Centralize routing, authentication, and rate limiting for all services[6][34].
  • Service Discovery: Use tools like Consul for dynamic service registration and health checks.
  • Automated Testing & CI/CD: Each service should have its own pipeline for build, test, and deploy.

Example: Dockerizing Laravel Microservices

Each microservice (e.g., user, product, order) runs in its own container. Here’s a sample Dockerfile for a Laravel service: 


# Stage 1: Build Composer dependencies
FROM composer:2.0 as build

WORKDIR /app
COPY . /app
RUN composer install --prefer-dist --no-dev --optimize-autoloader --no-interaction

# Stage 2: Production PHP-FPM
FROM php:8.1-fpm

RUN apt-get update && apt-get install -y \
    libicu-dev libzip-dev zip unzip \
    && docker-php-ext-install pdo_mysql zip intl

WORKDIR /var/www/html
COPY --from=build /app /var/www/html

RUN chown -R www-data:www-data /var/www/html \
    && chmod -R 755 /var/www/html/storage

EXPOSE 9000
CMD ["php-fpm"]

For a full microservices setup, you’ll also need a docker-compose.yml file to orchestrate multiple services: 


version: '3.8'
services:
  user-service:
    build: ./user-service
    ports:
      - "8001:9000"
    environment:
      - APP_ENV=production
    depends_on:
      - user-db
  user-db:
    image: mysql:8
    environment:
      MYSQL_DATABASE: userdb
      MYSQL_ROOT_PASSWORD: secret
    ports:
      - "3307:3306"
  product-service:
    build: ./product-service
    ports:
      - "8002:9000"
    depends_on:
      - product-db
  product-db:
    image: mysql:8
    environment:
      MYSQL_DATABASE: productdb
      MYSQL_ROOT_PASSWORD: secret
    ports:
      - "3308:3306"
  api-gateway:
    build: ./api-gateway
    ports:
      - "8080:80"
    depends_on:
      - user-service
      - product-service
networks:
  default:
    driver: bridge

Each service (user, product, etc.) is a separate Laravel or Lumen app, with its own database and Dockerfile. The api-gateway routes requests to the right service.

Integrating Dockerized Microservices with CI/CD

  • Each microservice should have its own GitHub Actions workflow for build, test, and deploy.
  • Use docker-compose in your pipeline to spin up all services for integration tests.
  • Push Docker images to a registry (Docker Hub, GitHub Packages) and deploy to your VPS or Kubernetes cluster.
  • Automate database migrations and cache clearing in your deployment scripts.

API Gateway and Service Communication

  • Use an API Gateway (Kong, Tyk, or a custom Laravel/Lumen gateway) to centralize authentication, routing, and monitoring[6][34].
  • REST APIs are the most common for Laravel microservices, but you can also use message queues for async communication.
  • Service discovery tools (like Consul) help manage dynamic service endpoints.
  • Laravel 12: Latest version with improved performance, security, and developer experience.
  • GitHub Actions: Native CI/CD automation for GitHub repositories.
  • Hostinger VPS: Affordable, scalable hosting with full root access and one-click Laravel templates.
  • Composer: Dependency management for PHP projects.
  • Envoyer: Zero-downtime deployment tool for Laravel (optional, paid).
  • Forge: Server provisioning and management for Laravel (optional, paid).
  • Serverless Laravel: Tools like Laravel Vapor are making it possible to deploy Laravel apps on AWS Lambda, reducing server management overhead.
  • AI-Powered DevOps: Assistants like Hostinger’s Kodee are streamlining deployment and troubleshooting.
  • Microservices & APIs: Laravel’s event-driven architecture and API-first tools are enabling more modular, scalable systems.
  • Zero-Downtime Deployments: Expect more teams to adopt atomic deployment strategies for seamless updates.

Should You Dockerize Laravel as Microservices?

Dockerizing Laravel as microservices is increasingly popular for large, complex, or rapidly scaling applications. Microservices architecture breaks your app into independent, focused services—each running in its own container. This approach is worth considering if you need:

  • Independent scaling of different app modules (e.g., user, product, order services).
  • Faster development cycles with multiple teams working in parallel.
  • Resilience: failures in one service don’t bring down the whole app.
  • Technology flexibility: use the best language or framework for each service.
  • Seamless CI/CD: containers ensure consistent environments from dev to production.

For small or simple apps, microservices may add unnecessary complexity. But for growing businesses, SaaS platforms, or apps with diverse modules, the benefits are significant[6][10][13].

Real-World Example

  • Case Study: A SaaS platform split its monolithic Laravel app into microservices (user, billing, analytics) using Docker. Each service was independently deployed and scaled, reducing downtime and improving developer productivity. The API Gateway handled authentication and routing, while CI/CD pipelines automated testing and deployment for each service[6][10][11].

Challenges and Solutions

Challenge Solution
Complexity in orchestration Use Docker Compose or Kubernetes for service management.
Inter-service communication REST APIs for sync, message queues (RabbitMQ, Redis) for async.
Data consistency Design for eventual consistency; use events and queues.
Monitoring and logging Centralize logs and metrics with tools like ELK stack or Prometheus.
Deployment automation CI/CD pipelines for each service, automated Docker builds and deploys.

Conclusion & Key Takeaways

Building web pages with Laravel and automating delivery with CI/CD is no longer just for big tech companies. With the right tools and a clear process, anyone can launch secure, scalable, and maintainable web applications—fast. Laravel’s elegant syntax, robust ecosystem, and active community make it a top choice for modern web development. Pair it with GitHub Actions and a reliable VPS like Hostinger, and you’re set for continuous innovation.

References & Further Reading

Ready to take your web projects to the next level? Contact us today for expert Laravel development and CI/CD solutions tailored to your business!





Image credit: Designed by Freepik

Related Posts