GITNUXSOFTWARE ADVICE
Cybersecurity Information SecurityTop 10 Best Parental Lock Software of 2026
Top 10 Parental Lock Software tools ranked for family device control, with criteria and reviews of Bark, Disney Family Premium, and Qustodio.
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.
Bark
Bark’s parent alert workflow groups detected risky content into child- and time-based notifications for review.
Built for fits when households need multi-channel monitoring with straightforward parent alerting and minimal policy engineering..
Disney Family Premium
Editor pickChild-profile policy application through family account enrollment and device association.
Built for fits when a family needs profile-based device controls with centralized account governance..
Qustodio
Editor pickWeb filtering with category controls and schedule windows tied to enrolled device policies.
Built for fits when families need enforceable screen time and filtering with per-device reporting..
Related reading
Comparison Table
The comparison table maps parental lock tools like Bark, Disney Family Premium, Qustodio, Net Nanny, and Kaspersky Safe Kids to integration depth, including how each service provisions child profiles and aligns device actions with its data model and schema. It also grades automation and the API surface for alerts, reporting, and policy updates, alongside admin and governance controls such as RBAC, audit logs, and configuration controls. The goal is to show where platform choices trade off throughput, extensibility, and governance rather than just listing feature checkmarks.
Bark
family monitoringProvides child online safety monitoring with configurable alerts, report history, and family account governance for messaging, social, and web signals.
Bark’s parent alert workflow groups detected risky content into child- and time-based notifications for review.
Bark’s core capability centers on content monitoring across multiple app categories and delivering alerts tied to specific children and devices. Notifications support parent follow up, and the system organizes findings into an overview that is usable for ongoing governance. Integration depth is practical rather than developer-driven since Bark targets mobile and app-level telemetry instead of requiring enterprise agents.
A key tradeoff is that Bark’s control surface is configuration and monitoring oriented, not a developer-extensible policy engine with custom schema. Bark fits situations where families want guided oversight with low setup overhead and predictable alerting rather than deep automation through an exposed API.
- +Cross-app content monitoring with parent notifications
- +Family-focused configuration tied to individual children
- +Daily summaries support consistent review cadence
- –Automation limits compared with API-native policy engines
- –No documented RBAC or extensible audit log schema for administrators
- –Less control over false positives than rules-first filters
Busy parents
Monitor risky messages across apps
Faster escalation and follow up
Families with multiple children
Separate oversight by child profile
Less confusion during reviews
Show 1 more scenario
Guardians managing screen risk
Review activity signals regularly
Consistent review workflow
Bark provides scheduled summaries that support ongoing oversight and incident tracking.
Best for: Fits when households need multi-channel monitoring with straightforward parent alerting and minimal policy engineering.
Disney Family Premium
family safetyDelivers family digital safety controls for minors via a family dashboard with monitoring signals, management settings, and caregiver alerts.
Child-profile policy application through family account enrollment and device association.
Disney Family Premium is a family-device control system that groups children under a shared family account and applies configuration through that account’s data model. Enrolled devices receive policy settings for content access, and the controls can be updated as profiles change. Governance relies on family roles in the account, which limits who can change filtering, add devices, or adjust child profiles.
A tradeoff appears in automation and extensibility since the control surface is largely account-driven and does not expose a documented public API for custom rule provisioning. Families that need repeatable, code-based workflows for many devices often find fewer integration options than tools with broader developer surfaces. Disney Family Premium fits most when consistent rules per child profile matter more than custom integrations with third-party monitoring or device management systems.
- +Profile-based controls that keep settings tied to each child
- +Account enrollment enables centralized device configuration
- +Content filtering applies across common browsing and app entry points
- –Limited documented extensibility for custom automation workflows
- –Automation depends on family account configuration rather than external triggers
- –Governance granularity is bounded by family-role controls
Parents managing multiple children
Apply consistent rules per child profile
Less manual configuration per device
Households with shared devices
Control access across family-owned phones
More consistent access boundaries
Show 2 more scenarios
Families avoiding developer workflows
Set controls using guided configuration
Lower setup friction
Rules can be configured inside the family account rather than via API scripts or integrations.
Families needing audit-friendly governance
Restrict policy changes to guardians
Tighter change control
Family roles gate configuration actions so child profile settings are not altered casually.
Best for: Fits when a family needs profile-based device controls with centralized account governance.
Qustodio
multi-device controlsOffers cross-device parental controls with web filtering, app controls, usage limits, location features, and admin reporting across child profiles.
Web filtering with category controls and schedule windows tied to enrolled device policies.
Qustodio combines content filtering, schedule-based screen time, and app blocking with activity reports tied to managed devices. The data model aligns policies to individual endpoints through device enrollment and per-device settings, which helps governance when multiple children use different devices. Automation and API surface are less transparent than tools built for enterprise-style integrations, so orchestration typically stays inside Qustodio's admin UI and notification flows.
A key tradeoff is that deeper automation and custom integrations are limited, so teams that need schema-level event streaming or external policy engines may hit an integration ceiling. Qustodio works well when the admin goal is straightforward enforcement such as blocking categories during school hours and reviewing web and app activity afterward. It fits households that want consistent policy application without building custom workflows around raw telemetry.
- +Cross-device coverage with consistent web filtering and schedule controls
- +Clear per-device policy application using managed enrollment and assignments
- +Activity reporting ties web and app events to managed endpoints
- +Location tracking supports context for device usage decisions
- –API and automation surface is not documented for custom external governance flows
- –Policy depth can be constrained by UI-driven configuration rather than schema-first tooling
Single parent households
Block categories during homework hours
Fewer off-task sites
Families with multiple devices
Set different limits per tablet
Policy separation by device
Show 1 more scenario
Guardians managing teens
Review app usage and events
Actionable visibility for conversations
Use structured app and activity reporting to understand usage patterns.
Best for: Fits when families need enforceable screen time and filtering with per-device reporting.
Net Nanny
internet supervisionImplements internet and device supervision with web filtering, screen time schedules, app blocking, and parent activity reports per child profile.
Centralized family profiles that apply web filtering and app permissions per child device.
Net Nanny targets parental device control with content filtering, app controls, and web safety policies enforced on managed endpoints. Its integration depth is driven by multi-device profiles that map a family policy set onto each child’s device.
The product emphasizes configurable thresholds for categories like web content, screen time, and app permissions, with centralized admin for consistent behavior. Automation and API surface are limited compared with tools that publish broad developer endpoints for policy provisioning and event ingestion.
- +Policy enforcement across multiple device types with per-child profile configuration
- +Content filtering and app controls tied to categories and age-appropriate rules
- +Central admin console supports consistent settings and rule review across devices
- +Screen time controls include scheduled limits and pause behavior
- –Automation and external API surface are limited for custom integrations
- –Event exports and webhook-like workflows are not the primary automation mechanism
- –Governance controls lack clearly documented RBAC granularity for multi-admin teams
- –Audit log depth for configuration changes is not presented as an automation-first data model
Best for: Fits when families want centralized policy configuration for web and app control without building custom integrations.
Kaspersky Safe Kids
child protectionProvides child protection with web and app filtering, screen time controls, and location features managed from a caregiver console.
Schedule-driven restrictions that enforce usage limits by child profile across supported apps and browsing activity.
Kaspersky Safe Kids applies parental controls across a child device through content filtering, app and web activity rules, and schedule-based limits. Integration depth centers on how rules are modeled for child profiles and how enforcement maps to device actions like blocking categories and limiting usage windows.
Governance is handled through account-based management of child profiles, with activity reporting designed for parent review rather than developer workflows. Automation and API surface are limited compared with tools built around documented schemas and programmable rule provisioning.
- +Web and app category controls with schedule-based enforcement
- +Child profile model supports per-device rules and restrictions
- +Activity reporting focuses on actionable parent visibility
- +Blocklists and allowlists support targeted category and site control
- –Limited documented automation and API for rule provisioning
- –RBAC granularity for delegated administrators is not a primary strength
- –No clear extensibility model for custom policy engines
- –Audit-log depth for policy changes is not the main focus
Best for: Fits when family device control needs category filtering, usage schedules, and parent-focused activity review.
Norton Family
family filteringControls child device browsing and apps with web filtering, time limits, and activity monitoring through caregiver management settings.
Per-child policy profiles apply screen time and content rules per device.
Norton Family fits households that need device-level supervision across major mobile and desktop ecosystems. Policy configuration covers screen time, app and web categories, and content filters, with per-child profiles that map to enforcement rules.
Norton Family focuses on operational control through guided setup, remote management from the admin account, and periodic status reporting from managed devices. Integration depth is primarily client-driven since Norton Family centers on agent-based enforcement rather than an exposed automation API.
- +Per-child profile separation supports different policies for each device
- +App and web category filtering covers common content types
- +Screen time schedules limit usage by day and time window
- +Managed-device reports show compliance outcomes and activity signals
- –Limited documented automation surface reduces integration options
- –No public, programmable schema for policies and enforcement events
- –Automation throughput depends on client reporting cadence
- –RBAC granularity is constrained to account-level admin use
Best for: Fits when families want guided policy setup and device enforcement without building custom workflows.
ESET Parental Control
web filteringEnforces web and app restrictions plus usage controls with caregiver dashboards and per-child configuration management.
Device-level time and content enforcement tied to child profiles in an ESET account setup.
ESET Parental Control targets family device control through OS-level enforcement and policy-based filtering rather than browser-only controls. The product centers on content filtering categories and time rules applied to managed child profiles.
Integration depth shows up through device management hooks and ESET account-based provisioning for rule distribution. Admin governance relies on profile separation and auditability of changes, but it exposes limited automation and API surface for external orchestration.
- +Time schedules and content categories apply at device enforcement level
- +ESET account onboarding supports repeatable profile provisioning
- +Child profile separation reduces rule cross-contamination
- +Clear configuration model for filter categories and allowed lists
- –Limited public API and automation surface for external tools
- –Few schema-level controls for custom app or domain classification
- –Automation throughput options for large fleets are constrained
- –Audit log granularity for policy diffs is not deeply configurable
Best for: Fits when households need device-enforced filtering and schedules without building automation or custom integrations.
Mobicip
mobile controlsDelivers mobile-first parental control with content filtering, time limits, and device monitoring managed in a centralized parent console.
Per-child policy management with scheduled filtering that propagates across enrolled family devices.
Parental lock software like Mobicip targets family device control across iOS and Android using policy-based filtering and scheduling. Mobicip’s integration depth shows up in how it provisions app and site access rules tied to a family data model, rather than only time-of-day blocks.
Admin control centers on account-level management of child profiles with configurable content categories and per-device enforcement behavior. The automation and API surface is designed for rule propagation across managed endpoints, which supports repeatable governance across a household setup.
- +Category-based web filtering with per-child profile scoping
- +Device policy scheduling supports routine time windows
- +Cross-device rule provisioning keeps behavior consistent
- +Family account model reduces per-device configuration drift
- –Automation relies on guided setup flows more than programmable orchestration
- –Limited transparency for rule matching and classification reasons
- –Granular app permissions can require manual adjustments per profile
- –Audit log depth and export options are harder to operationalize
Best for: Fits when families need consistent category filtering with scheduled enforcement across iOS and Android devices.
Kidslox
app controlProvides parental controls for iOS and Android with web filtering, app blocking, and usage limits tied to parent-managed child profiles.
Admin device policy profiles that bundle filtering and screen time under a single configuration workflow.
Kidslox applies device-level parental controls through a managed profile and policy configuration model. The core work centers on web and app filtering, screen time limits, and location-aware child device handling.
Integration depth is driven by account provisioning workflows and configuration states that map cleanly to admin-managed devices. Automation and extensibility depend on whether Kidslox exposes a documented API surface for provisioning, policy updates, and audit log retrieval.
- +Policy-driven filtering for apps and web categories under one configuration model
- +Screen time rules connect to device behavior instead of only browser settings
- +Admin-managed device profiles support consistent enforcement across child devices
- +Auditability is stronger when action logs are exportable via API or reports
- –Automation depth depends on documented API coverage for policy and provisioning
- –RBAC granularity may limit delegation if roles are limited to admin and user
- –Device edge cases can require manual reconfiguration after network or account changes
- –Extensibility hinges on schema support for custom categories and rule templates
Best for: Fits when families need device policy enforcement with predictable admin configuration and audit records.
SecureTeen
family supervisionRuns child internet restrictions and alerts with parent reporting, schedules, and content filters through a caregiver management interface.
Household policy provisioning with RBAC-backed admin governance for consistent enforcement across devices.
SecureTeen fits households that need device-level parental locking with centralized policy enforcement across multiple endpoints. The product focuses on a configurable control set that targets browsing, apps, and device behavior through a governed policy data model.
Integration depth centers on account provisioning and rule distribution, so enforcement stays consistent as children move between devices. Admin and governance controls emphasize monitoring visibility and role separation to reduce accidental policy changes.
- +Central policy configuration applied across multiple household devices
- +Role separation supports administrator and guardian workflows
- +Automation-friendly rule distribution keeps enforcement consistent
- +Clear governance controls reduce accidental configuration drift
- –Extensibility depends on supported integrations and control types
- –API automation surface appears limited for custom monitoring workflows
- –Data model complexity may require careful policy planning
- –Throughput impact is unclear during high-frequency rule updates
Best for: Fits when families need governed device controls across endpoints with minimal policy drift.
Conclusion
After evaluating 10 cybersecurity information security, Bark 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.
How to Choose the Right Parental Lock Software
This buyer’s guide covers how to select parental lock software for family device control using tools like Bark, Disney Family Premium, Qustodio, and Net Nanny. It focuses on integration depth, data model, automation and API surface, and admin governance controls.
Each section maps specific evaluation criteria to how these tools enforce policies across devices and channels. The guide also highlights common configuration gaps seen across Bark, Kaspersky Safe Kids, Mobicip, Kidslox, and SecureTeen.
Parental lock tooling that enforces child profiles across devices and channels
Parental lock software provides enforcement policies tied to child profiles, including web and app filtering, screen time schedules, and reporting signals for caregiver review. The main job is to keep policy changes centralized enough to apply consistently while still producing actionable notifications or activity records.
In practice, tools like Qustodio and Norton Family apply schedule-based limits and category controls across enrolled endpoints. Bark takes a different approach by coupling detection signals to parent alert workflows that group risky content by child and time for review, while Disney Family Premium centers profile-based controls under a family dashboard tied to device association.
Evaluation criteria for integration depth, policy data model, and admin governance
Selection should start with how policies are represented as data and how changes propagate to devices. The strongest tools treat policy as a structured model that administrators can configure, govern, and audit across child profiles.
Integration depth matters because limited automation and undocumented API surfaces force manual updates. Tools like Bark and Qustodio can cover common monitoring needs without deep developer workflows, while Mobicip and Kidslox focus more on repeatable rule propagation across enrolled devices.
Profile-scoped policy application
A child-profile model determines whether a policy applies cleanly per child without cross-contamination. Net Nanny and Norton Family emphasize centralized family profiles that apply web filtering and app permissions per child device, while Disney Family Premium applies child-profile policy through family account enrollment and device association.
Schedule-driven enforcement for time windows
Screen time and restriction windows should enforce at the device level so children cannot bypass policy by switching sites or apps. Kaspersky Safe Kids uses schedule-driven restrictions enforced by child profile across supported apps and browsing activity, while Qustodio ties schedule windows to enrolled device policies for web filtering and usage limits.
Monitoring coverage across web, apps, and messaging signals
Coverage determines which channels actually produce alerts and blocks. Bark monitors common channels including SMS, web browsing signals, YouTube activity, and popular social apps, while Qustodio and Net Nanny emphasize web filtering and app controls tied to categories and device policies.
Parent alerting workflow with review cadence controls
Notification grouping and summaries reduce review load and speed up escalation decisions. Bark groups detected risky content into child- and time-based parent notifications and provides daily or scheduled summaries to support a consistent review cadence, while other tools emphasize caregiver activity reports over automated alert workflows.
Admin governance controls including RBAC and delegated management
Governance controls should support more than a single account owner when multiple caregivers exist. SecureTeen highlights role separation for admin and guardian workflows, while several other tools show limited documented RBAC granularity for multi-admin teams, which can constrain delegated control.
Automation and API surface for policy provisioning and event ingestion
Automation controls matter when rule updates must be triggered by external systems or when fleet-level operations need throughput. Bark’s automation is limited compared with API-native policy engines and lacks documented RBAC or an extensible audit log schema for administrators, while Mobicip’s automation and API surface is designed to propagate rule changes across managed endpoints for repeatable governance.
Decision framework for choosing parental lock software with control depth
Start by defining the enforcement targets and the policy update workflow. Families that mainly need caregiver review and prompt alerts can prefer Bark or Disney Family Premium, while households that need enforceable filtering and schedule controls across many devices often prioritize Qustodio or Net Nanny.
Next, validate integration depth against governance and automation expectations. Tools that rely on guided setup flows and account configuration can work well for single-household administration, but tools with a documented automation surface are better when policy provisioning must be repeatable and externally orchestrated.
Map enforcement scope to policy signals and channels
If monitoring must include messaging and social signals, Bark is built around a unified detection workflow across SMS, web signals, YouTube activity, and popular social apps. If control must be mainly web filtering and app blocking with schedule windows, Qustodio and Net Nanny apply category controls and schedule-based limits tied to enrolled device policies.
Verify the policy data model matches child-profile administration
Confirm that each child has a separate profile so schedule limits and category rules do not overlap across devices. Net Nanny and Norton Family separate per-child profiles and apply content rules and screen time schedules per device, while Disney Family Premium applies child-profile policy through family account enrollment and device association.
Check automation needs against the available API and automation surface
If external systems must trigger policy updates and ingest events, Mobicip’s automation and API surface is designed for rule propagation across managed endpoints. If automation is not required and caregiver review is the primary workflow, Bark can rely on daily summaries and parent notifications even with limited API-native policy provisioning.
Evaluate governance depth for multi-caregiver administration
For multi-admin setups, prioritize tools with documented role separation so guardians and admins have distinct workflows. SecureTeen emphasizes RBAC-backed role separation for administrator and guardian workflows, while Bark and several other tools show limited documented RBAC granularity for delegated teams.
Assess auditability and configuration change visibility
Look for tools that provide clear audit records for configuration changes so incorrect policy edits can be traced. Kidslox is positioned for stronger auditability when action logs are exportable via reports, while Bark couples detection to alert workflows but does not present an extensible audit log schema for administrators.
Stress-test device association and propagation across endpoints
For consistent behavior as children move between devices, confirm the system ties enforcement to enrolled endpoints rather than one-off toggles. Disney Family Premium uses device association under a family account, and Mobicip and Net Nanny emphasize centralized configuration applied across enrolled family devices.
Which households match which parental lock control model
Parental lock software fits different families based on the required enforcement channels and the desired admin governance workflow. Some tools center child-profile policy under a family account dashboard, while others center detection signals and caregiver notifications.
The best match depends on whether the primary workflow is policy administration, alert review, or automation-driven governance across multiple endpoints.
Families needing multi-channel monitoring with alert grouping
Bark fits households that need unified monitoring signals and parent notifications across web, YouTube, and messaging-adjacent channels because it groups risky content by child and time for review and supports daily or scheduled summaries.
Families that want centralized profile controls with device association
Disney Family Premium is a fit when family administration should stay inside a family dashboard because it applies child-profile policy through family account enrollment and device association. It also favors guided configuration flows over external automation.
Households enforcing web filtering and schedule limits across endpoints
Qustodio and Net Nanny fit families that want enforceable screen time and filtering tied to enrolled device policies because they support web filtering category controls and schedule windows tied to managed endpoints.
Parents prioritizing device-enforced restrictions and predictable scheduling
Kaspersky Safe Kids and ESET Parental Control fit households that want schedule-driven restrictions enforced through child profiles at the device level. Both tools model time and content categories and apply them to managed child profiles rather than relying on browser-only controls.
Admins who need automation-friendly rule propagation and governance consistency
Mobicip fits when repeatable governance requires automation and an API surface for rule propagation across managed endpoints. SecureTeen also fits when governance needs role separation for administrator and guardian workflows, but its API automation surface is described as limited for custom monitoring workflows.
Where parental lock implementations go wrong in day-to-day administration
Several recurring issues appear across the tools when families treat parental lock as a one-time setup instead of an ongoing governance workflow. The failure modes usually relate to limited automation surfaces, unclear audit depth, and delegated admin constraints.
Configuration drift also shows up when child profiles and device associations are not managed carefully across enrolled endpoints.
Choosing a monitoring-first tool when automation is required for policy provisioning
Bark focuses on detection signals and parent alert workflows with limited API-native policy provisioning, so it can constrain external orchestration needs. Mobicip is a better match when repeatable rule propagation across managed endpoints and an automation-friendly surface are required.
Assuming RBAC and delegated admin governance exist for multi-caregiver teams
Bark does not present documented RBAC for administrators and Net Nanny and Kaspersky Safe Kids also lack clearly documented RBAC granularity for delegated management. SecureTeen is the closer option because it emphasizes role separation between administrator and guardian workflows.
Overlooking auditability of configuration changes during policy tuning
Bark does not provide an extensible audit log schema for administrators, and Kaspersky Safe Kids and Norton Family focus reporting on parent visibility rather than deeply configurable policy diff audit models. Kidslox is positioned for stronger auditability when action logs are exportable via reports.
Relying on guided setup flows when repeatable fleet-level updates are needed
Disney Family Premium and Qustodio emphasize account configuration and UI-driven policy management, which can slow external trigger workflows. Mobicip and Kidslox align better to repeatable governance when policy updates and provisioning must be operationalized across multiple enrolled devices.
Creating expectations for transparency in rule matching without checking classification visibility
Mobicip notes limited transparency for rule matching and classification reasons, which can make it harder to explain why specific content was flagged. Bark and Qustodio provide alerting and reporting, but both still emphasize notification and categorization rather than a schema-first explainability model.
How selection was produced and why Bark ranks higher than lower integration tools
We evaluated each parental lock tool on feature coverage, ease of use for caregiver workflows, and value for the control model it enforces across devices. We rated those categories and computed an overall score as a weighted average in which features carries the most weight, while ease of use and value each account for the remaining share.
This guide’s ordering reflects the operational reality of parental lock control models, not just the breadth of web or app filtering. Bark stands out in this set because its parent alert workflow groups risky content into child- and time-based notifications and it provides daily or scheduled summaries, which lifted its feature score and supported higher review usability for multi-channel monitoring.
Frequently Asked Questions About Parental Lock Software
How do Bark and Mobicip differ in content detection workflow across family devices?
Which tools support API-driven integrations or automation for parental control configuration?
How do Disney Family Premium and Qustodio handle admin governance and policy changes across children?
What approach best fits device-level enforcement rather than browser-only controls?
How do secure administration and role separation compare between SecureTeen and other household control tools?
Which platform is better for schedule-driven restrictions that enforce usage windows?
How do Bark and Disney Family Premium differ in the type of oversight parents receive?
What data migration steps are typically required when moving from one parental control tool to another?
Why do some tools show inconsistent policy behavior when new devices are added?
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
Cybersecurity Information Security alternatives
See side-by-side comparisons of cybersecurity information security tools and pick the right one for your stack.
Compare cybersecurity information security 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.