Maintainable
Custom functionality is kept in dedicated files instead of being scattered across page settings and editor fields.
About this project
A WordPress Website Built as a Real Working Project
This website is both a service website and a practical demonstration of how I approach WordPress work.
It was built and configured as a maintainable project rather than a collection of disconnected pages. The website combines WordPress content management with custom code, version control and a separately managed server environment.
My professional background in software testing and technical integrations influences the way I work: changes should be understandable, testable and recoverable.
The project
More Than a Demonstration Website
The goal was to create a clear WordPress service website while keeping its custom functionality organized and independent from theme updates.
The project includes website structure, service and pricing pages, request forms, custom styling and interactive elements. It also covers the technical work behind the visible website: hosting, domain configuration, source control and deployment.
Four principles guided the implementation:
Version Controlled
Project files are stored in GitHub so changes can be reviewed, traced and reversed when necessary.
Theme Independent
Custom styles and scripts are loaded separately so that they are less likely to be lost during a theme update.
Tested
Pages, links, forms, layouts and interactive elements are checked after significant changes.
What was implemented
From Website Structure to Technical Configuration
WordPress Structure
The website was organized into clear service, pricing, contact and project-information pages with consistent navigation and reusable visual elements.
Responsive Layouts
Page sections were adapted for desktop, tablet and mobile screens rather than being designed only for one display size.
Custom Styling
Project-specific CSS was added to control service sections, pricing cards, buttons, spacing and responsive behaviour.
Interactive Features
Custom JavaScript is used where the website needs behaviour beyond standard WordPress blocks, including pricing and request interactions.
Forms and Requests
Service-request forms collect the information needed to understand the website, selected service and expected scope of work.
Server and Domain Setup
The WordPress installation is hosted on a separately managed VPS, with the domain and web-server routing configured independently from WordPress.
Version-controlled customization
Custom Work Stored in GitHub
The custom parts of this website are stored in a GitHub repository instead of existing only inside the WordPress database.
The repository provides a clear place for project-specific CSS, JavaScript and plugin files. It also keeps a history of changes, making it easier to understand when and why a modification was introduced.
Version control does not replace website backups, but it adds an important recovery layer for custom code. If a change causes an unexpected result, the difference can be reviewed and an earlier version can be restored.
The repository contains only files intended for source control. Passwords, API tokens, private keys, database copies and other sensitive information are excluded.
Custom WordPress plugin
Keeping Site Functionality Separate from the Theme
A lightweight custom plugin was created to load the styles and scripts developed specifically for this website.
Placing this functionality in a plugin avoids tying it directly to the active theme. The theme can be updated or replaced without automatically removing the project-specific files.
The plugin provides one controlled entry point for the website’s custom assets. This makes the implementation easier to inspect, update and maintain than code distributed across unrelated editor fields.
The plugin is intentionally limited in scope. It does not modify WordPress core files and does not attempt to replace features already handled adequately by WordPress or established plugins.
Tools and technical choices
Each Tool Has a Defined Purpose
The project uses standard WordPress functionality where it is sufficient and custom code where the website requires more control.
The objective is not to install as many plugins as possible. Every additional component creates another update, compatibility and security dependency, so plugins should solve a specific problem and remain replaceable when practical.
| Purpose | Implementation |
|---|---|
| Content management | WordPress and the block editor |
| Hosting | VPS-based WordPress environment |
| Source control | GitHub repository |
| Custom styling | Version-controlled CSS |
| Interactive behaviour | Version-controlled JavaScript |
| Custom asset loading | Dedicated WordPress plugin |
| Forms | WordPress form plugin and custom configuration |
| Domain management | External DNS configuration |
Testing and verification
Changes Are Checked Beyond the Editor
A page that looks correct inside the WordPress editor may still behave differently for a real visitor. For that reason, significant changes are reviewed on the published website and at different screen widths.
The verification process includes:
- desktop and mobile layout checks;
- navigation and internal-link testing;
- button and form interaction checks;
- validation of required form fields;
- checks for missing images and broken links;
- review of custom CSS and JavaScript behaviour;
- basic browser testing;
- verification after plugin or theme changes.
This does not eliminate every possible future problem, but it reduces the risk of publishing an obvious layout or functionality defect.
Need help with your WordPress website?
The Same Structured Approach Can Be Applied to Your Project
I can review the current setup, identify the required work and suggest a practical scope without forcing the website into an unnecessary rebuild.