In the previous lesson, we discussed why every professional auction system should require a minimum increase over the current highest bid. In this implementation lesson, we’ll modify the Flipnzee Auctions plugin so that users cannot place insignificant bids and always know the minimum amount required.

By the end of this implementation, the plugin will:

• Reject bids that are too low.
• Display the minimum allowed bid.
• Guide users with browser-side validation.
• Improve the overall auction experience.

Step 1: Define the Minimum Increment

Open:

includes/class-bid-manager.php

Locate the section where the current highest bid is retrieved.

Immediately afterwards, add:

/*
 * Minimum bid increment.
 */
$minimum_increment = 10;

$minimum_allowed_bid =
    (float) $current_bid +
    $minimum_increment;

This calculates the lowest amount that can be accepted.

For example:

Current Bid:      $444
Minimum Increment $10
Minimum Bid:      $454

Step 2: Validate Incoming Bids

Find the existing validation:

if ( $bid_amount <= (float) $current_bid ) {
    return false;
}

Replace it with:

/*
 * Validate minimum bid.
 */
if ( $bid_amount < $minimum_allowed_bid ) {
    return false;
}

Now every new bid must be at least Current Bid + $10.

Examples:

Step 3: Display the Minimum Bid

Open:

includes/class-shortcodes.php

Locate the auction details table.

Immediately below the Current Bid row, insert:

<tr>
    <th>Minimum Bid</th>
    <td>
        <?php
        $minimum_bid =
            (float) $auction['current_bid'] + 10;

        echo esc_html(
            '$' . number_format_i18n(
                $minimum_bid,
                0
            )
        );
        ?>
    </td>
</tr>

The auction information now becomes:

Start Price      $111
Current Bid      $444
Minimum Bid      $454
Buy Now          $333

Visitors immediately know the next valid bid amount.

Step 4: Restrict the Bid Input

Still in:

includes/class-shortcodes.php

Locate the bid input field.

Replace it with:

<?php
$minimum_bid =
    (float) $auction['current_bid'] + 10;
?>

<input
    type="number"
    step="10"
    min="<?php echo esc_attr( $minimum_bid ); ?>"
    value="<?php echo esc_attr( $minimum_bid ); ?>"
    name="bid_amount"
    placeholder="Your Bid"
    required
>

This provides three improvements:

• min prevents smaller values from being submitted.
• value pre-fills the next valid bid.
• step increases or decreases by $10 using the spinner controls.

Testing the Feature

After refreshing the auction page, the auction details should resemble:

Current Bid      $999
Minimum Bid      $1009

Your Bid
[1009]

[ Place Bid ]

Testing results:

Browser Validation

Modern browsers also assist users before the form is submitted.

Attempting to enter a value below the minimum now displays a validation message similar to:

Value must be greater than or equal to 1009.

This improves usability by informing users immediately rather than after submission.

Files Modified

During this implementation, only two files required changes:

includes/class-bid-manager.php
includes/class-shortcodes.php

Keeping the modifications localized makes the feature easier to maintain and extend.

Result

After completing this implementation, Flipnzee Auctions now provides a more professional bidding experience by:

• Enforcing a minimum bid increment on the server.
• Displaying the minimum allowed bid to visitors.
• Preventing invalid bids through browser validation.
• Reducing unnecessary or insignificant bid increases.

These enhancements make the auction process clearer, fairer, and more intuitive for bidders.

Download Source Code

Download the starting version of the plugin before the lesson:

Download the completed version after this lesson:

What’s Next?

In the next lesson, we’ll continue improving the auction experience by adding more intelligent bidding features, making Flipnzee Auctions feel even closer to a production-ready auction platform.

In Lesson 45, we transformed our auction system from simply displaying the current highest bid into a much more transparent platform by introducing Bid History.

Instead of showing only the latest bid amount, visitors can now see every bid placed on an auction, who placed it, and when it was submitted. This feature is common on professional auction platforms because it builds trust and encourages competitive bidding.

In this implementation post, we’ll walk through the complete code used to build the Bid History feature.

Step 1: Create a Method to Retrieve Bids

The first step is to retrieve all bids for a particular auction from the database.

Open:

includes/class-bid-manager.php

Add the following method inside the Flipnzee_Bid_Manager class.

/**
 * Get all bids for an auction.
 *
 * @param int $auction_id Auction ID.
 *
 * @return array
 */
public static function get_bids( $auction_id ) {

	global $wpdb;

	$bid_table = $wpdb->prefix . 'flipnzee_bids';

	return $wpdb->get_results(
		$wpdb->prepare(
			"SELECT *
			FROM {$bid_table}
			WHERE auction_id = %d
			ORDER BY bid_amount DESC,
			         created_at DESC",
			$auction_id
		)
	);

}

What this code does

• Retrieves every bid for the selected auction
• Uses prepared SQL statements for security
• Orders bids from highest to lowest
• Displays newer bids first if two bids have the same amount

Step 2: Retrieve Bid History Inside the Shortcode

Open:

includes/class-shortcodes.php

Locate the auction details table.

Immediately after the closing </table> tag, retrieve all bids.

<?php
$bids = Flipnzee_Bid_Manager::get_bids(
	$auction['id']
);
?>

This gives us all bids belonging to the currently displayed auction.

Step 3: Display the Bid History Heading

If bids exist, display a heading.

<h3>Bid History</h3>

Step 4: Handle Auctions With No Bids

Before creating the table, check whether any bids exist.

<?php if ( empty( $bids ) ) : ?>

<p>No bids have been placed yet.</p>

<?php else : ?>

This provides a better user experience than displaying an empty table.

Step 5: Create the Bid History Table

Now create the HTML table.

<table class="flipnzee-bid-history">

<thead>

<tr>

<th>Bidder</th>

<th>Amount</th>

<th>Time</th>

</tr>

</thead>

<tbody>

Step 6: Display Every Bid

Loop through all bids.

<?php foreach ( $bids as $bid ) : ?>

<?php
$user = get_userdata(
	$bid->bidder_id
);
?>

<tr>

<td>

<?php
echo esc_html(
	$user
	? $user->display_name
	: 'Unknown'
);
?>

</td>

<td>

<?php
echo '$' .
	number_format_i18n(
		$bid->bid_amount,
		2
	);
?>

</td>

<td>

<?php
echo esc_html(
	wp_date(
		'd M Y g:i A',
		strtotime(
			$bid->created_at
		)
	)
);
?>

</td>

</tr>

<?php endforeach; ?>

This code displays:

• Bidder name
• Bid amount
• Bid date and time

Step 7: Close the Table

Finish the table.

</tbody>

</table>

<?php endif; ?>

Step 8: Improve the Table Appearance

Open:

assets/css/frontend.css

Add the following styles.

.flipnzee-bid-history{
	width:100%;
	border-collapse:collapse;
	margin:20px 0;
}

.flipnzee-bid-history th,
.flipnzee-bid-history td{
	padding:10px;
	border-bottom:1px solid #ddd;
	text-align:left;
	white-space:nowrap;
}

.flipnzee-bid-history th{
	background:#f5f5f5;
	font-weight:600;
}

This produces a cleaner and more professional table.

Final Result

After completing this lesson, each auction page now displays something like:

Visitors can immediately understand:

• Who is bidding
• How the auction has progressed
• When bids were placed
• The current competition

Troubleshooting During Development

While implementing this feature, a few issues were encountered and resolved:

• Initially, the page displayed “No bids have been placed yet.” even though bids existed in the database.
• A temporary debug statement was added to display the current auction ID, confirming that the correct auction (Auction ID: 31) was being queried.
• After verifying the auction ID and database records, the bid history displayed correctly.
• The bid amount column initially wrapped because of the narrow card layout; this was improved using CSS with white-space: nowrap.
• The raw database timestamp was replaced with a more readable format using wp_date().

These small debugging steps are a normal part of plugin development and highlight the importance of verifying data flow before assuming the query itself is incorrect.

What We Achieved

By the end of this implementation, Flipnzee Auctions gained another feature found in professional auction platforms:

• ✅ Secure database retrieval of bid history
• ✅ Display bidder names
• ✅ Display bid amounts
• ✅ Display bid timestamps
• ✅ Graceful handling of auctions with no bids
• ✅ Clean, responsive frontend table
• ✅ Increased transparency and trust for bidders

Download Source Code

Download the starting version of the plugin before the lesson:

Download the completed version after this lesson:

In the next lesson, we’ll enhance the bidding engine further by introducing Minimum Bid Increment Validation, ensuring that every new bid must exceed the current highest bid by a configurable minimum amount.

One of the biggest milestones in the Flipnzee Auctions project was transforming auctions from static listings into interactive auctions where visitors can actually place bids. In this lesson, the bidding engine was implemented from scratch, allowing authenticated users to compete for auction listings in real time.

What We Built

By the end of this lesson, the plugin supports:

• Creating a dedicated database table for bids
• Recording every bid placed by users
• Updating the current highest bid automatically
• Displaying a bid form on the frontend
• Validating that new bids are higher than the existing bid
• Persisting bid history in the database

This is the first version of a fully functional auction engine.

Step 1: Creating the Bid Database Table

A new database table named wp_flipnzee_bids was introduced.

The table stores:

• Auction ID
• Bidder ID
• Bid Amount
• Timestamp

Each bid is preserved permanently, creating a complete bidding history for every auction.

Unlike simply updating a single value, storing individual bids allows future features such as:

• Bid history
• Highest bidder tracking
• Auction analytics
• Winner determination
• Escrow integration

Step 2: Building the Bid Manager

A brand-new class called:

Flipnzee_Bid_Manager

was created.

This class became responsible for all bidding operations, including:

• Receiving new bids
• Checking the current highest bid
• Rejecting invalid bids
• Saving successful bids
• Updating the auction’s current bid

Separating bidding logic into its own class keeps the plugin modular and much easier to maintain.

Step 3: Saving Bids

When a visitor submits a bid:

1. The auction is identified.
2. The existing highest bid is retrieved.
3. The new amount is compared against the current bid.
4. Valid bids are inserted into the bids table.
5. The auction record is updated with the new highest bid.

This ensures that the auction table always reflects the latest highest bid while preserving every historical bid.

Step 4: Adding the Frontend Bid Form

The auction card on the frontend was enhanced with a simple bidding interface.

Visitors who are logged in can now enter a bid amount and submit it directly from the auction listing.

If the visitor is not logged in, the interface instead prompts them to sign in before participating.

This provides a clean foundation for future enhancements without complicating the user experience.

Step 5: Processing Bid Requests

A new request handler was added to process submitted bids securely.

The handler performs several important tasks:

• Verifies the WordPress nonce
• Ensures the user is authenticated
• Sanitizes user input
• Calls the Bid Manager
• Redirects the visitor back to the auction page

Using WordPress admin-post actions keeps the implementation aligned with WordPress coding standards.

Step 6: Testing the Complete Workflow

The implementation was verified through several tests.

The following scenarios were successfully completed:

• Bid form displayed correctly
• Bid submitted successfully
• Bid stored in the database
• Current bid updated automatically
• Multiple bids recorded correctly
• Frontend reflected the new highest bid

Database verification confirmed that both the wp_flipnzee_bids and wp_flipnzee_auctions tables were updated correctly after each successful bid.

Challenges Encountered

Several implementation issues were encountered during development, including:

• Loading the new Bid Manager class correctly
• Registering new WordPress action hooks
• Resolving PHP syntax errors after adding new functionality
• Ensuring database tables were created properly
• Confirming that current bids updated after inserts
• Troubleshooting bid submission until the complete workflow functioned correctly

These debugging sessions reinforced an important lesson:

Building new features often involves more time spent integrating and testing than writing the original code.

Why This Matters

This lesson transformed the plugin from a simple auction display into a genuine auction platform.

Before this lesson, visitors could only view auction information.

After this lesson, they can actively participate by placing bids that are securely stored and reflected immediately as the current highest bid.

Many advanced features now become possible because this foundation exists.

Download Source Code

Download the starting version of the plugin before the lesson:

Download the completed version after this lesson:

What’s Next?

In the next lesson, we’ll improve the bidding experience by introducing features such as:

• Displaying bid history
• Validating minimum bid increments
• Preventing bids after auctions end
• Better user feedback after bid submission
• Additional auction rules and safeguards

These improvements will make the auction system more robust while preparing it for future features such as automatic winner selection and escrow integration.

Key Takeaways

• Separate functionality into dedicated manager classes.
• Store every bid instead of only the highest bid.
• Always validate user input before writing to the database.
• Use WordPress nonces and admin-post handlers for secure form processing.
• Test every database operation thoroughly to verify the entire workflow.

Lesson Outcome: By the end of Lesson 44, Flipnzee Auctions supports real bid placement with database persistence and automatic highest-bid tracking, laying the groundwork for a complete online auction platform.

In the previous lesson, we designed the concept of dynamic auction status badges to provide visitors with a quick visual indication of an auction’s current state. In this lesson, we implemented that functionality in the Flipnzee Auctions plugin and integrated it into the frontend auction cards.

Instead of requiring visitors to interpret countdown timers or auction dates, the plugin now displays a clear, color-coded status badge that updates automatically based on the auction’s current status.

Why Auction Status Badges Matter

When visitors browse multiple auctions, they should be able to identify their status instantly.

A simple badge helps answer questions like:

• Is this auction currently active?
• Has it already ended?
• Is it scheduled to begin later?
• Has it been cancelled?

Providing this information visually improves usability and creates a more professional marketplace experience.

Badge States

The plugin now supports displaying badges for various auction states, including:

• 🟢 Active
• 🔴 Auction Ended
• 🟡 Scheduled
• ⚪ Draft
• ⚫ Cancelled (for future use)

Each badge uses a distinct color and label, making the auction status immediately understandable.

Implementing the Badge

The auction card template was updated to output a badge based on the auction’s status.

Instead of hardcoding text, the badge is generated dynamically using the auction record stored in the database.

This keeps the display synchronized with the auction’s actual state.

Styling the Badge

Custom CSS was added to improve the appearance of the badges.

The styling includes:

• rounded corners
• background color
• readable text color
• padding
• spacing from surrounding elements

The result is a compact status indicator that integrates naturally into the auction card design.

Improving the User Experience

Visitors no longer need to calculate whether an auction has ended by reading dates and times.

The badge communicates the auction status immediately.

This small enhancement significantly improves the browsing experience, particularly when multiple auctions are displayed on the same page.

Testing the Feature

After implementing the badges, different auction records were tested to verify that:

• Active auctions displayed the correct badge.
• Ended auctions showed an “Auction Ended” badge.
• Badge styling remained consistent across listings.
• The status updated correctly based on the auction data.

Challenges During Development

While implementing this lesson, development naturally expanded into improving the auction management workflow.

This led to the beginning of an Edit Auction feature, allowing administrators to modify auction details from the WordPress dashboard. During this process, several unexpected issues arose—particularly with updating auction start and end dates—which required extensive debugging.

One important takeaway was that implementing a feature is only part of development; carefully tracing data from the form, through WordPress, and into the database is equally important when diagnosing unexpected behavior.

What I Learned

This lesson reinforced several practical WordPress development concepts:

• Displaying dynamic frontend content
• Using database values to control the user interface
• Writing reusable conditional logic
• Improving user experience through visual indicators
• Enhancing plugin design with simple CSS styling

Tips for Plugin Developers

• Use colors consistently throughout your plugin.
• Display important information visually whenever possible.
• Keep frontend status indicators synchronized with backend data.
• Small UI improvements often have a significant impact on usability.
• Test every possible status to ensure the correct badge is displayed.

Final Thoughts

Dynamic auction status badges are a small feature that greatly improves the overall professionalism of an auction website. Rather than relying solely on dates or countdown timers, visitors receive an immediate visual cue about each auction’s current state.

Download Source Code

Download the starting version of the plugin before the lesson:

Download the completed version after this lesson: