How to Verify That Your WordPress Plugin Created a Database Table (Hostinger phpMyAdmin & Other Methods)

When developing a WordPress plugin, one of the most satisfying moments is seeing your first custom database table appear.

In our Flipnzee Auctions series, we created the wp_flipnzee_auctions table using WordPress’s dbDelta() function.

But how do we know the table was actually created?

There are several ways to verify this. In this article, I’ll show the method I used while developing Flipnzee Auctions on Hostinger, along with several other approaches that work on different hosting providers.


Why Verify the Database?

Suppose you activate your plugin and nothing appears to happen.

Did the activation hook run?

Was the SQL correct?

Did dbDelta() create the table?

Rather than guessing, it’s always a good idea to verify the database.


Method 1 – Using Hostinger phpMyAdmin (Recommended)

Since Flipnzee.com is hosted on Hostinger, this is the method I personally used.

Step 1

Log in to your Hostinger hPanel.


Step 2

Open:

Websites → Manage

for your WordPress website.


Step 3

Open:

Databases → phpMyAdmin


Step 4

Select your WordPress database.

You’ll see all WordPress tables listed in the left sidebar.


Step 5

Scroll through the list.

After activating the Flipnzee Auctions plugin, I found the newly created table:

wp_flipnzee_auctions

This confirmed that the activation hook executed successfully and that WordPress created the database table.


My Development Screenshot

The following screenshot shows the actual database used while developing the Flipnzee Auctions plugin.

Notice the presence of the wp_flipnzee_auctions table among the standard WordPress tables.


Method 2 – phpMyAdmin on Other Hosting Providers

Most shared hosting providers offer phpMyAdmin.

For example:

  • cPanel Hosting
  • Bluehost
  • SiteGround
  • DreamHost
  • A2 Hosting
  • Namecheap Hosting

The process is almost identical:

  1. Open phpMyAdmin.
  2. Select your database.
  3. Look for your custom table.

Method 3 – MySQL Workbench

Many professional developers use:

  • MySQL Workbench

Connect using your database credentials.

Refresh the database.

Your custom table should appear automatically.


Method 4 – Adminer

Adminer is a lightweight alternative to phpMyAdmin.

Many developers prefer it because it’s fast and easy to use.

Simply connect to your database and check whether your table exists.


Method 5 – DBeaver

Another popular database tool is DBeaver.

It’s free and supports multiple database systems.

After connecting to your WordPress database, simply refresh the tables list.


Method 6 – Create an Admin Dashboard (Future Lesson)

As our plugin evolves, we won’t need to open phpMyAdmin every time.

Instead, we’ll build an administration page inside Flipnzee Auctions that displays information such as:

Plugin Status

✓ Plugin Active

✓ Database Connected

✓ Auction Table Exists

Version 1.0.0

This provides a much friendlier experience for plugin users.

We’ll build this later in the series.


Which Method Should Beginners Use?

If you’re just getting started with WordPress plugin development, phpMyAdmin is usually the easiest place to begin because it lets you see exactly what’s happening behind the scenes.

As you become more experienced, you’ll probably rely more on dedicated database tools or build your own plugin diagnostics.


Lesson Learned

Creating a database table is only half the job.

Professional developers always verify that the database matches what the code intended to create.

Developing the habit of checking your database after major schema changes can save hours of debugging later.


Final Thoughts

One of the goals of the Flipnzee Auctions project is not just to build a marketplace plugin, but to understand what happens behind the scenes as WordPress plugins interact with the database.

Learning to inspect your database is an important step toward becoming a confident WordPress developer.

As we continue this series, we’ll gradually move from simply creating tables to inserting records, updating them, retrieving data, and eventually powering a complete website marketplace.

Lesson 6: Creating Your First Database Table with dbDelta()

Introduction

In the previous lesson, we made one of the most important architectural decisions for the Flipnzee ecosystem.

Rather than building one massive plugin that manages everything, we decided to split responsibilities between two plugins:

  • Flipnzee Analytics manages website listings, verification, Google Analytics, Search Console data, and marketplace insights.
  • Flipnzee Auctions manages auctions, bidding, transactions, and the website transfer process.

This separation of responsibilities keeps both plugins modular, easier to maintain, and easier to extend in the future.

Now it’s time to create our first custom database table.

WordPress provides a special function called dbDelta() that safely creates or updates database tables. Instead of executing raw SQL directly, dbDelta() compares your desired table structure with the existing database and applies only the necessary changes.

In this lesson, we’ll use dbDelta() to create the first table for the Flipnzee Auctions plugin.


Learning Objectives

By the end of this lesson, you’ll be able to:

  • Understand why WordPress provides the dbDelta() function.
  • Create a custom database table during plugin activation.
  • Use the $wpdb object correctly.
  • Understand the importance of $wpdb->prefix.
  • Design a database table that complements another plugin instead of duplicating data.

Why Are We Creating a Custom Table?

Earlier in this series, we decided that auctions are transactional data, not content.

A website listing already exists in Flipnzee Analytics.

The auction plugin only needs to know:

  • Which listing is being auctioned.
  • The auction settings.
  • The current bid.
  • The auction status.
  • Who won the auction.

This keeps each plugin focused on its own responsibility.


Our Plugin Architecture

Our project now looks like this:

Flipnzee Analytics
--------------------------
Website Listings
Google Analytics
Search Console
Traffic
Revenue
Verification

          │
          ▼

Flipnzee Auctions
--------------------------
Auction
Bids
Escrow Workflow
Transfers
Watchlists
Notifications

Notice that the Auctions plugin does not store website information.

Instead, it references an existing listing.


Why Not Duplicate Website Data?

Suppose we copied the following into the auction table:

  • Website title
  • Monthly traffic
  • Revenue
  • Domain age

Now imagine the seller updates the listing.

Which copy should the buyer trust?

Instead of maintaining two copies of the same information, our auction simply stores a reference to the listing managed by Flipnzee Analytics.

This is a common software engineering principle known as avoiding duplication.


Step 1 – Create the Database Class

Inside the includes folder, create a new file:

class-database.php

Step 2 – Add the Database Class

<?php

if ( ! defined( 'ABSPATH' ) ) {
	exit;
}

class Flipnzee_Auction_Database {

	public static function create_tables() {

		global $wpdb;

		$table_name = $wpdb->prefix . 'flipnzee_auctions';

		$charset_collate = $wpdb->get_charset_collate();

		require_once ABSPATH . 'wp-admin/includes/upgrade.php';

		$sql = "CREATE TABLE {$table_name} (

			id BIGINT UNSIGNED NOT NULL AUTO_INCREMENT,

			listing_id BIGINT UNSIGNED NOT NULL,

			status VARCHAR(30) DEFAULT 'draft',

			start_price DECIMAL(12,2) DEFAULT 0,

			reserve_price DECIMAL(12,2) DEFAULT 0,

			buy_now_price DECIMAL(12,2) DEFAULT 0,

			current_bid DECIMAL(12,2) DEFAULT 0,

			auction_start DATETIME NULL,

			auction_end DATETIME NULL,

			winner_user_id BIGINT UNSIGNED DEFAULT NULL,

			created_at DATETIME DEFAULT CURRENT_TIMESTAMP,

			updated_at DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,

			PRIMARY KEY (id),

			KEY listing_id (listing_id),

			KEY status (status)

		) {$charset_collate};";

		dbDelta( $sql );

	}
}

Understanding Each Field

id

The unique identifier for each auction.


listing_id

This is the most important field in our table.

Instead of storing website information again, we simply reference the existing listing managed by Flipnzee Analytics.

One listing may eventually have multiple auctions over its lifetime without duplicating data.


status

Examples include:

  • draft
  • scheduled
  • active
  • ended
  • sold
  • cancelled

start_price

The opening bid.


reserve_price

The seller’s minimum acceptable price.


buy_now_price

Allows a buyer to immediately purchase the website without waiting for the auction to end.


current_bid

Stores the highest bid.

Although individual bids will later have their own database table, storing the current highest bid here allows auction listings to load much faster.


auction_start

The date and time bidding begins.


auction_end

The date and time bidding closes.


winner_user_id

After the auction ends, this field stores the winning bidder.


created_at and updated_at

These timestamps help us monitor when auction records are created and modified.


Step 3 – Load the Database Class

Open:

flipnzee-auctions.php

Add:

require_once FLIPNZEE_AUCTION_PATH . 'includes/class-database.php';

Step 4 – Update the Activation Hook

Replace your activation function with:

function flipnzee_auction_activate()
{
	Flipnzee_Auction_Database::create_tables();

	flush_rewrite_rules();
}

Now, whenever the plugin is activated, WordPress checks whether the auction table exists.

If it doesn’t, dbDelta() creates it automatically.


Step 5 – Test Your Plugin

Deactivate the plugin.

Activate it again.

If everything has been configured correctly, the database table will be created without displaying any errors.


Step 6 – Verify the Table

Open your preferred database manager, such as:

  • phpMyAdmin
  • Adminer
  • MySQL Workbench

You should now see:

wp_flipnzee_auctions

If your WordPress installation uses a different table prefix, the table name will begin with that prefix instead of wp_.


Why We’re Keeping This Table Simple

You might notice that this table doesn’t include:

  • Bid history
  • Payments
  • Escrow transactions
  • Website transfers

That’s intentional.

Each of these responsibilities will receive its own dedicated database table in future lessons.

Keeping each table focused on a single responsibility makes the database easier to maintain and allows the plugin to scale as more features are added.


Lesson Summary

In this lesson, we created our first custom database table using WordPress’s dbDelta() function. Instead of duplicating website information, we designed the table to reference listings managed by Flipnzee Analytics using the listing_id field.

This modular architecture allows Flipnzee Analytics to remain the source of truth for website information while Flipnzee Auctions focuses entirely on managing auctions and transactions.


Key Takeaways

  • ✓ Use dbDelta() when creating WordPress database tables.
  • ✓ Always use $wpdb->prefix.
  • ✓ Avoid duplicating data between plugins.
  • ✓ Design each database table with a single responsibility.
  • ✓ Modular plugins are easier to maintain and extend.

Common Mistakes

  • Hardcoding the wp_ table prefix.
  • Forgetting to load upgrade.php.
  • Storing the same information in multiple tables.
  • Mixing listing data with auction data.
  • Forgetting to reactivate the plugin after updating the activation hook.

Git Commands Used

git add .

git commit -m "Lesson 6: Create auction database table"

git push

Project Evolution

If you’ve been following this series from Lesson 0, you may notice that the architecture of Flipnzee Auctions has evolved as the project has grown.

Originally, the plugin was planned as a standalone website auction platform responsible for both listings and auctions.

As development progressed, we realized that Flipnzee Analytics already provides website listings, verification, Google Analytics integration, and Search Console data. Rather than duplicating those responsibilities, we decided to keep Flipnzee Auctions focused on auctions and transaction management.

This architectural change brings several advantages:

  • It avoids storing the same data in multiple places.
  • It keeps each plugin focused on a single responsibility.
  • It makes both plugins easier to maintain.
  • It allows future improvements to Flipnzee Analytics to benefit the auction system automatically.

You’ll notice similar design refinements throughout this series. That’s intentional. Real-world software development is an iterative process, and one of the goals of this series is to demonstrate how professional software evolves over time rather than presenting it as if it were designed perfectly from the beginning.

The GitHub repository will always contain the latest implementation, while these lessons document the reasoning behind each important decision.

Project Status

✅ Development environment

✅ Plugin skeleton

✅ Plugin installation

✅ Plugin lifecycle

✅ .gitignore

✅ Data architecture

✅ First database table

⬜ Auction Manager

⬜ Bid engine

⬜ Escrow workflow

⬜ Website transfer workflow

⬜ Notifications

⬜ Version 1.0

Developer’s Notebook

One of the most important principles in software engineering is Separation of Concerns. Each component of a system should have a clearly defined responsibility.

In the Flipnzee ecosystem, Flipnzee Analytics is responsible for collecting and presenting website information, while Flipnzee Auctions is responsible for managing the buying and selling process. By keeping these responsibilities separate, we avoid duplication, reduce complexity, and make both plugins easier to maintain as they evolve.


Looking Ahead

In Lesson 7, we’ll create the Auction Manager class and learn how to insert, retrieve, update, and delete auction records using WordPress’s $wpdb methods. This will be the first time our plugin stores and retrieves real auction data, moving us from database design into application development.

Lesson 5: Designing the Data Model – Custom Post Types, Custom Tables, or Both?


Introduction

Up to this point, we’ve built a solid foundation for the Flipnzee Auctions plugin. Our plugin installs correctly, follows good development practices, and is managed with Git.

Now it’s time to ask one of the most important questions in WordPress plugin development:

Where should we store our data?

WordPress offers several ways to store information, and choosing the right one can significantly affect your plugin’s performance, scalability, and maintainability.

For Flipnzee Auctions, we’ll eventually need to store:

  • Website listings
  • Auctions
  • Bids
  • Escrow transactions
  • Payment records
  • Website transfer progress
  • User watchlists
  • Notifications

Should all of these be stored as WordPress posts? Should we create our own database tables? Or is a hybrid approach the best solution?

In this lesson, we’ll explore the strengths and limitations of each approach before making our architectural decision.


Learning Objectives

By the end of this lesson, you’ll understand:

  • How WordPress stores content.
  • What Custom Post Types (CPTs) are.
  • What custom database tables are.
  • The advantages and disadvantages of each approach.
  • Why many professional plugins combine both.
  • Why Flipnzee Auctions will use a hybrid architecture.

Option 1 – Using Custom Post Types

Many plugins use Custom Post Types to store structured content.

For example:

Post
Page
Product
Event
Property
Listing

Each item is stored in the standard WordPress posts table, while additional information is stored as post meta.

Advantages include:

  • Built-in WordPress admin interface.
  • Revisions.
  • Categories and tags.
  • SEO compatibility.
  • REST API support.
  • Familiar editing experience.

For website listings, this is often an excellent choice.


Option 2 – Using Custom Database Tables

Some plugins create their own tables.

Examples include:

wp_flipnzee_auctions
wp_flipnzee_bids
wp_flipnzee_payments

Advantages include:

  • Faster queries for large datasets.
  • Better indexing.
  • Greater flexibility.
  • Easier reporting.
  • Better performance when storing transactional data.

This approach is commonly used by complex plugins such as e-commerce systems, booking systems, and learning management systems.


Why Not Store Everything as Posts?

Imagine an auction with:

  • 5,000 bids
  • 200 auctions
  • Thousands of payment records

Storing all of this in wp_posts and wp_postmeta would make queries increasingly complex and potentially slower as the site grows.

Transactional data is often better suited to dedicated database tables.


Why Not Store Everything in Custom Tables?

Custom tables are powerful, but they don’t automatically provide:

  • The WordPress editor.
  • Revisions.
  • Built-in REST support.
  • Categories and tags.
  • Media integration.

You would need to build many of these features yourself.


The Hybrid Approach

Many large WordPress plugins use a combination of both methods.

For Flipnzee Auctions, that’s exactly what we’ll do.

Flipnzee Analytics (Existing Plugin)

This plugin already manages website listings and verified analytics.

It provides:

  • Website listing
  • Google Analytics integration
  • Search Console integration
  • Verified metrics

Those listings can continue using WordPress’s strengths.


Flipnzee Auctions (New Plugin)

Our plugin will focus on transactional data such as:

  • Auction settings
  • Bid history
  • Watchlists
  • Escrow records
  • Payment tracking
  • Website transfer workflow

These are excellent candidates for custom database tables.


Our Planned Architecture

Flipnzee Analytics
-------------------
Website Listings
Traffic
Revenue
Verification

        │
        ▼

Flipnzee Auctions
-------------------
Auction
Bids
Escrow
Payments
Transfers
Watchlists

Each plugin has a clear responsibility.

This keeps the overall system modular, easier to maintain, and easier to extend.


Why This Matters

One of the biggest mistakes beginners make is trying to solve every problem with the same tool.

Professional developers choose the storage mechanism that best fits the type of data being stored.

Content and transactions have different requirements.

By recognizing that difference early, we can build a plugin that scales more effectively over time.


Lesson Summary

In this lesson, we explored three approaches to storing data in WordPress:

  • Custom Post Types
  • Custom Database Tables
  • A Hybrid Approach

Rather than choosing one exclusively, we’ve decided that Flipnzee Auctions will complement the existing Flipnzee Analytics plugin by storing transactional data in dedicated database tables while continuing to use WordPress where it makes sense.

This architectural decision will guide the remainder of the project.


Key Takeaways

  • ✓ WordPress provides several ways to store data.
  • ✓ Custom Post Types are ideal for content.
  • ✓ Custom tables are well suited to transactional data.
  • ✓ Many successful plugins use both approaches.
  • ✓ Flipnzee Auctions will use a hybrid architecture.

Common Mistakes

  • Assuming every plugin should use only Custom Post Types.
  • Creating database tables without a clear need.
  • Duplicating data already managed by another plugin.
  • Designing the database before understanding the application’s requirements.

Git Commands Used

git add .

git commit -m "Lesson 5: Design plugin data architecture"

git push

Note: This lesson focuses on architecture and planning. Unless you’ve actually changed files in your repository (such as updating ROADMAP.md or documentation), you don’t need to create a Git commit just because you published the lesson.


Project Status

✅ Development environment

✅ Plugin skeleton

✅ Plugin installation

✅ Plugin lifecycle

✅ .gitignore

✅ Data architecture planned

⬜ Database tables

⬜ Auction model

⬜ Bid engine

⬜ Escrow

⬜ Payment gateways

⬜ Website transfer

⬜ Version 1.0

Developer’s Notebook

Software architecture is about making good decisions before writing code. It’s tempting to start creating tables immediately, but taking time to understand your data leads to cleaner, more maintainable systems. In this series, we’ll build Flipnzee Auctions step by step, ensuring each design decision has a clear purpose rather than simply following convention.


Looking Ahead

In Lesson 6, we’ll create our first custom database table using WordPress’s dbDelta() function. We’ll learn why WordPress provides this function, how it safely creates and updates tables, and how we’ll use it to store auction data as our plugin grows.

Lesson 4: Using .gitignore to Keep Your Repository Clean

In the previous lesson, we learned how WordPress discovers and loads plugins during every request. We also explored the difference between plugin activation and the normal loading process.

While developing Flipnzee Auctions, we created a ZIP file so that we could install and test our plugin in WordPress. That ZIP file served its purpose, but it raised an important question:

Should generated files be stored in Git?

The answer is usually no.

Professional developers use a special file called .gitignore to tell Git which files and folders should never be tracked.

In this lesson, we’ll create our first .gitignore file and learn why keeping a repository clean is an important part of software development.


Learning Objectives

By the end of this lesson, you’ll be able to:

  • Understand the purpose of a .gitignore file.
  • Create a .gitignore file in GitHub Codespaces.
  • Prevent generated ZIP files from being tracked by Git.
  • Understand the difference between source code and generated files.
  • Learn what kinds of files should never be committed.

What Is a .gitignore File?

A .gitignore file tells Git:

“Ignore these files. Don’t show them as changes, and don’t include them in commits.”

It does not delete files.

It simply prevents Git from tracking them.


Why Do We Need One?

Suppose you create:

flipnzee-auctions.zip

This ZIP file is generated from your source code.

It can always be recreated.

If we committed every ZIP file to GitHub, our repository would quickly become cluttered with generated files instead of the source code that actually matters.

Our Git repository should contain the recipe, not the finished product.


Step 1 – Delete the Existing ZIP File

If you still have the ZIP file from Lesson 2, delete it.

GUI Method

In GitHub Codespaces Explorer:

  • Right-click flipnzee-auctions.zip
  • Select Delete

Terminal Method

rm flipnzee-auctions.zip

Verify it has been removed:

ls

The ZIP file should no longer appear.


Step 2 – Create a .gitignore File

Make sure you’re in the repository root.

pwd

Expected output:

/workspaces/flipnzee-auctions

GUI Method

Click New File.

Create:

.gitignore

Terminal Method

touch .gitignore

Open it:

code .gitignore

Step 3 – Add Your First Ignore Rule

Add the following:

# Generated plugin package
flipnzee-auctions.zip

Save the file.

That’s all!

From now on, Git will ignore the generated plugin ZIP.


Step 4 – Let’s Expand It

As our project grows, we’ll generate more temporary files.

Let’s prepare for that now.

Replace the contents of .gitignore with:

# Generated plugin package
flipnzee-auctions.zip

# ZIP files
*.zip

# Log files
*.log

# macOS
.DS_Store

# Windows
Thumbs.db

This is still a very small .gitignore, but it’s a good start.

We’ll continue adding to it throughout the project.


How Git Uses .gitignore

Imagine this repository:

flipnzee-auctions/
│
├── README.md
├── ROADMAP.md
├── LICENSE
├── CHANGELOG.md
├── .gitignore
│
├── flipnzee-auctions/
│
└── flipnzee-auctions.zip

Git sees the ZIP file.

It checks .gitignore.

It finds:

*.zip

Git immediately ignores the ZIP.

The file still exists on your computer.

It simply won’t appear in git status.


Test It Yourself

Create a ZIP again.

zip -r flipnzee-auctions.zip flipnzee-auctions

Now run:

git status

You should not see:

flipnzee-auctions.zip

Git is ignoring it exactly as we intended.


What Should Never Be Committed?

Generally speaking, Git repositories should contain:

✅ Source code

✅ Documentation

✅ Configuration

❌ Generated ZIP files

❌ Temporary files

❌ Cache files

❌ Log files

❌ Operating system metadata


Why This Matters

A clean Git repository has many advantages:

  • Smaller repositories.
  • Faster cloning.
  • Easier code reviews.
  • Fewer accidental commits.
  • More professional project organization.

Keeping only the files that matter makes collaboration much easier.


Lesson Summary

In this lesson, we created our first .gitignore file and learned why professional developers keep generated files out of version control. We also distinguished between source code, which belongs in Git, and generated artifacts, which can always be recreated.

Although .gitignore is a small file, it plays an important role in keeping software projects clean and maintainable.


Key Takeaways

  • ✓ .gitignore tells Git which files to ignore.
  • ✓ Ignored files remain on your computer.
  • ✓ Generated ZIP files should not be committed.
  • ✓ Source code belongs in Git.
  • ✓ Build artifacts generally do not.

Common Mistakes

  • Creating .gitignore.txt instead of .gitignore.
  • Adding files to .gitignore after they’ve already been committed.
  • Thinking .gitignore deletes files.
  • Forgetting to save the .gitignore file before testing.

Git Commands Used

touch .gitignore

git status

git add .

git commit -m "Lesson 4: Add .gitignore"

git push

Project Status

✅ Development environment

✅ Plugin skeleton

✅ Plugin installation

✅ Plugin lifecycle

✅ .gitignore

⬜ Database tables

⬜ Auction data model

⬜ Bidding engine

⬜ Escrow

⬜ Payment gateways

⬜ Website transfer

⬜ Version 1.0

Developer’s Notebook

One of the easiest ways to recognize a well-maintained software project is by looking at its Git repository. Professional repositories focus on the source code, documentation, and configuration files that define the project. Temporary files, generated packages, and operating system metadata are intentionally left out. A well-crafted .gitignore file is a small investment that pays dividends throughout the lifetime of a project.


Looking Ahead

In Lesson 5, we’ll take our first step into persistent data by creating the database tables that will power the Flipnzee Auctions plugin. We’ll learn why complex plugins often use custom database tables instead of relying entirely on WordPress post types and post meta, and we’ll create our first table using WordPress’s dbDelta() function.

Lesson 2: Installing and Activating Your First WordPress Plugin

Learning Objectives

By the end of this lesson, you’ll be able to:

  • Package your plugin for WordPress.
  • Install a plugin using the WordPress Dashboard.
  • Activate and deactivate a plugin.
  • Verify that WordPress recognizes your plugin correctly.
  • Understand what happens during plugin activation.
  • Troubleshoot common installation problems.

Why Test Early?

One of the most valuable habits in software development is testing small changes frequently.

Rather than writing thousands of lines of code and testing everything at the end, professional developers test after every significant milestone.

Since we’ve completed the plugin skeleton, now is the perfect time to verify that WordPress recognizes it as a valid plugin.

If everything works at this stage, we can confidently build additional features knowing that our foundation is solid.


Prerequisites

Before continuing, ensure that:

  • GitHub repository has been created.
  • GitHub Codespaces is working.
  • Lesson 1 has been completed.
  • Your changes have been committed and pushed to GitHub.

Step 1: Verify Your Project Structure

Your repository should look similar to this:

flipnzee-auctions/
│
├── README.md
├── ROADMAP.md
├── CHANGELOG.md
├── LICENSE
│
└── flipnzee-auctions/
    │
    ├── flipnzee-auctions.php
    └── includes/
        └── class-loader.php

Notice that only the inner flipnzee-auctions folder will become the WordPress plugin.


Step 2: Create the Plugin ZIP

WordPress installs plugins as ZIP archives.

Open GitHub Codespaces and make sure you’re in the repository root.

pwd

Expected output:

/workspaces/flipnzee-auctions

Now compress only the plugin folder.

Using the terminal:

zip -r flipnzee-auctions.zip flipnzee-auctions

Verify that the ZIP file was created:

ls

You should now see:

CHANGELOG.md
LICENSE
README.md
ROADMAP.md
flipnzee-auctions
flipnzee-auctions.zip

Step 3: Download the ZIP File

In GitHub Codespaces Explorer:

  • Locate flipnzee-auctions.zip
  • Right-click the file.
  • Select Download.

Save it to your computer.


Step 4: Install the Plugin

Log in to your WordPress website.

Navigate to:

Plugins → Add New Plugin

Click:

Upload Plugin

Select:

flipnzee-auctions.zip

Click:

Install Now

If everything is correct, WordPress will display a success message.


Step 5: Activate the Plugin

Click:

Activate Plugin

Navigate to:

Plugins → Installed Plugins

You should now see:

Flipnzee Auctions

Version 1.0.0

By Splendid Digital Solutions

Congratulations! WordPress now recognizes your plugin.

Although it doesn’t yet contain any auction functionality, it has officially become a valid WordPress plugin.


Step 6: Test Activation and Deactivation

Deactivate the plugin.

Activate it again.

Nothing visible should happen—and that’s perfectly normal.

Behind the scenes, WordPress executes the activation and deactivation hooks that we created in Lesson 1.

At the moment they simply refresh the rewrite rules.

In future lessons, those same hooks will create database tables, initialize settings, and perform other setup tasks.


Understanding What Just Happened

When WordPress activated your plugin, it performed several tasks automatically:

  1. Read the plugin header.
  2. Loaded flipnzee-auctions.php.
  3. Checked the ABSPATH security condition.
  4. Defined the plugin constants.
  5. Registered the activation hook.
  6. Loaded the Flipnzee_Auction_Loader class.

Even though your plugin currently has no visible features, WordPress has already built the execution environment that will support everything we add later.


Common Installation Problems

“Plugin could not be activated.”

Usually caused by:

  • PHP syntax errors
  • Missing semicolons
  • Incorrect file names

Plugin Doesn’t Appear

Usually caused by:

  • Plugin header missing
  • Main PHP file inside the wrong folder
  • Incorrect ZIP structure

White Screen

Usually caused by a PHP fatal error.

Enable debugging by adding the following to wp-config.php:

define('WP_DEBUG', true);
define('WP_DEBUG_LOG', true);

Then check:

wp-content/debug.log

Lesson Summary

In this lesson, we packaged our plugin, installed it on a WordPress website, activated it, and confirmed that WordPress recognizes it as a valid plugin. This milestone is important because it proves that our project structure and plugin header are correct before we begin adding more complex functionality.


Key Takeaways

  • WordPress installs plugins from ZIP files.
  • Only the plugin folder—not the entire repository—should be packaged.
  • Testing early helps identify problems before they become difficult to debug.
  • Activation hooks execute every time the plugin is activated.

Common Mistakes

  • Zipping the entire GitHub repository instead of the plugin folder.
  • Uploading the wrong ZIP file.
  • Forgetting to save changes before creating the ZIP.
  • Ignoring PHP errors during activation.

Git Commands Used

zip -r flipnzee-auctions.zip flipnzee-auctions

git add .

git commit -m "Lesson 2: Install plugin in WordPress"

git push

Project Status

✅ Development environment ready

✅ GitHub repository created

✅ Plugin skeleton completed

✅ Plugin installed successfully

⬜ Database installation

⬜ Auction engine

⬜ Bidding system

⬜ Escrow workflow

⬜ Payment gateways

⬜ Website transfer

⬜ Reports

⬜ REST API

⬜ Version 1.0 Release

Developer’s Notebook

Professional developers validate their work continuously. A plugin that installs and activates successfully gives you confidence that the project’s structure is sound. As we continue adding features, we’ll continue testing after each major milestone, making problems easier to isolate and fix.

As the Flipnzee ecosystem grows, this plugin will work alongside other Flipnzee plugins. For example, Flipnzee Analytics is responsible for collecting and displaying verified website metrics, while Flipnzee Auctions focuses on the buying, bidding, payment, and transfer process. Keeping these responsibilities separate makes each plugin easier to maintain and extend.


Looking Ahead

In Lesson 3, we’ll explore the WordPress Plugin Lifecycle. You’ll learn exactly what happens from the moment WordPress loads your plugin until your code is executed. Understanding this lifecycle is essential for writing efficient, secure, and maintainable plugins, and it will prepare us for creating our first database tables in the lessons that follow.


Lesson 3: Understanding the WordPress Plugin Lifecycle

In the previous lesson, we successfully installed and activated the Flipnzee Auctions plugin on our WordPress website. Even though the plugin doesn’t yet display any visible functionality, WordPress already recognizes it as a valid plugin and executes its code whenever appropriate.

But have you ever wondered what actually happens behind the scenes?

How does WordPress discover plugins?

When does it read the plugin header?

Why does the ABSPATH constant already exist?

When are activation hooks executed?

And why do they run only once?

Understanding these questions is one of the biggest differences between simply copying WordPress code and becoming a confident WordPress plugin developer.

In this lesson, we’ll follow the complete journey of our plugin—from the moment a visitor requests a page until our code is executed.


Learning Objectives

By the end of this lesson, you’ll understand:

  • How WordPress discovers installed plugins.
  • What happens during plugin activation.
  • What happens during every page request.
  • Why the ABSPATH security check works.
  • When your plugin code executes.
  • The purpose of activation and deactivation hooks.
  • Why understanding the plugin lifecycle makes debugging easier.

Why This Matters

Many beginners think WordPress “magically” loads plugins.

It doesn’t.

There is a very specific sequence of events.

Once you understand that sequence, many concepts become much easier:

  • Hooks
  • Filters
  • AJAX
  • REST APIs
  • Database creation
  • Custom Post Types
  • Scheduled tasks

Almost every advanced WordPress feature depends on understanding when your code runs.


The Journey Begins

Imagine someone visits:

https://flipnzee.com

The browser sends a request to the web server.

The web server loads WordPress.

WordPress then begins its own startup process.

Eventually it reaches the point where it starts loading plugins.


Step 1 — WordPress Finds Active Plugins

WordPress stores the list of active plugins in its database.

During startup it reads that list.

If your plugin is active:

Flipnzee Auctions

WordPress prepares to load:

flipnzee-auctions/flipnzee-auctions.php

This is why the main plugin file is so important.


Step 2 — WordPress Reads the Plugin Header

Before executing the plugin, WordPress reads the comment block at the top of the file.

/**
 * Plugin Name: Flipnzee Auctions
 * Version: 1.0.0
 * ...
 */

This information is displayed on:

Plugins → Installed Plugins

Notice something interesting.

The plugin header is metadata.

PHP ignores it.

WordPress reads it.


Step 3 — PHP Begins Executing Your File

Now PHP starts reading your code.

The very first executable line is:

if (!defined('ABSPATH')) {
    exit;
}

At this point WordPress has already defined:

ABSPATH

So the condition evaluates to:

false

The plugin continues loading.

If someone tried opening the PHP file directly in a browser:

https://example.com/wp-content/plugins/flipnzee-auctions/flipnzee-auctions.php

ABSPATH wouldn’t exist.

The plugin would immediately exit.

That’s why this simple security check is so important.


Step 4 — Constants Are Defined

Next WordPress executes:

define('FLIPNZEE_AUCTION_VERSION', '1.0.0');

Then

define('FLIPNZEE_AUCTION_PATH', ...);

Then

define('FLIPNZEE_AUCTION_URL', ...);

These constants remain available throughout the rest of the request.


Step 5 — Activation Hooks Are Registered

WordPress encounters:

register_activation_hook(...)

Notice the wording carefully.

We are registering the activation hook.

We are not executing it.

This often confuses beginners.

WordPress simply remembers:

“If this plugin is activated in the future, run this function.”


Step 6 — Additional Files Are Loaded

Next we load:

includes/class-loader.php

PHP reads the file.

The class becomes available.

Then we create:

new Flipnzee_Auction_Loader();

Its constructor executes immediately.

Right now the constructor is empty.

Later it will register all our actions, filters, REST routes, AJAX handlers, database classes, auction engine, payment system, and more.


The Complete Lifecycle

Here’s the entire process.

Browser Request
        │
        ▼
Web Server
        │
        ▼
WordPress Starts
        │
        ▼
Find Active Plugins
        │
        ▼
Read Plugin Header
        │
        ▼
Execute PHP
        │
        ▼
Security Check
        │
        ▼
Define Constants
        │
        ▼
Register Hooks
        │
        ▼
Load Classes
        │
        ▼
Plugin Ready

Every page request follows this sequence.


What Happens During Activation?

Activation is different.

It occurs only when you click:

Activate Plugin

WordPress performs:

Load Plugin

↓

Execute Activation Function

↓

Return Control

Your activation function currently contains:

flush_rewrite_rules();

Later we’ll expand it to:

  • Create database tables.
  • Create default settings.
  • Set plugin version.
  • Prepare the auction system.

What Happens During Deactivation?

When you deactivate the plugin:

WordPress executes:

flipnzee_auction_deactivate()

Currently it refreshes rewrite rules.

Later we’ll also:

  • Remove scheduled tasks.
  • Clear caches.
  • Perform cleanup.

Notice that we won’t delete auction data during deactivation.

Users expect their data to remain if they reactivate the plugin later.


Understanding One Important Difference

Many beginners think:

Activation happens every time a page loads.

It doesn’t.

Activation occurs once.

Normal plugin loading occurs on every request.

Understanding this distinction prevents many common mistakes.


Improving Our Development Workflow

As our project grows, we’ll start generating temporary files such as plugin ZIP archives.

Rather than storing these generated files in Git, professional developers use a .gitignore file to tell Git which files should be ignored.

In the next lesson, we’ll create our first .gitignore file and begin adopting even more professional development practices.


Lesson Summary

In this lesson, we explored the complete lifecycle of a WordPress plugin. We learned how WordPress discovers plugins, reads plugin headers, executes PHP code, registers hooks, and loads classes. We also distinguished between activation, deactivation, and the normal loading process that occurs on every page request.

Understanding this lifecycle gives us a strong conceptual foundation for every feature we’ll build in the remaining lessons.


Key Takeaways

  • ✓ WordPress loads active plugins during every request.
  • ✓ Plugin headers are read by WordPress, not PHP.
  • ✓ ABSPATH exists because WordPress has already started.
  • ✓ Activation hooks are registered during loading but execute only during activation.
  • ✓ Classes are loaded only after the main plugin file executes.
  • ✓ Understanding the plugin lifecycle makes debugging much easier.

Common Mistakes

  • Assuming activation hooks run on every page load.
  • Placing expensive operations outside hooks, causing them to execute on every request.
  • Removing user data during plugin deactivation.
  • Confusing plugin registration with plugin execution.

Git Commands Used

git add .

git commit -m "Lesson 3: Understand the WordPress plugin lifecycle"

git push

Project Status

✅ Development environment

✅ Plugin skeleton

✅ Plugin installation

✅ Plugin lifecycle

⬜ .gitignore

⬜ Database tables

⬜ Auction data model

⬜ Bidding engine

⬜ Escrow

⬜ Payment gateways

⬜ Website transfer

⬜ Version 1.0

Developer’s Notebook

One of the biggest milestones in becoming a professional WordPress developer is realizing that your code doesn’t run in isolation. Every plugin participates in WordPress’s startup process. The better you understand that process, the easier it becomes to write efficient, secure, and maintainable plugins. Throughout the remainder of this series, we’ll continue referring back to the plugin lifecycle as we introduce hooks, database tables, AJAX, REST APIs, and background tasks.


Looking Ahead

In Lesson 4, we’ll create our first .gitignore file and begin preparing the project for long-term development. We’ll also discuss which files belong in Git, which should never be committed, and why professional developers treat generated files differently from source code.

Lesson 1: Creating Your First WordPress Plugin

Welcome to Lesson 1 of the Building Flipnzee Auctions series.

In the previous lesson, we created our GitHub repository, launched GitHub Codespaces, organized our project, and learned the basics of version control.

Now it’s time to write our first PHP code.

By the end of this lesson, you’ll have a WordPress plugin that appears in the Plugins page of your WordPress website and can be activated just like any other plugin.

Although the plugin won’t do anything yet, this is an exciting milestone because we’re laying the foundation for everything that follows.


What You’ll Learn

In this lesson you’ll learn how to:

  • Create the WordPress plugin folder
  • Create the main plugin file
  • Understand the plugin header
  • Protect your plugin from direct access
  • Define reusable plugin constants
  • Register activation and deactivation hooks
  • Create a simple loader class
  • Commit your changes to GitHub

Step 1: Enter the Plugin Folder

Open the integrated terminal in GitHub Codespaces.

Navigate into the plugin folder:

cd flipnzee-auctions

Confirm your location:

pwd

You should see something similar to:

/workspaces/flipnzee-auctions/flipnzee-auctions

From now on, everything we create belongs inside this folder.


Step 2: Create the Main Plugin File

Create the plugin’s main PHP file.

GUI Method

Click New File in the Explorer.

Create:

flipnzee-auctions.php

Terminal Method

touch flipnzee-auctions.php

Open it:

code flipnzee-auctions.php

Step 3: Add the Plugin Header

Copy the following code into the file.

<?php
/**
 * Plugin Name: Flipnzee Auctions
 * Plugin URI: https://flipnzee.com
 * Description: Professional website auction platform for Flipnzee.
 * Version: 1.0.0
 * Author: Splendid Digital Solutions
 * Author URI: https://flipnzee.com
 * License: GPL v2 or later
 * Text Domain: flipnzee-auctions
 * Domain Path: /languages
 * Requires at least: 6.5
 * Requires PHP: 8.1
 */

if (!defined('ABSPATH')) {
    exit;
}

Save the file.

Congratulations!

You’ve just created the smallest possible WordPress plugin.


Understanding the Plugin Header

Everything inside the comment block is called the Plugin Header.

When WordPress scans the plugins directory, it looks for these special comments.

Let’s understand each line.

Plugin Name

Plugin Name: Flipnzee Auctions

This is the name displayed on the Installed Plugins page.


Plugin URI

Plugin URI: https://flipnzee.com

This points users to the official plugin website.


Description

Description: Professional website auction platform for Flipnzee.

A short explanation shown beneath the plugin name.


Version

Version: 1.0.0

Every release should have a version number.

Later we’ll learn about semantic versioning.


Author

Author: Splendid Digital Solutions

Displays the plugin developer.


Author URI

Author URI: https://flipnzee.com

Links to your website.


Text Domain

Used for translating the plugin into different languages.


Requires PHP

Requires PHP: 8.1

Prevents installation on servers running older PHP versions.


Step 4: Protect Against Direct Access

Immediately below the plugin header we added:

if (!defined('ABSPATH')) {
    exit;
}

Why?

Imagine someone tries to visit:

https://example.com/wp-content/plugins/flipnzee-auctions/flipnzee-auctions.php

directly in their browser.

Without this check, PHP would execute the file outside of WordPress.

By checking whether ABSPATH exists, we ensure the file only runs when WordPress has already been loaded.

This is one of the simplest and most important WordPress security practices.


Step 5: Define Plugin Constants

Below the security check add:

define('FLIPNZEE_AUCTION_VERSION', '1.0.0');

define('FLIPNZEE_AUCTION_PATH', plugin_dir_path(__FILE__));

define('FLIPNZEE_AUCTION_URL', plugin_dir_url(__FILE__));

Constants allow us to define values once and reuse them throughout the plugin.

For example:

FLIPNZEE_AUCTION_PATH

is much cleaner than repeatedly writing:

plugin_dir_path(__FILE__)

Step 6: Register the Activation Hook

Add:

function flipnzee_auction_activate() {

    flush_rewrite_rules();

}

register_activation_hook(__FILE__, 'flipnzee_auction_activate');

This function runs automatically when the plugin is activated.

Today it only refreshes WordPress rewrite rules.

Later it will also create our database tables.


Step 7: Register the Deactivation Hook

Add:

function flipnzee_auction_deactivate() {

    flush_rewrite_rules();

}

register_deactivation_hook(__FILE__, 'flipnzee_auction_deactivate');

This runs whenever the plugin is deactivated.


Step 8: Create the Includes Folder

Professional plugins avoid placing thousands of lines inside one file.

Create a folder named:

includes

Inside it, create a new file:

class-loader.php

Step 9: Load the Loader Class

Back in flipnzee-auctions.php, add:

if (file_exists(FLIPNZEE_AUCTION_PATH . 'includes/class-loader.php')) {
    require_once FLIPNZEE_AUCTION_PATH . 'includes/class-loader.php';
}

This prepares the plugin for modular development.


Step 10: Create the Loader Class

Open:

includes/class-loader.php

Add:

<?php

if (!defined('ABSPATH')) {
    exit;
}

class Flipnzee_Auction_Loader
{

    public function __construct()
    {

    }

}

new Flipnzee_Auction_Loader();

Although the class is currently empty, it will eventually load every component of our plugin, including auctions, bids, payments, reports, APIs, and notifications.


Folder Structure After Lesson 1

flipnzee-auctions/

│
├── flipnzee-auctions.php
│
└── includes/
      └── class-loader.php

Commit Your Changes

Open Source Control.

Use the commit message:

Lesson 1: Create plugin skeleton

Commit your changes.

Then click Sync Changes.

Your plugin skeleton is now safely stored in GitHub.


Summary

Congratulations!

You’ve officially written your first WordPress plugin.

Although it doesn’t yet contain any auction functionality, you’ve created the foundation that every future lesson will build upon.

Lesson Summary

In this lesson, we built the foundation of the Flipnzee Auctions plugin using GitHub Codespaces. We created the main plugin file, added the WordPress plugin header, protected the plugin from direct access, defined reusable constants, registered activation and deactivation hooks, and introduced a loader class to prepare for a modular architecture.

Although the plugin is still in its early stages, we’ve established a professional project structure that will allow us to add features in a clean and maintainable manner as the series progresses.


Key Takeaways

  • ✓ Every WordPress plugin begins with a properly formatted plugin header.
  • ✓ WordPress automatically discovers plugins by reading their headers.
  • ✓ The ABSPATH check prevents direct access to plugin files.
  • ✓ Plugin constants reduce repetition and improve maintainability.
  • ✓ Activation and deactivation hooks allow WordPress to execute code at important points in the plugin lifecycle.
  • ✓ A loader class helps organize larger plugins into smaller, reusable components.

Common Mistakes

When completing this lesson, beginners often encounter one or more of the following issues:

  • Creating files in the GitHub repository root instead of the flipnzee-auctions plugin folder.
  • Forgetting to save files before committing changes.
  • Omitting the opening <?php tag.
  • Misspelling one of the required plugin header fields.
  • Creating the includes folder in the wrong location.
  • Forgetting to commit and sync changes to GitHub.

If your plugin does not appear in the WordPress Plugins page, review each of these items before moving on.


Git Commands Used

During this lesson, we used the following Git and terminal commands:

cd flipnzee-auctions

touch flipnzee-auctions.php

mkdir includes

touch includes/class-loader.php

git add .

git commit -m "Lesson 1: Create plugin skeleton"

git push

Project Status

✅ Development environment ready

✅ GitHub repository created

✅ GitHub Codespaces configured

✅ Plugin skeleton completed

⬜ Database installation

⬜ Auction engine

⬜ Bidding system

⬜ Escrow workflow

⬜ Payment gateways

⬜ Website transfer

⬜ Reports & Analytics

⬜ REST API

⬜ Version 1.0 Release

Source Code

The complete source code for this project is maintained in the official GitHub repository.

Rather than embedding the full source code in every lesson, the GitHub repository serves as the single source of truth and always contains the latest version of the project. This allows the tutorial series to focus on explaining concepts and design decisions while ensuring readers have access to the most up-to-date implementation.

(Insert your GitHub repository link here.)


Developer’s Notebook

One of the biggest mistakes new developers make is trying to build an entire application before creating a solid foundation.

Professional software projects evolve incrementally. We start with a minimal but well-structured plugin, verify that it works, and then add one feature at a time. This approach makes debugging easier, keeps the codebase organized, and reduces the likelihood of introducing difficult-to-find bugs.

Throughout this series, you’ll see the Flipnzee Auctions plugin grow from a simple plugin skeleton into a fully featured website auction platform. By following this step-by-step approach, you’ll not only build a working plugin but also gain insight into how experienced WordPress developers approach large software projects.


Looking Ahead

In Lesson 2, we’ll package our plugin into a ZIP file, install it on a WordPress website, activate it, and verify that WordPress recognizes it as a valid plugin. This will be the first time we see the Flipnzee Auctions plugin running inside WordPress.


Lesson 0: Setting Up Your Development Environment with GitHub Codespaces

Welcome to Lesson 0 of the Building Flipnzee Auctions series.

Before writing a single line of PHP, let’s prepare our development environment.

Many WordPress tutorials begin by creating a folder inside wp-content/plugins and editing files directly on the server. While that approach works, it doesn’t scale well and doesn’t teach the workflow used by most professional developers.

Throughout this series, we’ll use GitHub Codespaces as our development environment. This means you can build your plugin entirely in your web browser, keep your code safely backed up in GitHub, and deploy it to any WordPress website by simply uploading a ZIP file.

Even if you’ve never used Git or GitHub before, don’t worry. We’ll learn everything step by step.


Why Use GitHub Codespaces?

GitHub Codespaces provides a complete Visual Studio Code development environment in your browser.

There is no need to install:

  • PHP
  • Apache
  • MySQL
  • Visual Studio Code
  • Git

Everything runs in the cloud.

Some of the benefits include:

  • Develop from any computer
  • Automatic backups with Git
  • Professional development workflow
  • Easy collaboration
  • No risk of accidentally breaking your live website
  • Perfect for open-source projects

By the end of this series, your entire plugin will be stored in a GitHub repository that you can continue improving for years.


Our Development Workflow

Every lesson in this series will follow the same workflow.

GitHub Repository
        │
        ▼
GitHub Codespaces
        │
        ▼
Develop & Test
        │
        ▼
Commit Changes
        │
        ▼
Push to GitHub
        │
        ▼
Download Plugin ZIP
        │
        ▼
WordPress Dashboard
        │
        ▼
Plugins → Add New
        │
        ▼
Upload Plugin
        │
        ▼
Activate Plugin

This is a modern workflow that combines version control with WordPress development.


Step 1: Create a GitHub Account

If you don’t already have one, create a free GitHub account.

Once your account is ready, sign in.


Step 2: Create a New Repository

Click the New Repository button.

Repository Name:

flipnzee-auctions

Choose:

  • Public (recommended for learning)
  • Add a README file
  • Add a .gitignore (choose None for now)
  • License: GPL-3.0 (or leave blank—we’ll add one later)

Click Create Repository.

Congratulations! You’ve just created the home of your plugin.


Step 3: Launch GitHub Codespaces

Inside your repository:

  1. Click the green Code button.
  2. Select the Codespaces tab.
  3. Click Create Codespace on main.

GitHub will prepare your development environment.

The first launch may take a minute or two.

When it finishes, you’ll see a browser-based version of Visual Studio Code.


Step 4: Explore the Interface

Spend a few minutes becoming familiar with the layout.

You’ll see:

  • Explorer (your project files)
  • Search
  • Source Control (Git)
  • Run & Debug
  • Extensions
  • Terminal

Don’t worry if some of these seem unfamiliar. We’ll use them throughout the series.


Step 5: Create the Plugin Folder

In the Explorer, create a new folder named:

flipnzee-auctions

This folder will eventually become the ZIP file that we’ll upload to WordPress.


Step 6: Open the Integrated Terminal

From the menu:

Terminal → New Terminal

Try a few basic commands:

pwd

Displays your current location.

ls

Lists files and folders.

Navigate into your plugin folder:

cd flipnzee-auctions

Confirm your location:

pwd

Learning a few terminal commands now will make development much easier later.


Step 7: Organize Your Repository

Before we start writing plugin code, let’s organize our GitHub repository like a professional software project.

It’s important to understand that a GitHub repository and a WordPress plugin are not exactly the same thing.

Think of the repository as the home for your entire project. Besides the plugin itself, it also contains documentation, licenses, changelogs, and other files that help you manage and distribute the project.

By the end of this step, your repository should look like this:

flipnzee-auctions/                 ← GitHub Repository

│
├── README.md
├── ROADMAP.md
├── LICENSE
├── CHANGELOG.md
│
└── flipnzee-auctions/             ← WordPress Plugin Folder

Notice that there are two folders named flipnzee-auctions.

The outer one is your GitHub repository, while the inner one will become the actual WordPress plugin.

When we eventually upload our plugin to WordPress, we’ll package only the inner folder into a ZIP file.


Step 8: Create the ROADMAP.md File

In the root of your GitHub repository (not inside the plugin folder), create a file named:

ROADMAP.md

Add the following content:

# Flipnzee Auctions Roadmap

## Version 1.0

- Plugin Skeleton
- Database Tables
- Auction Engine
- Website Listings
- Proxy Bidding
- Watchlist
- Buy Now
- Escrow Workflow
- Payment Methods
- Website Transfer
- Email Notifications
- Reports
- REST API

## Future Versions

- Live Bidding
- AI Website Valuation
- Multi-vendor Marketplace
- Stripe Integration
- WooCommerce Integration
- Mobile App API

This roadmap will evolve throughout the project and serve as our development checklist.


A Note About README.md

You may have noticed that your repository already contains a file named README.md.

That’s perfectly normal.

If you created your repository with the “Add a README file” option enabled, GitHub automatically generated this file for you. This is standard practice and gives every repository a landing page describing the project.

We’ll continue updating this README.md throughout the series as our plugin evolves. By the time we release Flipnzee Auctions v1.0, it will contain installation instructions, feature highlights, requirements, screenshots, and developer documentation.

For now, there’s nothing you need to change in README.md. We’ll focus on creating the remaining project files.

Step 9: Create a CHANGELOG.md File

Professional software projects maintain a changelog that records significant changes between releases.

Create a file named:

CHANGELOG.md

Add the following content:

# Changelog

## Version 1.0.0

- Initial project setup

As we complete each lesson, we’ll update this file with new features and improvements.


Step 10: Review the Repository Structure

Your repository should now look similar to this:

flipnzee-auctions/
│
├── README.md
├── ROADMAP.md
├── CHANGELOG.md
├── LICENSE
│
└── flipnzee-auctions/

At this stage, the inner flipnzee-auctions folder is intentionally empty.

In the next lesson, we’ll begin transforming it into a real WordPress plugin by creating our first PHP file and adding the plugin header.


Step 11: Commit Your Changes

Now that the repository is organized, it’s time to save your progress.

Open the Source Control panel in GitHub Codespaces.

You’ll see the newly created files waiting to be committed.

Use the following commit message:

Lesson 0: Initial project setup

If you prefer using the terminal, run:

git add .
git commit -m "Lesson 0: Initial project setup"
git push

This creates the first milestone in your project’s history and safely stores your work in GitHub.


Summary

Congratulations!

Although we haven’t written any PHP yet, you’ve already adopted a professional development workflow.

Your project now includes:

  • A GitHub repository
  • GitHub Codespaces as your development environment
  • A project roadmap
  • A changelog
  • A clean repository structure ready for development

In Lesson 1, we’ll move into the flipnzee-auctions plugin folder and create the first PHP file that WordPress recognizes as a plugin.

GUI vs Terminal: Which Should You Use for WordPress Plugin Development?

If you’re just starting your journey into WordPress plugin development, one of the first things you’ll notice is that experienced developers often use the terminal (command line), while beginners usually prefer the graphical user interface (GUI).

Should you force yourself to learn the terminal immediately? Or is it perfectly acceptable to rely on the GUI?

The answer is simpler than you might think.

What Is a GUI?

A Graphical User Interface (GUI) lets you interact with your computer using windows, buttons, icons, and menus.

Examples include:

  • Windows File Explorer
  • macOS Finder
  • GitHub Codespaces Explorer
  • Visual Studio Code Explorer
  • WordPress Dashboard

Instead of typing commands, you simply click your way through folders and files.

For example, creating a new file in GitHub Codespaces can be as simple as:

  • Click the New File button
  • Type ROADMAP.md
  • Press Enter

No commands required.

What Is a Terminal?

A terminal is a text-based interface where you type commands instead of clicking buttons.

For example, instead of creating a file using the mouse, you could type:

touch ROADMAP.md

Instead of opening a folder, you might type:

cd flipnzee-auctions

Instead of listing files, you would type:

ls

The terminal may seem intimidating at first, but it is simply another way of communicating with your computer.

GUI vs Terminal

TaskGUITerminal
Create a fileClick New Filetouch filename
Create a folderClick New Foldermkdir foldername
Rename a fileRight-click → Renamemv oldname newname
Delete a fileRight-click → Deleterm filename
Open a fileDouble-clickcode filename
View filesExplorerls
Change foldersClick folderscd foldername

Both approaches accomplish the same goal.

Why Do Professional Developers Use the Terminal?

There are several reasons.

Speed

Typing one command is often faster than clicking through multiple menus.

For example:

mkdir includes admin public assets languages

creates five folders instantly.

Automation

Many development tools only work from the command line.

Examples include:

git status
composer install
npm install
phpunit

As your projects grow, these tools become increasingly valuable.

Universal Skills

Whether you’re working with WordPress, Laravel, Django, Node.js, or Linux servers, terminal knowledge transfers across technologies.

Learning a handful of commands today will continue to benefit you for years.

Does That Mean Beginners Should Avoid the GUI?

Absolutely not.

In fact, beginners often learn more effectively by combining both approaches.

Suppose you create a file using the Explorer. Later, you learn the equivalent terminal command:

touch ROADMAP.md

Now you’ve learned two different ways to accomplish the same task.

Over time, you’ll naturally begin using whichever method feels more efficient.

Our Approach in This Tutorial Series

Throughout the Building Flipnzee Auctions series, we’ll demonstrate both methods whenever practical.

For example, if we create a new folder, you’ll learn:

GUI Method

  • Click New Folder
  • Enter the folder name
  • Press Enter

Terminal Method

mkdir includes

This dual approach allows every reader to progress comfortably, regardless of prior experience.

There’s No “Right” Way

Some developers spend nearly their entire day inside Visual Studio Code without touching the terminal.

Others rarely use the mouse.

Both groups build excellent software.

The goal isn’t to replace one with the other. Instead, it’s to understand that both interfaces are simply different tools for interacting with the same files.

As your confidence grows, you’ll likely find yourself using the GUI for visual tasks and the terminal for repetitive or automated work.

Final Thoughts

Don’t feel pressured to master the terminal overnight.

Start with the GUI if it makes you comfortable. Learn one or two terminal commands each week. Before long, commands like cd, ls, pwd, git status, and touch will become second nature.

Remember, great developers aren’t defined by whether they use a mouse or a keyboard. They’re defined by their ability to solve problems, write clean code, and continue learning.

Every expert was once a beginner who typed their first command.

Introducing the Flipnzee Auctions Plugin Development Series

Have you ever wondered how website marketplaces like Flippa allow buyers to place bids, make offers, purchase websites, and complete secure transfers? If you’re a WordPress developer, you may have searched for an auction plugin only to discover that most are designed for physical products rather than digital assets such as websites and domain names.

In this new series on WPNzee, we’re going to build a professional WordPress auction plugin from the ground up.

This won’t be a collection of isolated code snippets. Instead, it will be a structured, real-world software development project where each lesson builds upon the previous one. By the end of the series, we’ll have created a fully functional plugin that powers website auctions for Flipnzee.

What We’re Building

The plugin, Flipnzee Auctions, is designed specifically for buying and selling websites. It will eventually include features such as:

  • Website auction listings
  • Starting price and reserve price
  • Buy Now option
  • Automatic proxy bidding
  • Bid history
  • Watchlist
  • Countdown timers
  • Escrow-based payments
  • Alternative payment methods including PayPal, Wise, Payoneer, bank transfer, and cryptocurrency
  • Buyer and seller dashboards
  • Website transfer checklist
  • Auction reports and analytics
  • Email notifications
  • Security and anti-fraud measures

Rather than trying to build everything at once, we’ll develop the plugin step by step, just as a professional software team would.

Who Is This Series For?

This series is intended for:

  • WordPress developers
  • PHP developers
  • Plugin developers
  • Freelancers
  • Agency owners
  • Computer science students
  • Anyone who wants to learn how large WordPress plugins are architected

A basic understanding of PHP and WordPress will be helpful, but every important concept will be explained along the way.

What Makes This Series Different?

Many tutorials stop after creating a simple plugin that displays “Hello World.”

This series is different.

We’ll discuss software architecture, database design, WordPress coding standards, security, performance, scalability, maintainability, and clean code. Every lesson will explain not only what we’re building, but also why we’re building it that way.

Our goal is to produce a plugin that is robust enough for production use while serving as an educational resource for developers who want to build professional WordPress applications.

How the Series Will Be Organized

The series will be divided into logical stages, including:

  1. Plugin foundation and architecture
  2. Database design
  3. Auction engine
  4. Bidding system
  5. Payment workflow
  6. Escrow integration
  7. Website transfer management
  8. Notifications
  9. Reporting and analytics
  10. Testing, optimization, and release

Each lesson will contain complete source code, detailed explanations, and practical insights that you can immediately apply to your own projects.

Learn by Building

The best way to learn software development is by building something meaningful.

Instead of reading about plugin development in theory, you’ll follow the complete journey of creating a commercial-quality WordPress auction plugin from scratch.

Whether your goal is to build your own marketplace, improve your PHP skills, or better understand WordPress internals, I hope this series helps you gain both confidence and practical experience.

Let’s begin our journey with Lesson 0: Setting Up Your Development Environment with GitHub Codespaces, where we’ll lay the foundation for everything that follows.