What You Need

Before starting, make sure your hosting environment has:

• cPanel Application Manager enabled
• Phusion Passenger enabled
• Node.js 20+ available
• MySQL or MariaDB available
• SSH access to the cPanel account
• a subdomain for Strapi, for example cms.yourdomain.com

A good setup is:

• frontend: https://yourdomain.com
• Strapi CMS: https://cms.yourdomain.com

1. Create the Subdomain

In cPanel, create a subdomain for Strapi, for example:

• cms.yourdomain.com

This is the public URL your Strapi app will use.

2. Upload the Strapi Project

Upload your Strapi app files to the server.

A typical location is:

• /home/yourcpaneluser/public_html

or better:

• /home/yourcpaneluser/strapi

If you use public_html, make sure your Node app in Application Manager points there.

Upload these parts of the project:

• package.json
• package-lock.json
• config/
• database/
• src/
• public/
• types/
• tsconfig.json
• favicon.png

Do not upload:

• node_modules/
• .cache/
• temporary build artifacts you do not need

3. Create the Database

In cPanel, create a MySQL database and user.

Use the real cPanel-generated names, which are often prefixed. For example:

• database name: youruser_db
• username: youruser_user

Do not assume local placeholder names like strapi_fold will work in production.

4. Create the .env File

In your Strapi app root, create .env with production values:

HOST=0.0.0.0
PORT=1337
NODE_ENV=production
PUBLIC_URL=https://cms.yourdomain.com

APP_KEYS=your_key_1,your_key_2,your_key_3,your_key_4
API_TOKEN_SALT=your_api_token_salt
ADMIN_JWT_SECRET=your_admin_jwt_secret
TRANSFER_TOKEN_SALT=your_transfer_token_salt
ENCRYPTION_KEY=your_encryption_key
JWT_SECRET=your_jwt_secret

DATABASE_CLIENT=mysql
DATABASE_HOST=localhost
DATABASE_PORT=3306
DATABASE_NAME=your_real_db_name
DATABASE_USERNAME=your_real_db_user
DATABASE_PASSWORD=your_real_db_password
DATABASE_SSL=false

5. Make Sure server.ts Uses the Public URL

In config/server.ts, include:

import type { Core } from '@strapi/strapi';

const config = ({ env }: Core.Config.Shared.ConfigParams): Core.Config.Server => ({
  host: env('HOST', '0.0.0.0'),
  port: env.int('PORT', 1337),
  url: env('PUBLIC_URL', ''),
  app: {
    keys: env.array('APP_KEYS'),
  },
});

export default config;

This makes Strapi use the real public domain instead of localhost.

6. Important: Add JS Config Files for Passenger

If your Strapi project uses TypeScript, Passenger startup via app.js may ignore .ts config files.

You should create JS equivalents in config/:

• config/admin.js
• config/api.js
• config/database.js
• config/middlewares.js
• config/plugins.js
• config/server.js

Example config/admin.js:

module.exports = ({ env }) => ({
  auth: {
    secret: env('ADMIN_JWT_SECRET'),
  },
  apiToken: {
    salt: env('API_TOKEN_SALT'),
  },
  transfer: {
    token: {
      salt: env('TRANSFER_TOKEN_SALT'),
    },
  },
  secrets: {
    encryptionKey: env('ENCRYPTION_KEY'),
  },
  flags: {
    nps: env.bool('FLAG_NPS', true),
    promoteEE: env.bool('FLAG_PROMOTE_EE', true),
  },
});

Example config/server.js:

module.exports = ({ env }) => ({
  host: env('HOST', '0.0.0.0'),
  port: env.int('PORT', 1337),
  url: env('PUBLIC_URL', ''),
  app: {
    keys: env.array('APP_KEYS'),
  },
});

Example config/api.js:

module.exports = {
  rest: {
    defaultLimit: 25,
    maxLimit: 100,
    withCount: true,
  },
};

Example config/middlewares.js:

module.exports = [
  'strapi::logger',
  'strapi::errors',
  'strapi::security',
  'strapi::cors',
  'strapi::poweredBy',
  'strapi::query',
  'strapi::body',
  'strapi::session',
  'strapi::favicon',
  'strapi::public',
];

Example config/plugins.js:

module.exports = ({ env }) => ({});

7. Add app.js for Passenger

This is the most important file for Passenger.

Create app.js in the app root:

process.env.NODE_ENV = process.env.NODE_ENV || "production";

require("@strapi/strapi")
  .createStrapi({ distDir: "./dist" })
  .start();

The distDir part matters for serving the built admin frontend correctly.

8. Install Dependencies

SSH into the cPanel account and go to the app folder:

cd ~/public_html

or wherever your app lives, then run:

/opt/cpanel/ea-nodejs22/bin/npm install

If your project includes better-sqlite3 but you are using MySQL in production, remove better-sqlite3 first. It often fails to compile on shared hosting and is not needed for MySQL.

On this cPanel server, npm was not available from the default shell path. Using /opt/cpanel/ea-nodejs22/bin/npm runs the cPanel-provided npm binary directly, which is why it worked.

9. Build Strapi

Run:

/opt/cpanel/ea-nodejs22/bin/npm run build

This builds the admin panel.

10. Configure cPanel Application Manager

In cPanel Application Manager, create the Node app with values like:

• Application Name: Strapi
• Deployment Domain: cms.yourdomain.com
• Base Application URL: /
• Application Path: public_html or strapi
• Deployment Environment: Production
• Startup file: app.js

Important:

• Base Application URL should be /
• Application Path should be relative to your home directory

11. Restart the App

After saving the app in Application Manager, restart it from cPanel.

Do not rely only on manually running node app.js in SSH. Passenger must be the one managing the app process.

12. Test the Deployment

Check:

• https://cms.yourdomain.com/api
• https://cms.yourdomain.com/admin
• https://cms.yourdomain.com/admin/init

If /api returns Strapi JSON and /admin/init returns admin config data, the backend is working.

Common Issues

strapi: command not found

This means npm install did not complete successfully.

better-sqlite3 build errors

Remove better-sqlite3 if you are using MySQL.

Missing admin.auth.secret configuration

This usually means your .ts config files are not being loaded by Passenger. Add JS config files.

/api works but /admin is Not Found

This usually means your app.js is missing:

.createStrapi({ distDir: "./dist" })

Not Found even when the app is stopped

That usually means Passenger is not actually serving the subdomain. Recheck Application Manager routing.

Final Result

Once everything is correct, Strapi should work at:

• https://cms.yourdomain.com
• admin: https://cms.yourdomain.com/admin

Closing Notes

Strapi on cPanel with Passenger works, but TypeScript-based Strapi projects need extra care because Passenger startup does not naturally use .ts config files. The clean solution is to keep your project as-is, but add JS config equivalents and a proper Passenger app.js.

That is the setup used in this project.

The stack includes:

• Laravel 13
• Filament 5
• MySQL 8
• Docker Compose
• cPanel-friendly deployment defaults

This article is a compact reference for how the setup was built and why certain decisions were made.

Repository:
https://github.com/ipint/JobList

Why This Stack

The goal was to build a backend that could:

• run locally with Docker
• use MySQL locally and in production
• provide a fast admin panel for jobs management
• deploy cleanly to a dedicated cPanel server
• avoid needing Redis or Supervisor at the start

Filament was chosen because it gives Laravel a fast, maintainable admin panel. Laravel was chosen because the production target is PHP 8.3 on cPanel, so the ecosystem fits well.

Local Setup Approach

The local Docker stack is simple:

• PHP-FPM app container
• Nginx container
• MySQL container

This keeps development predictable and close to production.

One practical issue came up during setup: common local ports were already in use, so the app was exposed on:

http://localhost:8088

Important Early Decision: Queue Table Naming

Laravel’s default database queue uses a table named jobs.

That would conflict with the actual jobs domain table needed for job listings.

To avoid that, the queue tables were renamed to:

• queued_jobs
• failed_queued_jobs

That kept the data model clean from the start.

PHP Version Compatibility

Production is expected to run on PHP 8.3.

At one stage, Composer resolved packages using local PHP 8.4, which caused dependency problems inside Docker and would also have caused issues on cPanel.

The fix was to pin Composer’s platform to PHP 8.3 so the lockfile stays aligned with the real deployment environment.

Filament Admin Setup

Filament 5 was installed as the admin layer and mounted under:

/admin

That provided:

• login
• dashboard
• resource routing
• the structure needed to manage jobs properly

Jobs Schema

A proper jobs table was created with fields such as:

• title
• slug
• reference
• company name
• department
• description
• requirements
• benefits
• employment type
• work mode
• experience level
• status
• county
• city
• postcode
• salary fields
• application URL and email
• sponsorship and right-to-work flags
• publish and expiry dates
• featured flag

This gave the project a realistic jobs domain rather than just an empty admin shell.

UK Counties Dropdown

The project requirement was to always select a county from a dropdown.

To support that, the setup added:

• a uk_counties table
• a UkCounty model
• a UK counties seeder
• a county_id foreign key on jobs

This means counties are not hardcoded inside the form. They come from the database, which makes maintenance easier later.

Filament Jobs Resource

The generated Filament stubs were replaced with a proper Jobs resource.

The admin now includes:

• a create/edit job form
• a searchable jobs table
• filters for status, type, work mode, county, and featured jobs

That makes the panel usable as a real internal admin, not just a demo.

Seeded UK Jobs

To make testing easier, the setup also includes:

• a JobFactory
• a JobSeeder
• 30 generated UK jobs

The jobs use random departments such as:

• Technology
• Sales
• Marketing
• Finance
• Operations
• Product
• Customer Support
• Legal

This makes the admin panel useful immediately for testing and demonstration.

cPanel Deployment Strategy

The production target is a dedicated cPanel server running PHP 8.3, without Redis or Supervisor.

Because of that, the setup uses:

• database queue
• database cache
• database sessions
• cron-based scheduling
• cron-based queue processing if needed

That keeps the architecture realistic for the hosting environment.

Issues Encountered During Setup

A few practical problems came up:

1. Laravel could not be scaffolded directly into the repo root

The repo was not empty, so Laravel had to be created in a temporary subdirectory first.

2. Docker port conflicts

Ports 8000 and 8080 were already in use, so the final local port became 8088.

3. Composer resolved dependencies for PHP 8.4

That had to be corrected by pinning the Composer platform to PHP 8.3.

4. Filament 5 namespace differences

One form error came from using the wrong namespace for Section. In Filament 5 it needed to come from Filament\Schemas\Components.

Final Result

The finished setup gives:

• Laravel 13 backend
• Filament 5 admin panel
• MySQL Docker environment
• UK counties lookup
• jobs management resource
• 30 seeded jobs
• cPanel-friendly deployment path

That is a solid base for adding more features later, such as:

• companies
• categories
• applications
• saved jobs
• public jobs APIs
• frontend job listing pages

Closing Note

The most important part of this setup is not that it is advanced. It is that it matches the actual environment and future needs.

That includes:

• matching local and production database choices
• keeping Laravel upgrades manageable
• using Filament as an admin layer, not as the whole application
• making location data structured from the start

If you are building a similar platform, this is a strong practical foundation to start from.

Repository:
https://github.com/ipint/JobList

Why use this method?

• Easy to update after each push
• Works with private GitHub repos
• More secure than manual uploads

Prerequisites

• A cPanel account with Terminal/SSH access
• A GitHub repository
• Domain already pointed to your hosting account

1. Generate an SSH key on your cPanel server

In cPanel Terminal:

ssh-keygen -t ed25519 -C "cpanel-deploy" -f ~/.ssh/id_ed25519 -N ""
cat ~/.ssh/id_ed25519.pub

Copy the public key output.

2. Add the key to GitHub

In your GitHub repo:

• Go to Settings → Deploy keys
• Click Add deploy key
• Paste the public key
• Keep write access off unless you specifically need push from server

This allows your server to read your private repo securely.

3. Configure SSH on cPanel

Create/update ~/.ssh/config:

Host github.com
  HostName github.com
  User git
  IdentityFile ~/.ssh/id_ed25519
  IdentitiesOnly yes

Then run:

chmod 600 ~/.ssh/config
ssh -T git@github.com

4. Clone the repository using SSH

Use SSH URL (not HTTPS):

cd ~
git clone git@github.com:YOUR_USERNAME/YOUR_REPO.git repositories/your-repo

5. Deploy files to your website folder

Copy repo files to your domain’s document root (example: public_html):

rsync -av --delete ~/repositories/your-repo/ ~/public_html/

Now your site files are live.

6. Updating after future GitHub pushes

When you push new changes:

cd ~/repositories/your-repo
git pull origin main
rsync -av --delete ./ ~/public_html/

Common errors and fixes

• could not read Username for ‘https://github.com’
  You used HTTPS. Switch remote to SSH.
• Permission denied (publickey)
  Wrong/missing deploy key, or SSH config not using correct key.
• Wrong branch (main vs master)
  Pull the branch that actually exists.

This setup gives you a secure and repeatable GitHub-to-cPanel deployment flow without making your repository public.

Step 1

Login to WordPress admin and click Plugins link, then its Add New sub-link

Step 2

Type searching by a keyword Site Kit by Google

Install the plugin by clicking the button Install Now

Step 3

Click link G Site Kit

Step 4

Start configuring Google Analytics, Google AdSense, Google Search Console, Google PageSpeed Insights, Google Optimize, and Google Tag Manager. All in one place.

After all, it is not a bad start. Cheers!

ErrorDocument 401 "Authorisation Required"
AuthUserFile /home/account/public_html/.htpasswd
AuthName "Please Log In"
AuthGroupFile /dev/null
AuthType Basic
Require valid-user

* here the line with ‘AuthUserFile’ gives the full path of the .htpasswd file which contains login details to the subfolder.

http://www.htaccesstools.com/htpasswd-generator/
http://tools.dynamicdrive.com/password/

The above 2 links will help to generate the content for the .htpasswd file

Ok next if we would like access the file inside the password protected folder then use the following sample curl script

$url = "http://www.domain.co.uk/subfolder/script.php";

$username = 'username';
$password = 'password';

$crl = curl_init();
$timeout = 10;
curl_setopt ($crl, CURLOPT_URL,$url);
curl_setopt ($crl, CURLOPT_RETURNTRANSFER, 1);
curl_setopt ($crl, CURLOPT_CONNECTTIMEOUT, $timeout);
curl_setopt ($crl, CURLOPT_HTTPAUTH, CURLAUTH_BASIC);
curl_setopt ($crl, CURLOPT_USERPWD, $username . ":" . $password);
$ret = curl_exec($crl);
curl_close($crl);
}

P.S. This script has been tested with cPanel hosting with Apache web server.

But anyway there is a solution for this I have changed “http://localhost/magento2” to “http://127.0.0.1/magento2” . This can be updated directly on the Magento’s database table ‘core_config_data’.

Cheers!

1. If the payment can be voided,
2. If you cannot unhold the order,
3. If all items have have not been invoiced,
4. If the order is not cancelled, complete or closed,
5. Or if the order has not already been flagged to be cancelled,

But this can be achieved by running sql query directly on the PHPMyadmin.

UPDATE `sales_flat_order_grid` SET `status` = 'canceled' WHERE `sales_flat_order_grid`.`entity_id` = ENTITY_ID;

UPDATE `sales_flat_order` SET `status` = 'canceled', `state` = 'canceled' WHERE `sales_flat_order`.`entity_id` = ENTITY_ID;

In the above sql queries ENTITY_ID will be replaced by an Order ID which status to be changed to ‘Canceled’. We can get the Order ID from the admin panel. To get this value navigate to ‘Sales -> Orders’ in the admin and click the Order row you want to change status. Once you are in the Order details page please check the URL and see the number placed between ‘order_id’ and ‘key’ and this is the Order ID

For example the following image ‘799’ is the ‘ENTITY_ID’ will be used in the SQL query.

Cheers!

Step 1:

Go to ‘Promotions -> Shopping Cart Price Rules’ and hit ‘Add New Rule’ button.  On the tab ‘Rule Information’ select ‘No Coupon’ on the ‘Coupon’ field.

Step 2:

On the tab ‘Conditions’ set the condition you want the products to have the Free Shipping

Step 3:

On the tab ‘Actions’ please follow the image below for the settings. And make sure you have the conditions set to work only for the selected items.

Now we are done with it and Save now. Please go to the website front end and test it! You will have the Free shipping working for this selected items.

Cheers!

1. The first thing that we need to do is to tell Dreamweaver that it’s okay to open a .scss or .less file – something that Dreamweaver by default doesn’t understand. You’ll first need to take a peak in your personal Dreamweaver configuration folder – on a Windows 7, that’s located in “C:\Users\~username\AppData\Roaming\Adobe\Dreamweaver CS6\en_US\Configuration” – and locate a file named “Extensions.txt”. Open the file and add SCSS (or SASS if you’re using the older syntax) and LESS to line 8, so that it reads: “CSS,SCSS,LESS:Style Sheets”.

2. Secondly we need to do the same as we did in the first step “C:\Users\~username\AppData\Roaming\Adobe\Dreamweaver CS6\en_US\Configuration\DocumentTypes” – and locate a file named “MMDocumentTypes.xml”. Open the file and add scss(or sass if you’re using the older syntax) and less to line 142, so that it reads: ‘<documenttype id=”CSS” internaltype=”Text” winfileextension=”css,scss,less” macfileextension=”css,scss,less” file=”Default.css” writebyteordermark=”false” mimetype=”text/css” >’.

Now save the files and restart Dreamweaver. You should now be able to click on a .scss or .less file in your explorer and have it open in Dreamweaver.

Cheers!

The following code helps to determine whether it is Category page or not?

<?php
if(Mage::registry('current_category')) {
    //Place your content/snippet here
}
?>

The following code helps to determine whether it is Product Details page or not?

<?php
if(Mage::registry('current_product')) {
    //Place your content/snippet here
}
?>

We could use this code anywhere in modules or in ,phtml files placed under ‘app/design/frontend/[package]/[theme]/ template/’

Cheers!