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:
Bidder
Amount
Time
Rajeev
$650
5 mins ago
John
$600
15 mins ago
Alice
$550
30 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.
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.
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:
The auction is identified.
The existing highest bid is retrieved.
The new amount is compared against the current bid.
Valid bids are inserted into the bids table.
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:
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:
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.
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.
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:
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.
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.
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:
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.
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.
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.
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.
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.