GITNUXSOFTWARE ADVICE
General KnowledgeTop 10 Best Pom Software of 2026
Ranked comparison of Pom Software tools for tracking work sessions and time, with notes on OpenProject, Taiga, and ClickUp.
How we ranked these tools
Core product claims cross-referenced against official documentation, changelogs, and independent technical reviews.
Analyzed video reviews and hundreds of written evaluations to capture real-world user experiences with each tool.
AI persona simulations modeled how different user types would experience each tool across common use cases and workflows.
Final rankings reviewed and approved by our editorial team with authority to override AI-generated scores based on domain expertise.
Score: Features 40% · Ease 30% · Value 30%
Gitnux may earn a commission through links on this page — this does not influence rankings. Editorial policy
Editor’s top 3 picks
Three quick recommendations before you dive into the full comparison below — each one leads on a different dimension.
OpenProject
REST API with work-item and workflow state endpoints plus schema-aware custom fields.
Built for fits when mid-size teams need visual workflow automation without code..
Taiga
Editor pickWorkflow configuration tied to a typed data model with API-driven updates.
Built for fits when teams need workflow-driven automation with a stable schema and governed access..
ClickUp
Editor pickClickUp Automations with API-backed triggers for status changes and field updates.
Built for fits when organizations need automation plus an API-driven work schema across teams..
Related reading
Comparison Table
This comparison table maps Pom Software tools against integration depth, data model design, and the automation and API surface used for provisioning and extensions. It also highlights admin and governance controls such as RBAC scope, configuration controls, and audit log coverage. The goal is to show concrete tradeoffs in schema fit, extensibility, and operational throughput rather than feature checklists.
OpenProject
on-prem capableProvides project management workflows with configurable permissions, REST API access for tasks and work packages, and audit logging for governance.
REST API with work-item and workflow state endpoints plus schema-aware custom fields.
OpenProject is built around an issue and project hierarchy that supports custom fields, workflow states, and team execution views such as boards and timelines. The REST API exposes work items, changes, and assignments in a way that can feed external planning and reporting systems. Automation can be implemented with API calls for provisioning work, changing states, and syncing metadata, while webhooks can notify external systems of updates. Admin and governance controls include RBAC with project roles plus audit log events that track key changes across the data model.
A tradeoff is that deep process automation often requires careful modeling of custom fields and workflow states, because inconsistent schema design increases integration mapping work. OpenProject fits teams that need controlled change history and API-based orchestration between engineering planning and downstream systems. It is a good match when integration throughput depends on predictable work-item IDs, consistent schema, and repeatable state transitions.
- +REST API covers work items, custom fields, and workflow state changes
- +RBAC with project roles supports role-scoped permissions
- +Audit log provides traceability for configuration and work updates
- +Webhooks enable event-driven integrations for issue changes
- –Workflow and custom field modeling adds upfront schema design effort
- –Complex governance scenarios require disciplined role and project setup
PMO and delivery operations
Standardize planning artifacts across portfolios
Fewer manual status corrections
IT service management teams
Sync tickets to internal tooling
Faster ticket lifecycle updates
Show 2 more scenarios
Engineering platform teams
Integrate release work with CI pipelines
Consistent release readiness tracking
Link sprints and releases to issues and drive state transitions through automated API calls.
Security and governance owners
Enforce RBAC and audit requirements
Stronger change control evidence
Apply project roles and review audit log events for permissions and configuration changes.
Best for: Fits when mid-size teams need visual workflow automation without code.
Taiga
API-first workflowSupports Scrum and Kanban work items with a documented API for creating and syncing issues, plus role-based access control for admin governance.
Workflow configuration tied to a typed data model with API-driven updates.
Taiga fits teams that already model work in types, fields, and statuses and want automation to act on that schema. It offers issue and project management features with configurable workflows, so configuration changes can map to predictable automation triggers. The integration depth is driven by an API surface that supports data synchronization and external tool connectivity, with practical throughput for ongoing operations.
A tradeoff is that deeper customization often depends on how teams structure their fields and workflow states up front. Taiga works best when automation rules and integrations can be expressed against stable objects such as projects, issues, and custom fields rather than ad hoc spreadsheet logic. It is a good fit for teams that need controlled configuration and repeatable provisioning across multiple projects.
- +Configurable workflow and schema make automation deterministic across issue states
- +API and automation surface supports integration-based provisioning and data sync
- +Role-based access controls support governance for projects and users
- +Activity history supports traceability during configuration and workflow changes
- –Advanced custom behavior depends on how fields and states are modeled
- –Cross-team automation may require careful standardization of issue types
Product operations teams
Automate release gates from issue states
Fewer manual status handoffs
Integration engineers
Synchronize Taiga issues to external systems
Consistent cross-tool state
Show 2 more scenarios
Program managers
Enforce project governance with RBAC
Reduced unauthorized configuration changes
Access controls limit who can change workflows and manage project data.
Operations analytics teams
Standardize reporting with custom fields
Comparable metrics across teams
A structured schema keeps dashboards aligned to shared definitions.
Best for: Fits when teams need workflow-driven automation with a stable schema and governed access.
ClickUp
automation + APIOffers tasks, dashboards, and automations with a public API surface for programmatic creation and updates plus organization-level permissions.
ClickUp Automations with API-backed triggers for status changes and field updates.
ClickUp’s data model centers on tasks, lists, statuses, and custom fields that can be reused across workflows. Organizations can configure views, automations, and reporting surfaces using that schema, which reduces the need for separate tracking tools. API and automation scope cover multiple entity types, with endpoints that support creating, updating, and moving work items based on events.
A tradeoff appears in governance, because schema sprawl can occur when many teams add custom fields and statuses without shared conventions. ClickUp fits when automation rules and integrations must stay close to a consistent work object model, such as routing tasks from intake forms into project workflows.
- +Configurable schema with reusable custom fields across workflows
- +Automation rules trigger on status and object events
- +API surface supports external provisioning and work updates
- +Workspace RBAC supports role-scoped access controls
- –Custom field sprawl can weaken reporting consistency without standards
- –Admin configuration across many spaces increases governance overhead
RevOps teams
Route inbound leads into delivery workflows
Fewer missed transitions
Platform engineering teams
Provision epics and tasks from tickets
Lower manual triage
Show 2 more scenarios
Operations managers
Enforce SLAs with rule-based routing
More on-time delivery
Automations apply due date logic and reassign tasks when conditions hit.
Program management offices
Standardize reporting using shared schemas
Consistent portfolio visibility
Custom fields and statuses support cross-team dashboards and rollups.
Best for: Fits when organizations need automation plus an API-driven work schema across teams.
Linear
GraphQL automationEnables teams to manage issues with a strong GraphQL API for workflow automation, plus workspace membership controls for governance.
GraphQL API plus webhooks for cycle and issue state automation
Linear is a Pom-style workflow tool built around an issue-first data model and strong automation surfaces. Its GraphQL API exposes core entities like teams, projects, issues, cycles, and views with granular fields, which supports custom Pom tracking and status transitions.
Automation runs through webhooks and API-driven workflows, which makes configuration and throughput controllable at the integration layer. Admin and governance rely on org-level identity, role permissions, and auditability for changes via API and internal actions.
- +GraphQL API exposes issues, cycles, and views for Pom-oriented state transitions
- +Webhook events support automation triggers without polling
- +Typed schema enables deterministic field mapping for timebox status and metadata
- +RBAC scopes access by organization roles and project visibility rules
- +Auditability improves traceability for workflow changes made via API
- –GraphQL clients require schema management to handle field and type changes
- –Pom-specific reporting needs external aggregation from issue and cycle events
- –Automation logic depends on event coverage and idempotency handling by consumers
- –Admin controls focus on org permissions more than workflow policy enforcement
- –High-volume event ingestion can require careful rate and retry design
Best for: Fits when teams need Pom tracking via issue state, API automation, and governed access.
Jira Software
enterprise workflowSupports issue workflows with configurable schemes, provides REST APIs for automation and provisioning, and maintains admin auditing for governance.
Jira Automation rules with triggers, conditions, and actions across issue lifecycle events.
Jira Software runs issue and workflow tracking with built-in Scrum and Kanban boards tied to a configurable data model. Integration depth is driven by Atlassian cloud services and a REST API that covers issues, workflows, permissions, and automation events.
Jira Automation and webhooks provide an automation surface for cross-tool actions such as field updates, status transitions, and notifications. Administration focuses on schema configuration, RBAC, provisioning controls, and audit log coverage across projects and organizations.
- +REST API covers issues, workflows, permissions, and bulk operations
- +Jira Automation supports event-driven rules without custom code
- +Project-level schemas and workflow schemes enable controlled standardization
- +RBAC via Atlassian groups maps access to projects and issues
- +Audit logs support traceability for admin actions and changes
- –Workflow and scheme changes require careful governance to avoid drift
- –Automation rule debugging can be slow when chains span multiple events
- –Advanced integrations often need app development for deeper UI workflows
- –Data model customization can increase maintenance overhead for admins
- –Throughput on bulk edits depends heavily on implementation patterns
Best for: Fits when teams need controlled workflow automation and deep API-driven integrations for issue tracking.
Confluence
docs data modelProvides structured documentation with a REST API for automation, permission models for spaces, and content history for auditability.
Space-level RBAC and page permissions with audit log coverage for governance and compliance workflows.
Confluence supports structured knowledge collaboration with a configurable data model for spaces, pages, labels, and permissions. Integration depth centers on Jira alignment, REST APIs, and add-on extensibility for connecting workflows and documents to external systems.
Automation and provisioning are driven by Atlassian APIs, webhook events, and admin configuration options that affect creation, access, and content lifecycle. Governance relies on RBAC controls tied to groups and spaces plus audit log coverage for traceable administrative actions.
- +Space and page permissions map cleanly to RBAC using Atlassian identity and groups
- +Jira and Confluence linkages keep issues, decisions, and documentation context synchronized
- +REST API and webhooks cover content, permissions, and event-driven integrations
- +App extensibility supports custom macros and workflows with well-defined extension points
- –Permission inheritance across space and page hierarchies can require careful policy design
- –Workflow automation often needs external services for multi-system orchestration
- –Large knowledge bases can demand tuning for content structure and retrieval performance
- –Advanced governance depends on admin setup and disciplined group management
Best for: Fits when teams need governed knowledge pages with Jira-linked workflows and documented API automation.
Miro
workspace integrationSupports collaborative boards with an API for programmatic updates and integrations, plus admin controls for team governance.
Miro REST API plus webhooks for event-driven board automation.
Miro differentiates with a workspace and diagram model that stays editable across browser clients while integrating with external identity, content, and automation. Its REST API and SDK support board CRUD, comments, access, and webhooks that feed automation pipelines tied to board events.
Extensibility includes custom apps with fine-grained permissions, and content can be structured for repeatable workflows through templates and variables. Admin features focus on RBAC, domain provisioning, and governance tooling such as audit logs for change visibility.
- +REST API supports board, comments, and access management automation
- +Webhooks enable event-driven workflows for board and user changes
- +Custom apps use granular scopes for controlled extensibility
- +RBAC and permission controls map access to teams and workspaces
- –Complex data mapping for rich canvas objects into external schemas
- –Automation throughput can bottleneck under large bulk board operations
- –Governance coverage is stronger for access than for in-canvas edits
- –Template and variable setup requires careful upfront schema design
Best for: Fits when teams need visual workflow automation with a documented API and governed access.
Notion
block data modelUses a flexible block-based data model with an API for automation and schema-like page structures plus team permissions for governance.
Notion API database schema and query model for reading and writing structured records.
Notion is a workspace knowledge tool that also functions as an application builder through its database data model and block-based pages. Its integration depth comes from a documented API, official and community connectors, and webhooks for workflow triggers.
Automation is driven by API-driven updates to database records, page properties, and related content, while extensibility relies on blocks and the structured query surfaces. Governance features include workspace roles via RBAC and admin-controlled settings that shape permissions, access, and content visibility across teams.
- +Unified block plus database data model supports structured content and page composition
- +Consistent API for databases, pages, properties, and query-driven reads
- +Automation via API updates and integrations that act on database records
- +RBAC enables role-based access across workspace, pages, and database permissions
- +Admin settings support managed access and external integration control
- –Page and block structure changes can complicate API scripts and migrations
- –High-volume sync work can hit latency and rate limits without careful batching
- –Fine-grained audit coverage depends on workspace plan configuration and settings
- –Cross-system data modeling can require adapters for property and schema mapping
Best for: Fits when teams need document-first workflows with API-driven automation and structured databases.
Trello
workflow boardsRuns board and card workflows with API endpoints for creating cards and lists plus organization admin controls for governance.
Trello Automation rules that trigger on board and card actions and execute configured updates.
Trello runs visual boards with cards and lists to model work and dependencies using a flexible, user-defined schema. Atlassian’s automation layer provides rule-based triggers and actions tied to card and board events, and Trello’s public API supports programmatic card and board CRUD.
Integration depth is mainly via Atlassian ecosystem connectors, webhooks, and app integrations that extend board metadata and workflows without changing the core data model. Governance relies on workspace administration and permission controls that determine access to boards and automation execution.
- +Card and board data model maps cleanly to work tracking and handoffs
- +Rule-based automation triggers on card and board events
- +Public API enables programmatic CRUD for boards, lists, and cards
- +Webhooks support event-driven integrations and sync pipelines
- +Permission controls restrict board access at workspace level
- –Schema is mostly properties on cards, so constraints are limited
- –Automation coverage is event-based and not a full workflow engine
- –Custom integration logic often requires external state management
- –Governance audit trails are limited for fine-grained admin oversight
- –Throughput for bulk operations depends on API rate limits
Best for: Fits when teams need board-centric workflow automation with API-driven integration and clear RBAC boundaries.
Monday.com
schema tablesOffers customizable tables with an API for provisioning and automation plus admin and permission settings for governance.
Automation built on item, status, and column changes for event-driven workflows.
Monday.com supports work management with a configurable data model built around boards, items, and column schemas that drive reporting and permissions. Integrations span common SaaS apps via native connections and third-party workflows, and the platform offers an API for data access and automation triggers.
Automation rules can react to changes in fields, assignments, and statuses to reduce manual coordination across teams. Governance is handled through organization settings, user roles, and audit logging to track key actions across workspaces.
- +Board-driven schema supports custom fields and consistent reporting
- +Automation rules trigger on field, status, and assignment changes
- +API enables programmatic CRUD and updates for board data
- +RBAC supports team-level access scoping across workspaces
- –Complex automations can be hard to reason about at scale
- –Automation coverage varies by feature and may require workarounds
- –API usage depends on board configuration and column conventions
- –Cross-board governance requires careful workspace and permission design
Best for: Fits when teams need visual workflow automation tied to a governed board schema.
How to Choose the Right Pom Software
This buyer's guide covers OpenProject, Taiga, ClickUp, Linear, Jira Software, Confluence, Miro, Notion, Trello, and monday.com for Pom-style workflow planning and timeboxed execution.
It focuses on integration depth, data model shape, automation and API surface, and admin and governance controls so evaluation can be mapped to concrete platform behaviors.
Pom software for workflow execution and timebox-driven issue states
Pom software coordinates work in short cycles with visual stages and structured artifacts like issues, cards, items, and board states.
Teams use these tools to drive predictable status transitions, capture time tracking where supported, and sync that work to external systems through REST or GraphQL APIs and webhook events. Tools like OpenProject and Linear show how an issue and workflow model plus API automation can power Pom-like state changes and reporting.
Evaluation criteria for Pom tools with schema, automation, and governance
Pom tools succeed when the workflow engine is tied to a defined data model and when automation triggers map cleanly to that model. OpenProject uses REST endpoints for work items and workflow state changes plus schema-aware custom fields, while Linear exposes GraphQL entities for issues, cycles, and views.
Integration and governance must be treated as first-class requirements because real Pom execution usually needs cross-system provisioning, event-driven updates, and audit-ready configuration changes. ClickUp, Jira Software, and Taiga all provide an API and automation surface, but governance depth varies by how RBAC, audit logs, and admin controls are implemented.
Schema-aware workflow state automation via documented APIs
OpenProject provides REST endpoints for work-item and workflow state changes so integrations can move Pom artifacts through configured states. Linear extends the same pattern with a GraphQL API plus webhooks for cycle and issue state automation.
Typed or structured data model for deterministic field mapping
Taiga ties workflow configuration to a typed data model so field and state changes remain deterministic across automation. ClickUp uses a configurable schema with reusable custom fields that automation rules can update on status and object events.
Automation surface that triggers on object and state events
Jira Software runs Jira Automation rules with triggers, conditions, and actions across issue lifecycle events, which supports Pom-related status transitions. Trello and monday.com also automate based on board and card events, with monday.com reacting to item, status, and column changes.
Webhook and event coverage for integration throughput
Miro and OpenProject support webhook-style event handling so external systems can react to board or issue changes without polling. Linear also uses webhooks for cycle and issue state automation, which matters when automation chains require fast event delivery.
Admin and governance controls with RBAC plus auditability
OpenProject pairs RBAC with project roles and includes audit log visibility for configuration and work updates. Jira Software maintains audit logs for admin actions and change traceability, while Confluence provides space-level RBAC and audit log coverage for governance workflows.
Extensibility and automation integration surface for provisioning and sync
ClickUp and Taiga emphasize API-driven updates for external provisioning and data sync with a defined issue schema. Notion offers an API database schema and query model for reading and writing structured records, which supports automated Pom documentation and structured execution logs.
A decision framework for picking the right Pom workflow tool
The first decision is whether workflow state changes and timebox artifacts map to a stable API-accessible data model. OpenProject and Linear both expose workflow concepts through REST or GraphQL so automation can be written against explicit work-item and cycle entities.
The second decision is whether governance and integration controls match the way execution will be run across teams. Jira Software, Taiga, and OpenProject each support RBAC patterns and audit visibility, while Confluence adds space-level permission models that pair naturally with Jira-linked execution context.
Validate the workflow state model against Pom execution needs
If Pom execution depends on moving work through workflow states, check whether the tool provides endpoints tied to workflow state changes. OpenProject exposes REST endpoints for work-item and workflow state changes, while Linear exposes GraphQL fields for issues and cycles plus webhook events for state transitions.
Test how the tool maps custom fields and typed data to automation
Choose tools where custom fields and schema elements are structured enough for integrations to map consistently. Taiga’s workflow configuration is tied to a typed data model, and OpenProject supports schema-aware custom fields through its REST API.
Confirm event-driven automation coverage before building integration chains
Automation chains fail when event coverage is incomplete or when consumers need heavy polling. Linear and OpenProject use webhooks for automation triggers, while ClickUp Automation rules fire on status and object events.
Align governance requirements with RBAC scope and audit logging
Select tools where the access model can be enforced at the right granularity and where admin changes are traceable. OpenProject includes audit log visibility for configuration and work updates, and Jira Software provides audit logs for admin actions and workflow-related changes.
Plan provisioning and sync around the tool’s actual API surface
Build provisioning logic around how each platform handles entities and updates at scale. ClickUp supports API-driven work object updates with automation triggers, while Notion centers API database records and query-driven reads and writes.
Set standards to prevent schema drift across teams and spaces
If a rollout spans many teams, enforce conventions for field usage and workflow configuration. ClickUp can face custom field sprawl if standards are not set, and Jira Software requires careful governance of workflow and scheme changes to avoid drift.
Which teams get the most from Pom software with integration and governance
Pom software targets teams that run short-cycle execution and need measurable state transitions tied to a workflow model. It also fits organizations that integrate cycle status with other systems through APIs and webhooks.
Tool choice depends on whether the core workflow engine is issue-first, board-first, or document-and-database-first, and whether governance must scale across projects or spaces.
Mid-size teams needing visual workflow automation without code
OpenProject fits because it combines configurable project workflows with a REST API covering work items, custom fields, and workflow state changes plus audit log visibility for governance traceability.
Teams that need deterministic workflow automation tied to a stable schema
Taiga fits when workflow behavior must remain consistent because workflow configuration is tied to a typed data model and API-driven updates support schema-based automation.
Organizations that want API-driven work schemas across teams
ClickUp fits because its configurable schema and ClickUp Automations trigger on status and object events, and the documented API supports programmatic creation and updates across a workspace.
Product and engineering groups automating Pom cycles through issue state
Linear fits because its GraphQL API exposes issues, cycles, and views with webhooks for cycle and issue state automation, which reduces integration friction for governed Pom tracking.
Teams that combine governed documentation with execution workflows
Confluence fits when Pom output must be recorded in governed knowledge pages because it provides space-level RBAC and audit log coverage plus REST APIs and webhook-driven automation.
Common Pom software pitfalls in integration, modeling, and governance
A frequent failure mode is choosing a tool with an API surface that does not align with how workflow states and timebox artifacts must change. GraphQL-based tools like Linear require schema-aware client handling, while board-centric tools like Trello can limit constraints because the schema is mostly properties on cards.
Another failure mode is treating governance as an afterthought. Complex governance scenarios need disciplined role and project setup in OpenProject, and cross-team configuration drift can appear in Jira Software when workflow and scheme changes are not governed.
Building automation against a workflow model that is not API-addressable for state changes
Avoid integration designs that assume arbitrary state edits will be supported consistently. OpenProject provides REST endpoints for workflow state changes, and Linear provides webhooks for cycle and issue state automation that integration code can react to.
Allowing schema drift in custom fields so automation logic stops mapping correctly
Avoid running without standards for field usage when automation depends on structured fields. ClickUp can accumulate custom field sprawl and weaken reporting consistency, and Jira Software requires careful governance of workflow and scheme changes to prevent drift.
Overlooking event and webhook coverage, leading to polling loops and missed transitions
Avoid automation chains that rely on polling when the tool offers event-driven triggers. Linear and OpenProject use webhooks for cycle and issue events, and ClickUp Automation rules trigger on status and object events.
Underestimating governance setup effort for RBAC and audit traceability
Avoid assuming governance works automatically without configuration. OpenProject supports RBAC with project roles and audit log visibility, but complex governance scenarios require disciplined role and project setup, and Jira Software requires careful permission mapping through Atlassian groups.
Trying to represent rich workflow constraints in a mostly flexible card property model
Avoid expecting full workflow constraints when the schema model is limited. Trello’s card and list model uses properties on cards so constraints are limited, and custom integration logic often needs external state management.
How We Selected and Ranked These Tools
We evaluated OpenProject, Taiga, ClickUp, Linear, Jira Software, Confluence, Miro, Notion, Trello, and Monday.com using editorial criteria tied to features, ease of use, and value, then produced an overall rating using a weighted average where features carry the most weight at 40% while ease of use and value each account for 30%. This scoring reflects criteria-based research of documented integration capabilities, automation surfaces, and governance controls rather than hands-on lab testing or private benchmark experiments.
OpenProject set the pace because its REST API specifically covers work items, schema-aware custom fields, and workflow state endpoints plus it provides RBAC with project roles and audit log visibility, which raised the features and value signals while keeping ease of use high for mid-size teams that want visual workflow automation without code.
Frequently Asked Questions About Pom Software
How do OpenProject and Jira Software model workflow states for Pom-style tracking?
Which tool provides a schema-driven data model for automation: Taiga, ClickUp, or Linear?
What is the best fit for event-driven automations using webhooks and APIs?
How do integrations differ when the goal is cross-tool orchestration with an API-first workflow engine?
How does RBAC governance work across tools: OpenProject, Confluence, and Monday.com?
Can teams automate tasks based on structured status or field changes without custom code?
What should admins do when migrating existing Pom or workflow data into a new system?
Which platforms offer extensibility for custom automation logic with controlled permissions?
What common operational issue breaks automations, and how do tools mitigate it?
Conclusion
After evaluating 10 general knowledge, OpenProject stands out as our overall top pick — it scored highest across our combined criteria of features, ease of use, and value, which is why it sits at #1 in the rankings above.
Use the comparison table and detailed reviews above to validate the fit against your own requirements before committing to a tool.
Tools reviewed
Primary sources checked during evaluation.
Referenced in the comparison table and product reviews above.
Keep exploring
Comparing two specific tools?
Software Alternatives
See head-to-head software comparisons with feature breakdowns, pricing, and our recommendation for each use case.
Explore software alternatives→In this category
General Knowledge alternatives
See side-by-side comparisons of general knowledge tools and pick the right one for your stack.
Compare general knowledge tools→FOR SOFTWARE VENDORS
Not on this list? Let’s fix that.
Our best-of pages are how many teams discover and compare tools in this space. If you think your product belongs in this lineup, we’d like to hear from you—we’ll walk you through fit and what an editorial entry looks like.
Apply for a ListingWHAT THIS INCLUDES
Where buyers compare
Readers come to these pages to shortlist software—your product shows up in that moment, not in a random sidebar.
Editorial write-up
We describe your product in our own words and check the facts before anything goes live.
On-page brand presence
You appear in the roundup the same way as other tools we cover: name, positioning, and a clear next step for readers who want to learn more.
Kept up to date
We refresh lists on a regular rhythm so the category page stays useful as products and pricing change.