How to Use WP_Query in WordPress

Mastering WP_Query in WordPress is essential for developers aiming to have full control over content display. This powerful class enables the creation of customized queries, allowing for efficient and effective content delivery. Since WordPress powers approximately 43.7% of all websites, understanding and utilizing WP_Query is crucial, as it serves as the platform’s industry standard for content retrieval. This guide will explore using WP_Query for custom queries, optimizing performance, and implementing best practices to elevate your WordPress development skills. If you’d rather hand this off, our WordPress development services cover custom queries, theme builds, and performance tuning end to end.

Unlocking the Potential of Custom WordPress Queries

Creating custom queries with WP_Query allows you to dictate exactly what content to show and how to display it. This section will guide you through the essentials of crafting and leveraging custom queries to optimize your site’s content.

How to Create Your First Custom Query

Before diving in, it’s essential to understand the anatomy of a WP_Query. Here’s a simple example:

$args = array(
    'post_type'      => 'post',
    'posts_per_page' => 5,
);

$query = new WP_Query( $args );

if ( $query->have_posts() ) {
    while ( $query->have_posts() ) {
        $query->the_post();
        // Output your post content here
    }
    wp_reset_postdata();
}

In this snippet:

• post_type: Specifies the type of content you want to retrieve, such as posts, pages, or custom post types.
• posts_per_page: Limits the number of posts retrieved (5 in this example), which is critical for performance.

This example fetches five posts and loops through them using The Loop, a key part of WordPress development that you’ll use frequently. If you want to go deeper on loop structure, see our guide on customizing the WordPress loop.

Why Custom Queries Matter for Your WordPress Site

Custom queries aren’t just about pulling content; they’re about enhancing the user experience. By strategically organizing your content, you can:

• Improve navigation: Visitors can find relevant content faster.
• Optimize loading times: Only load what you need, when you need it.
• Create tailored experiences: Show different content to different audiences.

Understanding the mechanics of custom queries will help you deliver a more personalized, efficient site.

Decoding WP_Query Parameters: A Developer’s Guide

With WP_Query, you have access to a vast array of parameters that let you filter and customize the data retrieved. Let’s break down the most crucial ones and how to use them.

Must-Know WP_Query Parameters for Beginners

Every WP_Query starts with a set of parameters, which act as the building blocks of your custom query:

• post_type: Defines the type of content you’re querying, such as post, page, or custom post type.
• posts_per_page: Specifies how many posts to show.
• order and orderby: Control the order of your posts.
• category_name: Filters posts by category name.
• tag: Retrieves posts with a specific tag.
• meta_query: Allows for complex filtering using custom fields.

These parameters give you granular control over your content, making it possible to tailor your WordPress site to your exact needs.

Mixing and Matching Parameters for Ultimate Flexibility

Combining multiple parameters enables you to fine-tune your queries. Here’s a more advanced example:

$args = array(
    'post_type'      => 'product',
    'posts_per_page' => 10,
    'order'          => 'ASC',
    'category_name'  => 'featured',
);

$query = new WP_Query( $args );

In this scenario:

• post_type: Fetches content from a custom post type called “product.”
• posts_per_page: Limits the result to 10 items.
• order: Specifies ascending order, ideal for chronological lists.
• category_name: Ensures only “featured” products are displayed.

Mastering these combinations allows you to create more refined and efficient queries.

Complete WP_Query Args Reference (Cheat Sheet)

This is the scannable reference most developers bookmark. Every parameter below is grouped by type, with its default value and a quick-copy example. Use it to build any query without digging through the Codex.

Post & Page Parameters

Parameter	What it does	Default	Quick copy
post_type	Content type to query	'post'	'post_type' => 'page'
post_status	Status filter	'publish'	'post_status' => 'draft'
p	Single post by ID	—	'p' => 42
name	Single post by slug	—	'name' => 'hello-world'
page_id	Single page by ID	—	'page_id' => 7
posts_per_page	Number of posts	10 (or Settings value)	'posts_per_page' => 6
post__in	Limit to specific IDs	—	'post__in' => array(1,2,3)
post__not_in	Exclude specific IDs	—	'post__not_in' => array(9)
post_parent	Children of a parent ID	—	'post_parent' => 12

Taxonomy, Category & Tag Parameters

Parameter	What it does	Default	Quick copy
cat	Category by ID	—	'cat' => 4
category_name	Category by slug	—	'category_name' => 'news'
category__in	Posts in any listed cat ID	—	'category__in' => array(2,5)
category__not_in	Exclude category IDs	—	'category__not_in' => array(8)
tag	Tag by slug	—	'tag' => 'wordpress'
tag_id	Tag by ID	—	'tag_id' => 15
tax_query	Custom taxonomy filtering	—	(see deep dive below)

Ordering, Pagination & Meta Parameters

Parameter	What it does	Default	Quick copy
orderby	Sort field	'date'	'orderby' => 'title'
order	Sort direction	'DESC'	'order' => 'ASC'
meta_key	Custom field key (also enables sort by meta)	—	'meta_key' => 'price'
meta_value	Custom field value	—	'meta_value' => 'yes'
meta_compare	Comparison operator	'='	'meta_compare' => '>='
meta_query	Complex custom-field filtering	—	(see deep dive below)
paged	Current page number	1	'paged' => $paged
offset	Skip N posts	—	'offset' => 3
nopaging	Return all, ignore paging	false	'nopaging' => true

Date Parameters

Parameter	What it does	Default	Quick copy
date_query	Filter by date range	—	'date_query' => array(array('after'=>'2024-01-01'))
year	Four-digit year	—	'year' => 2024
monthnum	Month number (1–12)	—	'monthnum' => 6
day	Day of month (1–31)	—	'day' => 15

Performance Parameters

Parameter	What it does	Default	Quick copy
fields	Return only what you need	'' (full objects)	'fields' => 'ids'
no_found_rows	Skip pagination count query	false	'no_found_rows' => true
update_post_meta_cache	Pre-load post meta	true	'update_post_meta_cache' => false
update_post_term_cache	Pre-load term data	true	'update_post_term_cache' => false

Keep this section bookmarked — it covers the wp_query args you’ll reach for 90% of the time.

Using WP_Query with Custom Post Types: What You Need to Know

Custom post types expand WordPress’s functionality, and WP_Query is indispensable for managing and displaying these types of content.

How to Display Custom Post Types Like a Pro

If your site relies on custom post types, you’ll need to use WP_Query to fetch and display them properly:

$args = array(
    'post_type'      => 'portfolio',
    'posts_per_page' => 3,
);

$query = new WP_Query( $args );

if ( $query->have_posts() ) {
    while ( $query->have_posts() ) {
        $query->the_post();
        // Your custom content output
    }
    wp_reset_postdata();
}

In this code:

• post_type: Fetches posts from your “portfolio” custom post type.
• posts_per_page: Limits the display to three items, ideal for a compact portfolio showcase.

Pro Tips for Handling Custom Post Types

• Proper Registration: Always register your custom post types using register_post_type(). This ensures that your content is queryable and accessible.
• Taxonomy Filtering: Use taxonomies (custom or built-in) to further refine your content. Example:

$args = array(
    'post_type' => 'portfolio',
    'tax_query' => array(
        array(
            'taxonomy' => 'project_type',
            'field'    => 'slug',
            'terms'    => 'web-design',
        ),
    ),
);

$query = new WP_Query( $args );

This query fetches portfolio items tagged with the “web-design” taxonomy, making it easier to organize and display your content.

tax_query and meta_query: The Deep Dive

These two parameters are where WP_Query gets genuinely powerful — and where most developers get stuck. Both accept nested arrays with a relation key (AND or OR) that controls how conditions combine.

Multiple Taxonomy Conditions with AND / OR

Want posts that match two taxonomies at once? Set 'relation' => 'AND'. Want either? Use 'OR'.

$args = array(
    'post_type' => 'portfolio',
    'tax_query' => array(
        'relation' => 'AND',
        array(
            'taxonomy' => 'project_type',
            'field'    => 'slug',
            'terms'    => 'web-design',
        ),
        array(
            'taxonomy' => 'industry',
            'field'    => 'slug',
            'terms'    => array( 'healthcare', 'finance' ),
            'operator' => 'IN',
        ),
    ),
);

$query = new WP_Query( $args );

This returns web-design projects that are also tagged healthcare or finance. Swap 'AND' for 'OR' to widen the net.

meta_query Compare Operators (LIKE, IN, BETWEEN)

meta_query supports far more than =. The compare key unlocks real filtering:

$args = array(
    'post_type'  => 'event',
    'meta_query' => array(
        'relation' => 'AND',
        array(
            'key'     => 'price',
            'value'   => array( 50, 200 ),
            'compare' => 'BETWEEN',
            'type'    => 'NUMERIC',
        ),
        array(
            'key'     => 'location',
            'value'   => array( 'atlanta', 'marietta', 'roswell' ),
            'compare' => 'IN',
        ),
        array(
            'key'     => 'title_text',
            'value'   => 'workshop',
            'compare' => 'LIKE',
        ),
    ),
);

$query = new WP_Query( $args );

Nested Query Relationships

You can nest a meta_query (or tax_query) inside another to build compound logic — “A AND (B OR C)”:

$args = array(
    'post_type'  => 'property',
    'meta_query' => array(
        'relation' => 'AND',
        array(
            'key'     => 'status',
            'value'   => 'available',
        ),
        array(
            'relation' => 'OR',
            array(
                'key'     => 'beds',
                'value'   => 3,
                'compare' => '>=',
                'type'    => 'NUMERIC',
            ),
            array(
                'key'     => 'has_pool',
                'value'   => 'yes',
            ),
        ),
    ),
);

$query = new WP_Query( $args );

This finds available properties that have either 3+ bedrooms or a pool. Nesting is the key to advanced filtering most tutorials skip.

5 WP_Query Examples You Can Use Right Now

Sometimes, seeing real-world examples helps solidify your understanding. Here are two essential scenarios where WP_Query shines.

Your Go-To Example for Simple Post Lists

Fetching the latest three posts is a common requirement:

$args = array(
    'posts_per_page' => 3,
);

$query = new WP_Query( $args );

if ( $query->have_posts() ) {
    while ( $query->have_posts() ) {
        $query->the_post();
        echo '<h2>' . get_the_title() . '</h2>';
        echo '<p>' . get_the_excerpt() . '</p>';
    }
    wp_reset_postdata();
}

This code outputs the titles and excerpts of the latest three posts, making it easy to set up a “Latest News” or “Recent Articles” section.

Advanced Filtering: Making Complex Queries Simple

To create more sophisticated queries, combine different filters:

$args = array(
    'post_type'  => 'event',
    'meta_query' => array(
        array(
            'key'     => 'event_date',
            'value'   => date( 'Y-m-d' ),
            'compare' => '>=',
            'type'    => 'DATE',
        ),
    ),
    'orderby' => 'meta_value',
    'order'   => 'ASC',
);

$query = new WP_Query( $args );

This query pulls upcoming events, ensuring only future dates are shown and orders them chronologically. Perfect for an event calendar!

Filtering Posts with WP_Query: From Basics to Advanced

Filtering posts is a powerful way to display exactly what you need. Whether you’re sorting by category, tag, or custom field, WP_Query has you covered.

Filtering Posts by Category or Tag

Categories and tags are standard in WordPress. Here’s how to use them:

$args = array(
    'category_name'  => 'news',
    'posts_per_page' => 5,
);

$query = new WP_Query( $args );

This example fetches five posts from the “news” category, making it ideal for category-specific sections of your site.

Going Deep with Custom Field Filtering

Custom fields let you take filtering to another level:

$args = array(
    'meta_query' => array(
        array(
            'key'   => 'featured',
            'value' => 'yes',
        ),
    ),
);

$query = new WP_Query( $args );

This query pulls posts marked as “featured” using a custom field. It’s perfect for highlighting special content.

Making Pagination Work with WP_Query

If your site displays a lot of content, pagination ensures it remains performant and user-friendly.

Simple Steps to Add Pagination

Add the paged parameter to your query to paginate your content:

$paged = ( get_query_var( 'paged' ) ) ? get_query_var( 'paged' ) : 1;

$args = array(
    'posts_per_page' => 10,
    'paged'          => $paged,
);

$query = new WP_Query( $args );

Using get_query_var('paged') ensures the correct page number is retrieved from the URL.

Enhancing Navigation with Pagination Links

For complete pagination, add navigation links:

echo paginate_links( array(
    'total' => $query->max_num_pages,
) );

These links allow users to navigate easily between pages of content, enhancing the user experience.

Optimizing WP_Query: Tips to Keep Your Site Fast

Efficiency is crucial, especially for high-traffic websites. Let’s explore techniques to make your queries performant.

Reducing Load with Efficient Queries

Fetching too much data slows your site. Always limit the number of posts:

$args  = array( 'posts_per_page' => 5 );
$query = new WP_Query( $args );

Use specific filters like post_type and meta_query to reduce the burden on your database.

Leveraging Caching to Boost Speed

Caching saves your database from executing repeated queries. Here’s how to use transients:

$posts = get_transient( 'custom_query_posts' );

if ( false === $posts ) {
    $args  = array( 'posts_per_page' => 5 );
    $query = new WP_Query( $args );
    set_transient( 'custom_query_posts', $query->posts, 12 * HOUR_IN_SECONDS );
}

By caching query results for 12 hours, you significantly reduce server load.

Troubleshooting & Best Practices for WP_Query

Beyond the basics, a handful of habits separate clean, fast queries from slow, buggy ones. Follow these every time.

Always Reset Post Data

After any custom loop that calls the_post(), run wp_reset_postdata(). Skipping it leaves the global $post object pointing at your last queried item, which corrupts the main loop, widgets, and any query that runs afterward. This is the single most common WP_Query bug — make it muscle memory.

Avoid Querying the Main Loop Unnecessarily

Don’t spin up a new WP_Query just to change what’s already on the page (a category archive, the homepage feed, search results). That runs the database twice. To alter the main query, use the pre_get_posts hook instead (covered below). Reserve new WP_Query for secondary content — sidebars, related posts, custom sections.

Limit Fields with fields and no_found_rows for Speed

Two parameters give you easy performance wins:

• 'fields' => 'ids' — When you only need post IDs (for example, to feed another function), this skips hydrating full post objects and dramatically cuts memory and query time.
• 'no_found_rows' => true — WP_Query normally runs a second SQL_CALC_FOUND_ROWS query to support pagination. If you’re not paginating, set this to true and skip the extra query entirely.

$args = array(
    'post_type'      => 'product',
    'posts_per_page' => 8,
    'fields'         => 'ids',
    'no_found_rows'  => true,
);

$query = new WP_Query( $args );

On non-paginated, ID-only queries this is often the fastest WP_Query you can write.

Mastering the pre_get_posts Hook for Ultimate Control

The pre_get_posts hook allows you to modify the main query before it runs, providing unparalleled control over content retrieval.

How to Customize Queries with pre_get_posts

Use this hook to change what content is displayed on specific pages:

function modify_main_query( $query ) {
    if ( is_home() && $query->is_main_query() ) {
        $query->set( 'posts_per_page', 5 );
    }
}
add_action( 'pre_get_posts', 'modify_main_query' );

This function modifies the main query on the homepage to show only five posts.

Creative Use Cases for pre_get_posts

The pre_get_posts hook is highly versatile. You can use it to:

• Filter search results to include only posts, not pages.
• Modify custom post type archives to display in a specific order.
• Limit posts on category archives for better performance.

WP_Query vs. get_posts vs. query_posts: Which to Use

Choosing the right function to query posts in WordPress can significantly impact your site’s performance and functionality. Understanding the differences between WP_Query, get_posts, and query_posts will help you make informed decisions when working with custom content retrieval.

Quick Comparison

Function	Best for	Side effects	Verdict
WP_Query	Full-control secondary queries, loops, pagination	None — runs independently of the main query	Use this
get_posts	Lightweight, read-only lists (sidebars, footers)	None — a thin wrapper around WP_Query, returns an array	Use for simple lists
query_posts	(Modifying the main query)	Re-runs the main query, breaks pagination, hurts performance	Avoid

Why WP_Query Is the Preferred Choice

WP_Query is the most powerful and flexible method for querying posts in WordPress. It allows you to create custom queries tailored to your exact needs without interfering with the main global query. This makes it ideal for scenarios where you need to control the content output precisely — and it’s the right tool whenever you need The Loop, pagination, or complex filtering.

When get_posts Is the Right Call

get_posts is a simplified wrapper around WP_Query that returns an array of post objects. Reach for it when you need a quick, read-only list and don’t need The Loop or pagination — think a “recent posts” sidebar or a footer widget. It’s lighter to write, but it lacks the full flexibility of WP_Query.

$args = array(
    'numberposts' => 5,
    'category'    => 3,
);

$recent_posts = get_posts( $args );

foreach ( $recent_posts as $post ) {
    setup_postdata( $post );
    echo '<h2>' . get_the_title() . '</h2>';
}
wp_reset_postdata();

Why query_posts Is Discouraged

query_posts overrides and re-runs the main query. That second database call degrades performance, breaks pagination, and interferes with default behaviors — especially on pages running multiple queries. There’s almost never a good reason to use it. To alter the main query, use pre_get_posts. For everything else, use WP_Query.

function modify_main_query( $query ) {
    if ( ! is_admin() && $query->is_main_query() && is_home() ) {
        $query->set( 'posts_per_page', 10 );
    }
}
add_action( 'pre_get_posts', 'modify_main_query' );

Common WP_Query Mistakes and How to Avoid Them

Even seasoned developers trip over the same handful of issues. Here are the big three.

1. Forgetting wp_reset_postdata()

The classic. After a custom loop, the global $post object stays stuck on your last queried post. Other loops, template tags, and widgets then output the wrong content. Fix: call wp_reset_postdata() immediately after every custom loop’s closing brace.

$query = new WP_Query( $args );

if ( $query->have_posts() ) {
    while ( $query->have_posts() ) {
        $query->the_post();
        // Custom loop content
    }
    wp_reset_postdata(); // Never skip this
}

If you need extra control on complex templates, store the global first and restore it manually:

global $post;
$original_post = $post; // Store

// ... your custom WP_Query loop ...

$post = $original_post; // Restore
setup_postdata( $post );

2. Using posts_per_page => -1

Setting -1 returns every matching post. On a small site that’s harmless; on a site with thousands of posts it can exhaust memory and crash the page. Fix: always set a sane upper bound (posts_per_page => 100), or paginate. If you genuinely need all IDs, pair a high limit with 'fields' => 'ids' and 'no_found_rows' => true to keep it cheap.

3. Modifying the Main Query Incorrectly

Spinning up a new WP_Query to “replace” what’s already on an archive or homepage means the database runs twice and pagination breaks. Fix: modify the main query with pre_get_posts (and always guard it with ! is_admin() and $query->is_main_query() so you don’t affect the dashboard or secondary loops).

Resetting WP_Query: A Crucial Step You Can’t Skip

Failing to reset WP_Query can lead to conflicts, especially when working with global variables.

wp_reset_postdata vs. wp_reset_query Explained

When using custom queries, always reset post data to maintain site integrity:

if ( $query->have_posts() ) {
    while ( $query->have_posts() ) {
        $query->the_post();
        // Output your content
    }
    wp_reset_postdata();
}

• wp_reset_postdata(): Resets global post data to ensure subsequent queries work as expected.
• wp_reset_query(): Resets the main query, but it should only be used in specific situations.

WP_Query Examples: Ready-to-Use Code Snippets

Understanding WP_Query becomes even more intuitive when you see it in action. Below are several pre-made examples that incorporate essential parameters such as loops, author information, categories, date queries, and more. Each example is followed by an explanation to help you implement these queries effectively.

Example 1: Display Posts by a Specific Author in Descending Order

This example showcases how to use the WP_Query class to fetch posts written by a specific author, ordered by date in descending order.

$args = array(
    'author'         => 2, // Replace 2 with the author's ID
    'posts_per_page' => 5,
    'orderby'        => 'date',
    'order'          => 'DESC',
);

$query = new WP_Query( $args );

if ( $query->have_posts() ) {
    while ( $query->have_posts() ) {
        $query->the_post();
        echo '<h2>' . get_the_title() . '</h2>';
        echo '<p>Written by: ' . get_the_author() . '</p>';
    }
    wp_reset_postdata();
}

Explanation:

• author: Filters posts by the author’s ID. Replace 2 with the desired author ID from your WordPress database.
• orderby: Orders the posts by the publication date.
• order: Specifies descending order (DESC), showing the latest posts first.
• wp_reset_postdata(): Ensures that global post data is reset after the custom query loop.

Example 2: Query Posts from a Specific Category with Author Information

Here’s how to display posts from a specific category, along with the author’s name and a custom excerpt.

$args = array(
    'category_name'  => 'technology', // Replace with your category slug
    'posts_per_page' => 3,
    'orderby'        => 'title',
    'order'          => 'ASC',
);

$query = new WP_Query( $args );

if ( $query->have_posts() ) {
    while ( $query->have_posts() ) {
        $query->the_post();
        echo '<h2>' . get_the_title() . '</h2>';
        echo '<p>By: ' . get_the_author() . '</p>';
        echo '<p>' . get_the_excerpt() . '</p>';
    }
    wp_reset_postdata();
}

Explanation:

• category_name: Filters posts by the category slug, such as “technology.”
• orderby: Sorts posts alphabetically by title (title).
• order: Specifies ascending order (ASC), useful for a directory-style listing.
• The loop outputs the post title, author name, and an excerpt.

Example 3: Fetch Posts Using a Date Query in Descending Order

Use this example to pull posts published after a certain date, ordered by most recent first.

$args = array(
    'date_query' => array(
        array(
            'after'     => 'January 1, 2023',
            'inclusive' => true,
        ),
    ),
    'posts_per_page' => 5,
    'orderby'        => 'date',
    'order'          => 'DESC',
);

$query = new WP_Query( $args );

if ( $query->have_posts() ) {
    while ( $query->have_posts() ) {
        $query->the_post();
        echo '<h2>' . get_the_title() . '</h2>';
        echo '<p>Published on: ' . get_the_date() . '</p>';
    }
    wp_reset_postdata();
}

Explanation:

• date_query: Filters posts published after a specified date (after parameter). The inclusive flag includes posts published on the exact date.
• orderby: Uses the date to order posts.
• order: Descending order (DESC) ensures that newer posts appear first.

This query is ideal for displaying recent content since a specific date.

Example 4: Retrieve Posts in a Custom Order with Multiple Parameters

Combine multiple parameters to create a highly customized query.

$args = array(
    'post_type'      => 'post',
    'posts_per_page' => 10,
    'orderby'        => array(
        'author' => 'ASC',
        'date'   => 'DESC',
    ),
);

$query = new WP_Query( $args );

if ( $query->have_posts() ) {
    while ( $query->have_posts() ) {
        $query->the_post();
        echo '<h2>' . get_the_title() . '</h2>';
        echo '<p>Author: ' . get_the_author() . ' | Published on: ' . get_the_date() . '</p>';
    }
    wp_reset_postdata();
}

Explanation:

• orderby: An array used to order posts first by the author in ascending order (ASC), then by date in descending order (DESC).
• posts_per_page: Limits the number of posts to 10, optimizing the query for performance.

This query is excellent for content that requires both author and date ordering.

Example 5: Query Posts with a Category and Date Constraint

This final example demonstrates a query that filters posts by category and only shows posts published before a specific date.

$args = array(
    'category_name' => 'news',
    'date_query'    => array(
        array(
            'before'    => 'December 31, 2023',
            'inclusive' => true,
        ),
    ),
    'posts_per_page' => 7,
    'order'          => 'DESC',
);

$query = new WP_Query( $args );

if ( $query->have_posts() ) {
    while ( $query->have_posts() ) {
        $query->the_post();
        echo '<h2>' . get_the_title() . '</h2>';
        echo '<p>Published: ' . get_the_date() . '</p>';
    }
    wp_reset_postdata();
}

Explanation:

• category_name: Restricts posts to the “news” category.
• date_query: Only includes posts published before December 31, 2023.
• order: The descending order (DESC) ensures the most recent posts within the date range are displayed.

Useful for archiving past content or creating a historical news section.

These examples should give you a solid foundation for using WP_Query to customize content retrieval from the WordPress database. By understanding and experimenting with these parameters, you can create highly efficient and tailored queries for any WordPress site.

Wrapping Up How to Use WP_Query in WordPress

Understanding how to effectively use WP_Query in WordPress can transform your site’s functionality and user experience. From creating custom queries to optimizing performance, mastering these techniques is essential for any WordPress developer. Remember, the key to success lies in choosing the right query method and avoiding common pitfalls to ensure your site runs smoothly.

Not sure whether all this custom work is worth it for your business? Our breakdown of what small businesses really need from WordPress in 2025 puts the cost-versus-value question in perspective.

If you’re ready to take your WordPress customization to the next level or need professional help implementing these techniques, explore our WordPress development services and discover how we can transform your website into a high-performing, user-friendly platform.