In the previous lesson, we introduced automatic auction closure based on the auction end time. While that prevented late bids, it also exposed an important usability issue—once an auction was marked as closed, the entire auction disappeared from the frontend.

In this lesson, we’ll improve the user experience by displaying completed auctions instead of hiding them. Visitors will still be able to see the auction results, while bidding will be disabled.

What You’ll Learn

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

• Display both active and closed auctions.
• Show an Auction Closed status message.
• Continue displaying the final bid amount.
• Display the winning bidder.
• Keep the complete bid history visible.
• Disable the bid form once the auction has ended.
• Improve transparency and trust for buyers and sellers.

Why This Matters

Imagine visiting an auction page only to discover that it has completely disappeared after the auction ended.

Questions immediately arise:

• Who won?
• What was the final bid?
• Was the auction successful?
• Is the page broken?

Professional auction platforms never hide completed auctions. Instead, they preserve the auction page as a permanent record.

Examples include:

• eBay
• Heritage Auctions
• Sotheby’s
• Copart

Visitors can still review the auction outcome even though bidding has ended.

Current Behaviour

At present, our shortcode behaves roughly like this:

if ( $auction['status'] !== 'active' ) {
    return '';
}

As soon as the auction status changes to closed, nothing is displayed.

Desired Behaviour

Instead of hiding the auction, we’ll show something like this:

Status
Closed

Winning Bid
$55,555,579

Winner
Rajeev Bagra

Auction Ended
15 Aug 2026 15:14 UTC

🏆 This auction has ended.
No further bids are accepted.

The bid history will remain visible.

Only the bidding form will disappear.

Implementation Plan

During this lesson we’ll:

Step 1

Remove the logic that hides closed auctions.

Step 2

Display an “Auction Closed” badge whenever the auction status is closed.

Step 3

Continue showing:

• Start Price
• Current Bid
• Highest Bidder
• Buy Now Price
• Auction End Time
• Bid History

Step 4

Hide only:

• Bid input field
• Place Bid button

Step 5

Display a friendly message:

🏁 This auction has ended. No further bids are accepted.

Benefits

After completing this lesson, Flipnzee Auctions will provide a much more professional experience.

Visitors will be able to:

• Verify who won the auction.
• See the final selling price.
• Review the complete bid history.
• Trust that auctions are permanently recorded.
• Understand immediately that bidding has ended.

What We’ll Build

By the end of this lesson, every completed auction page will resemble a real-world auction result page instead of disappearing completely.

This lays the foundation for future enhancements such as:

• 🏆 Winner badges
• 🎉 Sold ribbons
• Seller notifications
• Winner email notifications
• Auction archives
• Recently Sold listings
• Searchable auction history

Next Lesson

Lesson 53: Highlight the Winning Bidder and Final Selling Price for Closed Auctions

In the next lesson, we’ll enhance the completed auction page by prominently displaying the winner and the final sale price with improved styling, making the auction results more visually appealing and easier to understand.

One of the biggest frustrations in online auctions is bid sniping—when someone waits until the final few seconds before placing a bid, leaving other bidders with no opportunity to respond. Many professional auction platforms solve this by automatically extending the auction if a bid is received near the end.

In this lesson, we implemented the same feature in the Flipnzee Auctions plugin. Whenever a valid bid is placed during the final 60 seconds of an auction, the auction end time is automatically extended by five minutes.

What We Built

The auction system now:

• Detects every successful bid.
• Checks how much time remains before the auction ends.
• If 60 seconds or less remain:
  • Extends the auction by five minutes.
  • Updates the auction end time in the database.
• Otherwise, the auction continues normally.

This gives every interested bidder a fair opportunity to respond.

Step 1: Locate the Bid Processing Method

Open:

includes/class-bid-manager.php

Locate:

public static function place_bid(

This method already:

• validates bids,
• inserts the bid into the database,
• updates the auction’s current highest bid.

Step 2: Keep the Existing Current Bid Update

After a successful bid, the plugin already updates the auction table.

$wpdb->update(
    $auction_table,
    array(
        'current_bid' => $bid_amount,
    ),
    array(
        'id' => $auction_id,
    ),
    array(
        '%f',
    ),
    array(
        '%d',
    )
);

Immediately after this block, we inserted the anti-sniping logic.

Step 3: Retrieve the Auction End Time

First, fetch the current auction end time.

$auction = $wpdb->get_row(
    $wpdb->prepare(
        "SELECT auction_end
        FROM {$auction_table}
        WHERE id = %d",
        $auction_id
    )
);

This retrieves the existing end time directly from the database.

Step 4: Calculate Remaining Time

Convert the auction end time into a Unix timestamp.

$end_time = strtotime(
    $auction->auction_end
);

$current_time = current_time(
    'timestamp'
);

$seconds_left =
    $end_time - $current_time;

Using timestamps makes it easy to compare dates mathematically.

Step 5: Detect Last-Minute Bids

Only extend the auction if less than one minute remains.

if ( $seconds_left <= 60 ) {

    // Extend auction
}

This prevents unnecessary extensions while protecting against last-second sniping.

Step 6: Extend the Auction

Add five minutes to the existing end time.

$new_end = date(
    'Y-m-d H:i:s',
    $end_time + ( 5 * 60 )
);

Notice that:

5 × 60 = 300 seconds

The new end time is generated in MySQL datetime format.

Step 7: Save the New Auction End Time

Update the auction record.

$wpdb->update(
    $auction_table,
    array(
        'auction_end' => $new_end,
    ),
    array(
        'id' => $auction_id,
    ),
    array(
        '%s',
    ),
    array(
        '%d',
    )
);

The countdown timer will now use this updated value.

Complete Anti-Sniping Code

/*
 * Anti-sniping:
 * Extend auction by 5 minutes if
 * less than 60 seconds remain.
 */
$auction = $wpdb->get_row(
    $wpdb->prepare(
        "SELECT auction_end
        FROM {$auction_table}
        WHERE id = %d",
        $auction_id
    )
);

if ( $auction ) {

    $end_time = strtotime(
        $auction->auction_end
    );

    $current_time = current_time(
        'timestamp'
    );

    $seconds_left =
        $end_time - $current_time;

    if ( $seconds_left <= 60 ) {

        $new_end = date(
            'Y-m-d H:i:s',
            $end_time + ( 5 * 60 )
        );

        $wpdb->update(
            $auction_table,
            array(
                'auction_end' => $new_end,
            ),
            array(
                'id' => $auction_id,
            ),
            array(
                '%s',
            ),
            array(
                '%d',
            )
        );
    }
}

Why This Feature Matters

Many professional auction websites use automatic auction extensions because they:

• Prevent unfair last-second bidding.
• Give genuine buyers time to react.
• Encourage competitive bidding.
• Increase seller confidence.
• Often lead to higher final selling prices.

Instead of rewarding the fastest click during the final seconds, the auction rewards the highest genuine bidder.

Testing

Although this lesson was successfully implemented, testing was intentionally postponed.

Because auction end times depend on server time and WordPress timezone settings, it is more practical to verify the feature during a real auction approaching its end. When a bid is placed within the final 60 seconds, the auction end time should automatically increase by five minutes.

Download Source Code

Download the starting version of the plugin before the lesson:

Download the completed version after this lesson:

What We Learned

In this lesson we learned how to:

• Improve auction fairness with anti-sniping logic.
• Work with Unix timestamps in PHP.
• Calculate remaining auction time.
• Update MySQL datetime values.
• Extend auction durations dynamically.
• Build a feature commonly found in commercial auction platforms.

Final Thoughts

A simple five-minute extension can significantly improve the fairness and competitiveness of an online auction. By adding anti-sniping protection, Flipnzee Auctions now behaves much more like established auction marketplaces, ensuring that every bidder has a reasonable opportunity to respond before an auction closes.

In the previous lesson, we showed users whether they are currently winning or have been outbid. However, there is still one issue with our auction system:

A user who is already the highest bidder can continue placing higher bids against themselves.

Real-world auction platforms like eBay don’t allow this because it serves no purpose. In this lesson, we’ll prevent users from bidding again if they already hold the highest bid.

Why Is This Important?

Imagine this scenario:

• Rajeev bids $500
• Rajeev is now the highest bidder
• Rajeev accidentally bids $550
• Nobody else has bid yet

The auction price increases without any competition.

Preventing this keeps auctions fair and avoids unnecessary price inflation.

The Solution

Before accepting a bid, we need to determine:

1. Who is currently the highest bidder?
2. Is the logged-in user the same person?
3. If yes, reject the bid.

This validation belongs in the bid processing logic, not just the frontend.

Step 1: Retrieve the Highest Bidder

Inside the bid placement function, retrieve the current highest bidder.

$highest_bidder =
    self::get_highest_bidder(
        $auction_id
    );

Step 2: Compare User IDs

Check whether the logged-in user already owns the highest bid.

if (
    $highest_bidder &&
    (int) $highest_bidder->bidder_id === (int) $bidder_id
) {
    return new WP_Error(
        'already_highest_bidder',
        __( 'You are already the highest bidder.', 'flipnzee-auctions' )
    );
}

Step 3: Stop Processing

If this condition is true:

• No new bid is inserted.
• Current bid remains unchanged.
• Bid history remains unchanged.

The function exits immediately.

Step 4: Display the Error

Instead of silently failing, redirect back to the auction page with an error message such as:

You are already the highest bidder.

This provides immediate feedback to the user.

Why Backend Validation Matters

Some developers disable the bid button on the frontend and think the problem is solved.

It isn’t.

A malicious user could still:

• submit the form manually
• use browser developer tools
• send a POST request directly

That’s why validation must happen inside the PHP bid processing code.

Example Flow

Current Auction

Rajeev clicks Place Bid again.

Server checks:

Current Highest Bidder = Rajeev

Current User = Rajeev

Match = TRUE

Result:

❌ Bid rejected.

Another user bids:

Now Rajeev is allowed to bid again because he is no longer the highest bidder.

Benefits

Implementing this validation provides several advantages:

• Prevents self-bidding
• Makes auctions behave like professional auction websites
• Prevents accidental price increases
• Protects users from unnecessary mistakes
• Keeps auction history meaningful
• Enforces rules securely on the server

What You’ll Learn Next

In Lesson 49, we’ll improve the bidding experience further by displaying success and error notifications after a bid is submitted, so users receive clear feedback such as:

• ✅ Bid placed successfully.
• ❌ Bid is too low.
• ❌ You are already the highest bidder.
• ❌ Auction has ended.

This will make the auction workflow much more user-friendly and professional.

In the previous lesson, we built the core bidding engine that allows logged-in users to place bids on an auction. Every successful bid is securely stored in the database and the current highest bid is updated automatically.

However, a real auction is about more than just the latest bid. Participants want to see the competition, understand how the auction has progressed, and gain confidence that the bidding process is transparent.

In this lesson, we’ll build a Bid History feature that displays every bid placed on an auction.

What You’ll Learn

By the end of this lesson you will know how to:

• Retrieve auction bids from the database
• Sort bids from highest to lowest
• Display bidder information
• Show bid timestamps
• Build a frontend bid history table
• Gracefully handle auctions with no bids

Why Bid History Matters

Imagine visiting an auction where only the highest bid is visible.

Questions immediately arise:

• How many people are bidding?
• When was the last bid placed?
• Has the auction been active?
• Is the current price increasing steadily?

Displaying bid history answers all these questions and makes the auction feel much more trustworthy.

What We Will Build

Each auction page will display something similar to this:

Visitors can immediately understand the progress of the auction.

New Functionality

We’ll enhance our plugin by adding:

• A database query to fetch bids
• Bid history retrieval method
• Frontend HTML table
• User name lookup
• Proper currency formatting
• Date and time formatting

User Experience Improvements

If no bids exist, instead of showing an empty table, visitors will see a friendly message such as:

No bids have been placed yet. Be the first bidder!

This small detail greatly improves usability.

Security Considerations

While displaying bids, we’ll ensure:

• All output is properly escaped
• User data is sanitized
• Only public information is displayed
• SQL queries use prepared statements

Following WordPress coding standards remains a priority.

Skills You’ll Practice

During this lesson you’ll gain experience with:

• Database retrieval using $wpdb
• Looping through database results
• Fetching WordPress user information
• Formatting frontend tables
• Escaping output correctly
• Improving frontend user experience

Expected Outcome

After completing this lesson, every auction page will show:

• Current highest bid
• Complete bid history
• Bidder names
• Bid amounts
• Bid timestamps

The auction will feel much more interactive and transparent.

Coming Up Next

After implementing bid history, we’ll continue improving the auction system with features such as:

• Minimum bid increments
• Automatic auction closing
• Declaring the winning bidder
• Buy Now functionality
• Auction status badges
• Email notifications

Each lesson will move Flipnzee Auctions closer to becoming a fully featured marketplace plugin.

Objective

In this lesson, we will add a Bid History section to every auction page.

Instead of only showing the current highest bid, visitors will be able to see the progression of bidding throughout the auction.

Why This Feature Matters

Every successful auction platform provides transparency.

A visible bid history helps users:

• Build confidence in the auction
• See bidding activity
• Understand how quickly prices are increasing
• Encourage competitive bidding
• Increase engagement

Without bid history, visitors only know the current highest bid.

With bid history, they can see the auction’s journey.

What We Will Build

Each auction page will include a new section:

Bid History

-----------------------------------
Bidder         Amount        Time
-----------------------------------
Raj            $550         2 mins ago
Anita          $525         10 mins ago
John           $500         25 mins ago
-----------------------------------

Initially, we can display:

• Bid amount
• Date & time

Later, when user accounts are fully integrated, we can add bidder names (or anonymised usernames).

Features We’ll Implement

1. Create a Bid History Table

We’ll create a new custom database table to store every bid.

Example fields:

• Bid ID
• Auction ID
• User ID
• Bid Amount
• Bid Time

2. Record Every Bid

Instead of simply replacing the current bid, every bid will be stored permanently.

This creates a complete bidding history.

3. Retrieve Bid History

We’ll build helper functions to retrieve bids ordered by:

Newest First

or

Highest First

depending on the display requirement.

4. Display Bid History on the Frontend

Each auction card (or single auction page) will include:

Latest Bids

beneath the auction details.

5. Format Dates

Instead of displaying raw database timestamps, we’ll use WordPress date formatting functions.

Example:

Instead of:

2026-07-03 15:30:00

display

3 July 2026
3:30 PM

or

5 minutes ago

for recent bids.

6. Empty State

If no bids exist yet:

No bids have been placed yet.

Be the first bidder!

What You’ll Learn

By completing this lesson, you’ll gain experience with:

• Creating another custom database table
• Database relationships
• One-to-many data structures
• Retrieving ordered records
• Displaying dynamic lists
• Formatting dates and times
• Improving auction transparency

Why This Is an Important Milestone

Until now, the plugin has focused primarily on auction setup and presentation.

With bid history, we begin adding the interactive elements that make an auction platform feel alive. It also lays the foundation for future features such as:

• Highest bidder tracking
• Automatic winner selection
• User bidding dashboards
• Email notifications
• Auction analytics
• Escrow integration after auction completion

Each of these features will build naturally on the bid history system.

End Result

After Lesson 44, every auction will not only display its current price but also the complete story of how bidding has progressed, making the Flipnzee Auctions plugin more transparent, engaging, and closer to a production-ready auction platform.

Lesson 44 Implementation: Building the First Working Bidding System