Lesson 45: Displaying Bid History in Flipnzee Auctions


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:

BidderAmountTime
Rajeev$6505 mins ago
John$60015 mins ago
Alice$55030 mins ago

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.

Lesson 44: Building a Bid History Section for Every Auction

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

Lesson 44 Implementation: Building the First Working Bidding System

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.

Lesson 43: Implementing Dynamic Auction Status Badges in the Flipnzee Auctions Plugin


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:


Lesson 43: Displaying Dynamic Auction Status Badges

As the Flipnzee Auctions plugin continues to evolve, the auction cards are becoming much more than simple listings. Visitors can already see verified analytics, pricing information, and a live countdown timer. In this lesson, we’ll make the auction status even more obvious by introducing dynamic status badges.

Instead of requiring buyers to read the countdown or auction dates, a color-coded badge will immediately indicate whether an auction is currently active, approaching its end, or has already closed.


Why Status Badges Matter

People naturally respond to visual indicators faster than text.

Imagine browsing dozens of auction listings.

Without status badges, every listing appears similar.

With status badges, visitors can instantly identify auctions that deserve immediate attention.

For example:

🟢 Live Auction

🟡 Ending Soon

🔴 Auction Ended

These simple indicators improve usability and create a more engaging marketplace.


What You Will Learn

By the end of this lesson, you’ll know how to:

  • Compare auction end dates with the current time.
  • Determine the current auction status.
  • Display different badges based on auction status.
  • Apply different CSS styles for each badge.
  • Keep the logic reusable for future enhancements.

Badge Rules

For the first implementation, we’ll use three simple conditions.

Live Auction

Displayed when the auction is active and has more than 24 hours remaining.

Example:

🟢 Live Auction

Ending Soon

Displayed when less than 24 hours remain before the auction closes.

Example:

🟡 Ending Soon

This helps attract attention to auctions that are approaching their deadline.


Auction Ended

Displayed once the countdown reaches zero.

Example:

🔴 Auction Ended

This clearly communicates that bidding is no longer available.


Why Use Color?

The badges use colors that visitors already understand intuitively.

  • Green → Safe / Active
  • Yellow → Warning / Limited Time
  • Red → Closed / Expired

This allows buyers to recognize the auction state without reading additional text.


Planned Implementation

We’ll build this feature step by step.

Step 1

Determine the current auction status using PHP.

Step 2

Create a reusable badge variable.

Step 3

Display the badge above the auction title.

Step 4

Style each badge using CSS.

Step 5

Test all three auction states.


Expected Result

Each auction card will begin with a prominent status badge.

Example:

🟢 Live Auction

[ Featured Image ]

Calnzee.com

✔ Google Verified Analytics

👥 Monthly Users
📈 Monthly Sessions
🔍 Google Impressions

Start Price
Current Bid
Buy Now

Auction Ends In

5d 12h 14m 38s

View Listing

If the auction has less than one day remaining:

🟡 Ending Soon

If it has already expired:

🔴 Auction Ended

Looking Ahead

These badges are only the beginning.

Future versions of Flipnzee Auctions could introduce additional indicators such as:

  • ⭐ Featured Auction
  • 🔥 Popular Auction
  • 💰 Reserve Met
  • 🆕 Newly Listed
  • 🏆 Highest Bid Reached

Because the badge system will be reusable, new statuses can be added without redesigning the auction card.


What You’ll Gain

Status badges provide immediate visual feedback, helping buyers scan listings more efficiently and focus on auctions that require attention.

Combined with verified analytics, pricing, and the live countdown timer implemented in previous lessons, these badges move Flipnzee Auctions another step closer to becoming a polished, professional website marketplace.


Source Code

Available after implementation.


Next Lesson

In Lesson 43 (Implementation), we’ll calculate the auction status in PHP, display the appropriate badge on each auction card, and style it using CSS so that buyers can instantly distinguish between live, ending soon, and ended auctions.

Lesson 42 Implementation: Adding a Live JavaScript Auction Countdown to Flipnzee Auctions

One of the key characteristics of any modern auction website is a live countdown timer. Instead of showing visitors only the auction end date, a countdown creates urgency and helps buyers know exactly how much time remains before bidding closes.

In this lesson, the Flipnzee Auctions plugin was enhanced by replacing the static auction end date with a live JavaScript countdown timer that updates every second.


Objective

Convert this:

Auction Ends
03 Jul 2026

into something like:

Auction Ends In
5d 14h 32m 08s

and automatically display:

Auction Ended

once the auction expires.


What Was Implemented

The countdown feature required changes in three different areas of the plugin.

Step 1 — Create a JavaScript Countdown File

A new file was created:

assets/js/countdown.js

This script:

  • Finds every countdown on the page
  • Reads the auction end date
  • Calculates the remaining time
  • Updates every second
  • Automatically displays “Auction Ended” when time runs out

Step 2 — Pass the Auction End Date to JavaScript

Inside the shortcode output, the auction end date was stored inside a custom HTML data attribute.

Example:

<span
class="flipnzee-countdown"
data-end="2026-07-03 06:29:00">
Loading...
</span>

This allows JavaScript to read the date without embedding PHP inside the script.


Step 3 — Enqueue the JavaScript File

The plugin originally loaded only the frontend CSS.

It was updated to also load the countdown script.

Example:

wp_enqueue_script(
    'flipnzee-countdown',
    FLIPNZEE_AUCTION_URL . 'assets/js/countdown.js',
    array(),
    FLIPNZEE_AUCTION_VERSION,
    true
);

Loading the script in the footer ensures the HTML has already been generated before JavaScript executes.


Step 4 — Update the Countdown Every Second

JavaScript calculates the remaining:

  • Days
  • Hours
  • Minutes
  • Seconds

and refreshes the display every second using:

setInterval(updateCountdown, 1000);

The visitor therefore always sees an accurate countdown without refreshing the page.


Step 5 — Display “Auction Ended”

When the remaining time reaches zero, the script automatically changes the display to:

Auction Ended

instead of showing negative numbers.


Step 6 — Add Visual Styling

The countdown text was styled using CSS.

Normal countdown:

  • Blue text
  • Semi-bold

Expired auction:

  • Red text
  • Bold

Example CSS:

.flipnzee-countdown {
    color: #1d4ed8;
    font-weight: 600;
}

.flipnzee-countdown.ended {
    color: #dc2626;
    font-weight: 700;
}

This makes expired auctions immediately obvious to visitors.


Final Result

Each auction listing now displays:

✔ Google Verified Analytics

👥 Monthly Users
📈 Monthly Sessions
🔍 Google Impressions

Start Price
Current Bid
Buy Now

Auction Ends In
5d 08h 16m 42s

View Listing

Once the timer reaches zero, it automatically changes to:

Auction Ends In
Auction Ended

with the expired status highlighted in red.


What Was Learned

During this lesson, several important WordPress development concepts were covered:

  • Creating and organizing external JavaScript files
  • Loading JavaScript properly using wp_enqueue_script()
  • Passing PHP data to JavaScript through HTML data attributes
  • Using setInterval() to update content dynamically
  • Calculating countdown timers with JavaScript date functions
  • Enhancing user experience with conditional CSS classes

Why This Feature Matters

A live countdown is a standard feature on professional auction platforms because it creates urgency and encourages users to act before time runs out. Even without refreshing the page, visitors always know exactly how much time remains.

With this enhancement, the Flipnzee Auctions plugin feels significantly more interactive and professional, bringing it one step closer to a production-ready auction solution.


Download Source Code

Download the starting version of the plugin before the lesson:

Download the completed version after this lesson:

Complete Source Code

The complete source code for this lesson is available in the Flipnzee Auctions GitHub repository and reflects the changes made to implement the live JavaScript auction countdown.

Lesson 42: Build a Live Auction Countdown Timer in Your WordPress Auction Plugin

One of the defining features of any auction platform is a live countdown timer. Buyers naturally pay more attention when they can see exactly how much time remains before an auction closes. A countdown also creates urgency, encouraging users to place bids before time runs out.

In this lesson, we’ll enhance the Flipnzee Auctions plugin by replacing the static auction end date with a dynamic countdown timer that updates every second.


What You Will Build

Instead of displaying:

Auction Ends
03 Jul 2026

the auction card will display something like:

Auction Ends In

2 Days
14 Hours
36 Minutes
22 Seconds

When the auction expires, the countdown will automatically change to:

Auction Ended

without requiring the page to reload.


Why This Feature Matters

A live countdown provides several advantages:

  • Creates urgency among buyers.
  • Makes auctions feel active and dynamic.
  • Reduces confusion about auction closing time.
  • Improves user engagement.
  • Gives Flipnzee a more professional marketplace appearance.

Nearly every successful auction platform uses countdown timers because they encourage participation during the final hours of an auction.


What You Will Learn

In this lesson, you’ll learn how to:

  • Pass PHP date values to JavaScript.
  • Create HTML placeholders for dynamic content.
  • Write JavaScript countdown logic.
  • Calculate days, hours, minutes, and seconds.
  • Update the display every second.
  • Handle expired auctions gracefully.
  • Keep the implementation lightweight without external libraries.

Implementation Plan

We will complete this lesson in several small steps:

Step 1

Create a countdown placeholder inside the auction card.

Step 2

Pass the auction end time into a data attribute.

Step 3

Create a JavaScript file for countdown functionality.

Step 4

Calculate the remaining time.

Step 5

Refresh the timer every second.

Step 6

Display “Auction Ended” when time reaches zero.

Step 7

Style the countdown using CSS.


Expected Result

Every Flipnzee auction listing will display a real-time countdown similar to:

✔ Google Verified Analytics

👥 Monthly Users        91
📈 Monthly Sessions    109
🔍 Google Impressions    0

Start Price          $111
Current Bid            $0
Buy Now             $333

Auction Ends In

2d 14h 36m 22s

[ View Listing ]

As time passes, the countdown updates automatically without refreshing the page.


Developer Tips

  • Keep countdown calculations in JavaScript instead of PHP.
  • Use setInterval() to update once per second.
  • Always calculate using Unix timestamps to avoid formatting issues.
  • Stop the timer after the auction ends to reduce unnecessary processing.
  • Use CSS classes instead of inline styles for easier maintenance.
  • Ensure the timer respects the visitor’s local time zone by passing a standard date format such as ISO 8601.

Source Code

Available after implementation.


Coming Up Next

In Lesson 43, we’ll make the auction cards even more engaging by adding color-coded auction status badges such as:

  • 🟢 Live Auction
  • 🟡 Ending Soon
  • 🔴 Auction Ended

These visual indicators will help buyers instantly recognize the current state of every auction listing before opening the full listing page.

Lesson 41 Implementation: Adding a Verified Analytics Summary to Auction Cards


One of Flipnzee’s biggest goals is to help buyers make informed decisions. Instead of relying only on seller-provided information, auction cards should display trusted website metrics generated by the Flipnzee Analytics plugin.

In this lesson, the auction card was enhanced with a compact analytics summary that appears above the pricing information.

What was implemented

1. Added a “Google Verified Analytics” section

A new analytics block was inserted into the auction card layout. It retrieves analytics data from the Flipnzee Analytics plugin and displays it directly inside each auction listing.

The summary currently includes:

  • Monthly Users
  • Monthly Sessions
  • Google Impressions

This allows buyers to evaluate website performance without opening the full listing page.


2. Prevented PHP errors

During testing, a critical error occurred when analytics data was unavailable.

To make the shortcode more reliable, checks were added before accessing transient data so that missing analytics now safely display as zero instead of generating errors.

Example:

is_array( $main ) ? ( $main['users'] ?? 0 ) : 0

This makes the shortcode much more robust.


3. Improved terminology

Instead of generic labels, the metrics were renamed to better match buyer expectations.

Old labels:

  • Users
  • Sessions
  • Impressions

New labels:

  • Monthly Users
  • Monthly Sessions
  • Google Impressions

These names immediately communicate what the numbers represent.


4. Formatted values

Several presentation improvements were made:

  • Auction prices now display with a $ currency symbol.
  • Numeric values use WordPress number formatting functions.
  • Auction end dates are formatted into a clean, readable style instead of showing raw database values.

Example:

03 Jul 2026

instead of

2026-07-03 06:29:00

5. Styled the analytics section

A dedicated stylesheet was added for the analytics summary.

Visual improvements include:

  • Light blue background
  • Rounded corners
  • Consistent spacing
  • Professional typography
  • Improved alignment of labels and values

The “Google Verified Analytics” badge was also updated to better match Flipnzee’s branding.


Challenges encountered

While implementing the feature, several issues had to be resolved.

Browser and server caching

Initially, CSS changes appeared to have no effect. After investigation, the issue turned out to be cached styles rather than incorrect code.


CSS duplication

During testing, duplicate CSS rules accumulated inside frontend.css.

Although this did not break functionality, identifying duplicate rules helped keep the stylesheet cleaner for future development.


Defensive coding

The analytics block originally assumed that transient data always existed.

Adding validation around analytics arrays made the shortcode much safer and prevented runtime errors.


Result

Auction cards now present much more than just prices.

Each listing immediately communicates important website metrics before the visitor even opens the full listing page.

The card now combines:

  • Website preview
  • Verified analytics
  • Auction pricing
  • Auction end date
  • Call-to-action button

This creates a much stronger first impression for buyers and moves Flipnzee closer to becoming a marketplace that emphasizes verified website quality, not just website availability.

Download Source Code

Download the starting version of the plugin before the lesson:

Download the completed version after this lesson:


Key takeaway

A website buyer is purchasing more than a domain name—they are evaluating traffic, audience, and search visibility. By integrating verified analytics directly into auction cards, Flipnzee provides meaningful context that traditional website marketplaces often require users to discover manually.


Next Lesson: Lesson 42 – Adding a Live Auction Countdown Timer

In the next lesson, we’ll implement a dynamic countdown timer that shows exactly how much time remains before an auction ends, creating urgency and improving the overall auction experience.

Lesson 41: Displaying Verified Analytics on Auction Cards

One of Flipnzee’s biggest advantages over traditional website marketplaces is that every listing can display verified Google Analytics and Google Search Console data. Instead of asking buyers to trust screenshots or seller claims, Flipnzee can present real performance metrics directly from the website owner.

In this lesson, we’ll begin displaying selected analytics directly on each auction card, giving buyers valuable insights before they even open the full listing page.


Why Show Analytics on the Auction Card?

Most website marketplaces display only basic information:

  • Website name
  • Asking price
  • Category
  • Description

A buyer must open each listing individually before discovering whether the website actually has visitors.

Flipnzee can do better.

Since each listing already has verified analytics available through the Flipnzee Analytics plugin, we can surface the most important metrics directly within the marketplace.


The Buyer Experience

Imagine browsing dozens of websites for sale.

Instead of seeing this:

Calnzee.com

Start Price: $111
Current Bid: $0
Buy Now: $333

buyers will see something like:

Calnzee.com

✔ Google Verified Analytics

👥 Users...............210
📈 Sessions...........443
🔍 Impressions.......555

Start Price..........$111
Current Bid...........$0
Buy Now..............$333

Within seconds, buyers can identify listings that are already attracting visitors.


Why This Is Different

Many marketplace platforms rely entirely on information entered manually by the seller.

That means buyers often wonder:

  • Are these traffic numbers genuine?
  • Were the screenshots edited?
  • Is the data recent?

Flipnzee takes a different approach.

Analytics are pulled automatically from the connected Google Analytics and Google Search Console properties, helping reduce reliance on manually entered statistics.


Which Metrics Should Be Displayed?

The goal is not to overwhelm visitors with dozens of statistics.

Instead, show only a few headline metrics.

A good starting point is:

  • Users
  • Sessions
  • Google Impressions

These three values provide a quick overview of a website’s activity and search visibility.

The complete analytics dashboard remains available on the individual listing page.


Keep the Auction Card Simple

Think of the auction card as a preview.

It should answer one question:

“Is this listing worth opening?”

If the answer is yes, the visitor clicks View Listing to explore the complete analytics dashboard.

This creates a natural flow:

Marketplace

↓

Auction Card

↓

Listing Page

↓

Verified Analytics

↓

Place Bid

Avoid Information Overload

Showing every available metric on the auction card would make it difficult to scan.

For example, displaying all of these at once would quickly become cluttered:

  • Users
  • Sessions
  • Returning Visitors
  • Average Session Duration
  • Pages per User
  • Live Users
  • Countries
  • Cities
  • Keywords
  • Traffic Sources
  • Impressions
  • Clicks
  • Indexed Pages

Instead, the marketplace should provide a concise summary, while the listing page remains the place for detailed analysis.


Future Enhancements

As Flipnzee evolves, additional indicators can be introduced without overcrowding the card.

Examples include:

  • Google Verified badge
  • Live visitors indicator
  • Growth percentage
  • Auction ending soon badge
  • Recently updated analytics timestamp
  • Mobile-friendly metric icons

These enhancements can gradually enrich the browsing experience while keeping the interface clean.


What We Learned

One of Flipnzee’s strongest competitive advantages is its ability to present verified website performance, not just seller-provided descriptions.

By displaying a few key analytics directly on the auction card, buyers can evaluate listings more quickly and confidently, while the full listing page continues to provide comprehensive insights.

This approach helps transform the marketplace from a simple directory of websites into a data-driven platform where informed decisions can be made at a glance.


Next Lesson

In Lesson 41 (Implementation), we’ll modify the auction card shortcode to retrieve selected metrics from the connected Flipnzee Analytics plugin and display them alongside the auction details, creating the first analytics-powered marketplace cards.

Lesson 39 Implementation – Display Listing Titles, Featured Images, Placeholder Images & View Listing Button

After creating the frontend auction shortcode in Lesson 38, visitors could finally see active auctions on the website. However, each auction was still presented as a simple list of database values. Instead of displaying a meaningful website title and image, the shortcode only showed the Listing ID, making the marketplace feel more like a database report than a professional auction platform.

In this implementation, we significantly improved the frontend by connecting our custom auction records with the existing Listing custom post type. This allows each auction to display the actual website title, featured image, and a direct link to its Listing page. We also laid the groundwork for future frontend styling by introducing a dedicated stylesheet and logical HTML structure.


What We Implemented

During this lesson we completed the following improvements:

  • Retrieved the associated Listing post using listing_id.
  • Verified the Listing exists before displaying it.
  • Replaced the Listing ID with the Listing title.
  • Displayed the Listing’s featured image.
  • Added a branded placeholder image when no featured image exists.
  • Created a dedicated assets/images folder.
  • Created a dedicated assets/css folder.
  • Added a frontend stylesheet.
  • Loaded the stylesheet using wp_enqueue_style().
  • Organized the HTML into thumbnail and content sections.
  • Added a View Listing button linking to the Listing page.

Step 1 – Retrieve the Listing Post

Our auction table stores only the Listing ID. To display information about the website, we first retrieved the corresponding WordPress post.

$listing = get_post( $auction['listing_id'] );

if ( ! $listing ) {
	continue;
}

If the Listing no longer exists, the shortcode simply skips that auction instead of generating errors.


Step 2 – Display the Website Title

Previously the shortcode displayed something similar to:

Listing #2222

We replaced this with:

echo esc_html( get_the_title( $listing ) );

Visitors now see the actual website title, for example:

Calnzee.com

This immediately makes the auction easier to understand.


Step 3 – Display the Featured Image

Each Listing already supports WordPress featured images.

We used:

has_post_thumbnail()

and

get_the_post_thumbnail()

to display the website screenshot above the title.

This transforms the auction from plain text into a visual listing.


Step 4 – Add a Placeholder Image

Not every Listing has a featured image.

Instead of leaving an empty space, we created:

assets/
└── images/
    └── placeholder.png

Whenever no featured image exists, the shortcode now displays this branded placeholder.

This keeps every auction card visually consistent.


Step 5 – Organize the HTML

Rather than placing everything directly inside the auction card, we separated the content into logical sections.

Thumbnail section:

flipnzee-auction-thumbnail

Content section:

flipnzee-auction-content

Although visitors won’t immediately notice this change, it makes future styling much easier.


Step 6 – Create a Frontend Stylesheet

To keep presentation separate from functionality, we created:

assets/
└── css/
    └── frontend.css

Instead of mixing inline styles with PHP, all future frontend styling will now be maintained inside this stylesheet.


Step 7 – Enqueue the Stylesheet

Creating a CSS file alone isn’t enough.

We registered it using:

wp_enqueue_style()

inside the main plugin file.

Because we had already defined:

FLIPNZEE_AUCTION_URL

and

FLIPNZEE_AUCTION_VERSION

loading the stylesheet became straightforward while following WordPress best practices.


Step 8 – Add a View Listing Button

Finally, we connected the Auctions plugin with our Listing pages.

Using:

get_permalink( $listing )

we generated a link directly to the Listing.

Visitors can now move from the auction summary to the complete Listing page where they can view:

  • Website description
  • Screenshots
  • Flipnzee Analytics dashboard
  • Traffic statistics
  • Additional website information

This creates a much smoother browsing experience.


Project Structure After This Lesson

Our plugin now contains the following frontend assets:

flipnzee-auctions/

assets/
│
├── css/
│   └── frontend.css
│
└── images/
    └── placeholder.png

includes/
└── class-shortcodes.php

This organization keeps the plugin scalable and easier to maintain.


Why This Implementation Matters

One of the biggest improvements in this lesson wasn’t simply displaying an image or title—it was establishing the relationship between two independent systems.

Our Auctions plugin stores only the Listing ID in its custom database table. Whenever the shortcode runs, it retrieves the corresponding WordPress Listing post to display additional information.

This approach avoids duplicating data and allows us to take advantage of WordPress features such as:

  • Post titles
  • Featured images
  • Permalinks
  • Future custom fields

By building on top of the Listing custom post type rather than storing duplicate information in the auction table, the plugin remains cleaner, more flexible, and easier to extend.


Tips & Best Practices

  • Store only the Listing ID in the custom auction table.
  • Always verify the Listing exists before displaying it.
  • Escape all output using WordPress escaping functions.
  • Keep images inside the plugin instead of relying on external placeholders.
  • Separate HTML structure from CSS styling.
  • Use WordPress constants for plugin paths and URLs.
  • Organize frontend assets into dedicated css and images folders.

What We Learned

This lesson demonstrated how a custom database table can work together with native WordPress posts.

Instead of treating auctions as isolated records, we linked each auction to its corresponding Listing, allowing us to reuse existing WordPress functionality while keeping the database simple.

The result is a much more professional-looking marketplace and a solid foundation for future enhancements.


Looking Ahead

In the next lesson, we’ll continue improving the frontend by transforming these functional auction cards into a polished marketplace interface. We’ll refine the layout, improve spacing and typography, make the cards responsive, and prepare the design for future features such as bidding buttons, countdown timers, and deeper integration with the Flipnzee Analytics plugin.