What Makes a Good Feed?

A good feed is not just a list of popular items. It is a small, explainable pipeline that returns useful candidates for a specific user experience, keeps the results fresh, and has a fallback when the primary query is too narrow.

In the current Console at console.mbd.xyz, feed building has two core parts:

1. Algorithm: choose an index, search or filter it, hydrate the returned items, preview the result, and save the algorithm.
2. Feed config: choose one or more saved algorithms, set weights and cache behavior, add fallback rules when needed, and test the served feed.

Console currently focuses on search and hydration before output. There is no separate feature engineering, scoring, or ranking step to configure in the feed builder.

Start With A Clear Feed Job

Before opening the builder, define what the feed is supposed to do:

Use the supported index list as the source of truth for index names and fields: Supported Indices.

What To Configure In Console

1. Pick The Right Source

The index dropdown controls what kind of entities the feed can return. Pick the source that already matches the surface you are building:

• Use item indexes for content, markets, tokens, or trade events.
• Use user or wallet indexes when the feed should return accounts, traders, wallets, or users.
• Use notification indexes when the feed should be driven by delivered or deliverable notification events.

A good feed starts narrow. If the page is about tokens, start from a token index. If it is about trader discovery, start from a wallet or trader-oriented index.

2. Filter Before You Hydrate

Filters are how you make the feed useful. Use them to remove invalid candidates before they reach the UI:

• Require key fields with notNull.
• Restrict categorical fields with term or terms.
• Use numeric ranges for liquidity, volume, timestamps, counts, or quality thresholds.
• Use consoleAccount or inAppUsers filters when the feed should be scoped to your app users.

Keep filters explainable. If someone asks why an item appeared, you should be able to point to the index, filters, and sort.

3. Hydrate The Fields The UI Needs

Hydration is the step that turns search hits into useful feed cards. Ask for the fields your client needs to render the feed, such as title, image, symbol, URL, market metadata, timestamps, or user identity fields.

Avoid over-hydrating. Returning every field makes payloads larger and makes the feed harder to debug.

4. Preview With Real Output

Use the Console preview before deploying:

• Check whether the first page looks usable.
• Confirm images, titles, and IDs are present.
• Look for repeated items or empty fields.
• Test a narrow filter and then loosen it until the feed has enough candidates.

If the preview is mostly empty, the query is too strict. If it is noisy, the query is too broad.

Feed Examples

Fresh Token Discovery

Use this when you want a feed of active token items for a discovery surface.

import mbd from "algo-dsl";

export default async function algo() {
  return mbd
    .search()
    .index("token-items")
    .notNull("symbol")
    .notNull("name")
    .range("volume_24hr", { gt: 0 })
    .sortBy("timestamp", "desc")
    .size(30);
}

Why it works:

• It starts from a token-specific source.
• It removes items without the basic display fields.
• It keeps the result fresh with a timestamp sort.
• It returns enough candidates for a feed page without over-fetching.

Active Trader Or Wallet Discovery

Use this when the feed should return wallets or trader-like profiles rather than content items.

import mbd from "algo-dsl";

export default async function algo() {
  return mbd
    .search()
    .index("polymarket-wallets")
    .notNull("user_id")
    .range("volume_1mo", { gt: 0 })
    .sortBy("volume_1mo", "desc")
    .size(25);
}

Why it works:

• It uses a wallet/user-style source for a wallet/user feed.
• It removes candidates that cannot map back to a user.
• It uses recent activity as the main ordering signal.

App-Scoped Feed

Use app-user filters when the feed should only include entities connected to your Console account or in-app users.

import mbd from "algo-dsl";

export default async function algo() {
  return mbd
    .search()
    .index("token-items")
    .consoleAccount("account_id")
    .notNull("item_id")
    .sortBy("timestamp", "desc")
    .size(30);
}

Use the field names that match the index you selected. Console tooltips and the supported-index table show which fields are available for each source.

Feed Config Best Practices

After saving an algorithm, deploy it through a feed config.

Good feed configs are boring in the best way: the primary algorithm handles the normal path, the fallback handles sparse data, and exclusion rules keep repeated content out.

Quality Checklist

Before shipping a feed, check:

• The index matches the thing your UI is showing.
• Required display fields are present after hydration.
• Filters are strict enough to remove bad candidates but not so strict that the feed is empty.
• Sort order matches the feed job, such as freshness, activity, or liquidity.
• The first page has enough unique candidates.
• There is a fallback algorithm for cold start or sparse results.
• The served feed has been tested through the feed config test panel.

Common Problems

Next Steps

• Build the algorithm in Console.
• Check fields in Supported Indices.
• Learn search options in Search.
• Deploy the saved algorithm with Feed Configs.