GITNUXSOFTWARE ADVICE
Technology Digital MediaTop 10 Best Product Backlog Software of 2026
Top 10 product backlog software ranked for teams evaluating tools like Jira, ProdPad, and Airfocus, with comparison notes on fit and tradeoffs.
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
Jira is the best pick if you need cross-team backlog execution with consistent sprint and roadmapping workflows backed by API integration, whereas ProdPad is a better alternative for product teams that refine ideas and stories through template-driven prioritization before planning.
Editor’s top 3 picks
Three quick recommendations before you dive into the full comparison below — each one leads on a different dimension.
Jira
Workflow automation plus issue lifecycle triggers can enforce backlog rules without manual steps.
Built for fits when cross-team backlog execution needs consistent workflows and strong integration via API..
ProdPad
Editor pickAcceptance criteria templates and Definition of Done help teams enforce story readiness with repeatable refinement steps.
Built for fits when product teams need template-driven refinement and prioritization before sprint planning..
Airfocus
Editor pickImpact and confidence prioritization with ranked outcomes stays attached to the same item across workflow stages.
Built for fits when product teams need a prioritization-first backlog layer with shared rationale..
Related reading
Comparison Table
Product backlog software matters because teams need a shared data model for ideas, issues, and roadmaps that can be provisioned, automated, and audited across releases. This ranked review targets engineering-adjacent buyers who compare architecture choices, including backlog workflows, prioritization logic, and integration paths, using consistent evaluation criteria across the category.
Jira
enterpriseAgile project tracker with dedicated backlog management, sprint planning, and roadmapping modules.
Workflow automation plus issue lifecycle triggers can enforce backlog rules without manual steps.
Jira builds backlog refinement around configurable issue types and workflows, so teams can standardize states, acceptance workflows, and Definition of Done checkpoints at the project level. Board configuration supports column mapping to workflow status, rank-based ordering, and swimlane grouping for cross-team backlog views. Jira automation can enforce backlog hygiene by running rules when fields change, such as setting resolution gates, auto-assigning owners, or creating follow-up issues.
A common tradeoff is that complex workflow logic and many issue fields can increase setup and governance overhead across multiple teams. Jira fits best when an organization needs consistent backlog processing across teams and wants to connect issue lifecycle data to external systems through its API and integrations.
- +Configurable issue workflows let teams encode backlog states precisely
- +Automation rules can update backlog fields from workflow events
- +API and integrations keep backlog data in sync with other systems
- +Board views support sprint planning, ranking, and team-level grouping
- –Workflow and field configuration can become complex across many projects
- –Dependency modeling needs extra workflow discipline or add-ons
- –Large backlogs can feel heavy without careful board and filter design
- –Advanced reporting often depends on specific configuration choices
Product management teams
Refinement with epic-to-story tracking
Less drift between plans and execution
Agile delivery managers
Sprint planning with status-driven boards
Fewer sprint surprises
Show 2 more scenarios
Platform engineering orgs
Backlog-to-CI traceability via API
Tighter feedback on work items
Integrations can push build, test, and deployment signals into issue contexts for traceable progress.
Customer support product teams
Link backlog items to incidents
Clear accountability for fixes
Work from support channels can be associated with backlog issues to track fixes through status changes.
Best for: Fits when cross-team backlog execution needs consistent workflows and strong integration via API.
More related reading
ProdPad
SMBProduct management software with idea backlog, story mapping, and roadmap integration.
Acceptance criteria templates and Definition of Done help teams enforce story readiness with repeatable refinement steps.
ProdPad supports structured backlog refinement using configurable fields, workflow stages, and reusable templates for acceptance criteria. It captures story hierarchy for epic breakdown and encourages consistent granularity from initial idea through delivery-ready refinement. Prioritization can be driven with scoring methods and custom attributes so backlog item rank reflects agreed criteria. It also supports roadmap views that map work across themes and time horizons.
The main tradeoff is that ProdPad requires teams to adopt its specific workflow stages and template conventions to get consistent outputs. ProdPad fits teams that run regular backlog grooming cadence and want fewer ad hoc story formats. It also fits product organizations that need cross-team visibility into requirements traceability from idea to acceptance-ready work.
- +Acceptance criteria templates standardize story readiness across teams
- +Configurable workflow stages support repeatable backlog refinement routines
- +Prioritization scoring uses custom fields for decision consistency
- +Roadmap and backlog views keep theme-level context attached to work
- –Requires consistent template usage to prevent uneven story quality
- –Dependency mapping and audit-style traceability need careful process design
- –Cross-tool automation can be limited for highly customized engineering workflows
- –Story split heuristics are not as configurable as dedicated backlog tools
Product managers and team leads
Refine stories with shared readiness rules
More consistent delivery-ready stories
Agile delivery teams
Plan sprints from scored backlog items
Fewer re-rank cycles
Show 1 more scenario
Product ops and portfolio owners
Connect themes to execution work
Improved cross-team visibility
Roadmap views link higher-level themes to backlog items and refinement status.
Best for: Fits when product teams need template-driven refinement and prioritization before sprint planning.
Airfocus
SMBProduct management tool with prioritization frameworks, backlog scoring, and roadmap views.
Impact and confidence prioritization with ranked outcomes stays attached to the same item across workflow stages.
Airfocus supports product teams that need a single place for idea intake, prioritization, and decision traceability through stages like assessment and prioritization. Custom fields and templates help standardize work item content, while status and owner changes keep execution feedback close to the original rationale. The workflow is built for teams that plan around a recurring backlog refinement cadence, because items can be revisited as new information arrives.
A key tradeoff is that Airfocus prioritizes product prioritization workflows over deep sprint execution features like granular sub-task nesting and detailed sprint analytics. Teams that already run Jira-based sprint execution and need only a prioritization layer will fit well. Teams that require full requirements traceability links across many artifacts and automated acceptance test linkage may find coverage thinner than dedicated ALM or tracking stacks.
- +Visual prioritization keeps decision context tied to each backlog item
- +Custom fields and stages standardize intake and assessment steps
- +Idea to execution handoff uses the same ranked item record
- +Templates reduce variance across teams running refinement
- –Limited depth for sprint-level execution mechanics versus ALM tools
- –Dependency mapping needs manual modeling for complex cross-team graphs
- –Automation breadth favors workflow steps over large-scale data operations
- –Bulk governance controls can feel light for highly regulated processes
Product management teams
Run weekly refinement with shared prioritization
Faster backlog decisions with traceable rationale
Roadmap and strategy teams
Turn strategy assumptions into ranked work
More consistent roadmap updates
Show 1 more scenario
Cross-functional product ops
Coordinate intake across multiple stakeholders
Less rework during triage
Templates and stages guide how teams submit, review, and update backlog items.
Best for: Fits when product teams need a prioritization-first backlog layer with shared rationale.
Linear
SMBIssue tracker with backlog prioritization, cycles, and roadmap views for product teams.
API and webhooks drive end-to-end issue automation, including creation, updates, and reacting to lifecycle changes.
Linear turns backlog work into issues with a tight workflow that links planning, execution, and delivery status. It supports cross-team visibility through customizable issue states, labels, and team assignments.
Linear’s project views and queryable issue attributes make it practical to manage both sprint work and longer-running initiatives without manual spreadsheet tracking. Its API and webhook surface support automation for issue lifecycle events and external planning tools.
- +Issue-centric workflow with clear status transitions for backlog items
- +Advanced saved views that filter by team, label, and custom attributes
- +Automation hooks via API and webhooks for issue lifecycle events
- +Cross-team roadmap visibility using projects and shared issue views
- –Dependency mapping and requirement traceability require disciplined modeling
- –Backlog refinement queues are less structured than dedicated refinement tools
- –Story point estimation workflows depend on consistent team conventions
- –Granular RBAC and audit log controls are limited versus enterprise governance needs
Best for: Fits when teams want issue-led backlog management with automation and external system integration.
Azure DevOps
enterpriseMicrosoft DevOps suite with Boards for product backlog, sprint backlogs, and work item hierarchy.
Azure Boards work items with process customization, workflow states, and REST API support backlog automation end to end.
Azure DevOps manages product backlogs through work items, hierarchical relationships, and sprint planning workflows tied to code and delivery pipelines. Work item forms support rich fields for acceptance criteria, links to test cases, and revision history that helps track requirement changes across the backlog.
An automation and API surface supports backlog triage, status transitions, and reporting that pulls signals from teams, iterations, and boards. The system also provides administrative control via project collection and security groups, plus audit log coverage for governance workflows.
- +Work items and board states map directly to backlog refinement and sprint planning
- +Acceptance criteria fields and test case linkage support traceability across backlog changes
- +REST API and webhooks enable automated triage, re-ranking, and status transitions
- +Hierarchical linking supports epic to user story and sub-task nesting for granularity
- –Backlog customization requires configuration work across process, fields, and permissions
- –Cross-team backlog views need careful iteration and area path modeling
- –Reporting breadth depends on consistent field usage and linking discipline
- –Bulk restructuring can be slow when links and history volume are high
Best for: Fits when teams need work-item backed product backlogs tied to delivery pipelines and automation.
Productboard
enterpriseProduct management platform with feature backlog, prioritization scoring, and roadmap linking.
Productboard’s roadmap-to-feedback traceability ties each backlog item to customer evidence and strategic goals.
Productboard fits product teams that manage requirements as a portfolio of customer problems, not just Jira-style tickets. It centralizes prioritization inputs across qualitative feedback, strategic context, and roadmap artifacts.
Users can convert insights into structured product requests and route them through configurable workflows. The backlog then stays traceable to the evidence and goals behind each item.
- +Feedback to product request flow keeps prioritization context attached
- +Configurable workflows support consistent intake and review stages
- +Roadmap and release views link strategy decisions to backlog items
- +Admin controls cover workspace governance for scaling intake
- –Deep sprint planning still depends on Jira-style execution tooling
- –Custom workflow logic can require careful setup to avoid drift
- –Reporting focuses more on product outcomes than team-level delivery metrics
- –Bulk backlog operations can lag behind spreadsheets for large imports
Best for: Fits when product teams need evidence-backed prioritization and backlog traceability without building a custom system.
Aha!
enterpriseProduct development suite with backlog prioritization, roadmaps, and release planning.
Aha! roadmap and release context stays attached to backlog items via configurable relationships and workflow transitions, reducing link drift.
Aha! pairs product roadmap management with backlog workflows so teams can move from ideas to epics without losing context. It supports structured story work through configurable fields, relationships, and workflow states that connect backlog items to releases.
Automation and integrations cover status-driven updates and syncing work with external systems through a documented API and webhooks. Governance features include user roles and change visibility so large roadmaps stay consistent across teams.
- +Strong linkage between roadmaps, releases, and backlog items
- +Configurable fields and workflows that map to team stages
- +API and webhooks for bi-directional sync with external tools
- +Role-based permissions help separate product and delivery work
- –Backlog refinement needs careful configuration to stay consistent
- –Dependency and traceability require consistent relationship modeling
- –Advanced scoring and planning views depend on add-on modules
- –Bulk migration and import flows are slower than native board tools
Best for: Fits when roadmap-to-delivery traceability matters, and backlog workflows must stay configurable across teams.
Craft.io
SMBProduct management platform with feature backlog, prioritization, and roadmap storytelling.
Goal-linked prioritization that drives backlog item routing through configurable workflow rules.
Craft.io is a backlog management tool that centers on workflows built around work items, rather than only views and lists. It supports goal-linked prioritization and cross-team backlog organization, which helps connect initiatives to the stories and tasks that implement them.
Craft.io adds automation through rule-based configuration and exposes integrations and APIs for syncing backlog state with other engineering systems. Admin and governance controls focus on permissions for projects and workspaces and on visibility into change activity.
- +Goal-to-work mapping keeps prioritization tied to higher-level outcomes
- +Rule-based automation reduces manual backlog state changes across teams
- +API and integrations support backlog synchronization with external tooling
- +Permission scoping for projects and workspaces supports cross-team access
- –Complex workflows require careful upfront configuration to avoid churn
- –Backlog dependency mapping coverage is limited compared with dedicated planning suites
- –Bulk editing workflows can feel slower for very large backlogs
- –Some advanced refinement reporting needs external exports for deeper analysis
Best for: Fits when teams want goal-linked backlog workflows with automation and API-based integration.
ClickUp
SMBWork management platform with backlog lists, sprint automations, and custom statuses.
Board views and custom field schemas can drive backlog workflows across teams with rule-based state transitions.
ClickUp manages product backlog work with a flexible list and board system that supports epics, stories, and tasks in the same workspace. It handles backlog grooming through configurable statuses, custom fields, and repeatable templates for common acceptance criteria and workflow patterns.
Automation rules can move items between statuses, update fields, and trigger actions based on conditions like assignee or due date. REST and webhook-style integrations let engineering and reporting workflows pull backlog data and keep sprint planning artifacts aligned.
- +Single workspace supports tasks, epics, and cross-team backlog rollups
- +Custom fields and status definitions fit multiple backlog workflows
- +Automation rules update backlog state and fields without manual handoffs
- +API and integrations support reporting and synchronization with other tools
- –Backlog hierarchy can become inconsistent without clear ownership rules
- –Automation rules can be hard to audit when many triggers overlap
- –Advanced board configurations require careful setup to avoid view clutter
- –Dependency mapping is limited compared with tooling focused on portfolio planning
Best for: Fits when teams need one configurable backlog workspace plus automation and API-backed integrations.
Monday.com
SMBWork OS with customizable boards for backlog tracking, sprint views, and automations.
Board automations that react to field changes to drive backlog refinement and sprint handoffs without custom code
Monday.com is commonly used for backlog work management in cross-functional teams that already run projects in the same workspace structure. It supports configurable boards for story hierarchy, sub-task nesting, and dependency mapping, with status-driven workflows for refinement and sprint planning handoffs.
Automation rules and update triggers reduce manual movement of items between stages. Admin and governance controls cover user roles, permissioning, and audit visibility for activity across boards.
- +Configurable boards handle story hierarchy and nested work breakdowns
- +Automation can move items between backlog and sprint stages by status
- +Dependency mapping fields help track blocked work across teams
- +Permissions and audit visibility support controlled access across boards
- –Backlog grooming cadence and backlog aging reporting require board discipline
- –Some backlog refinement workflows need custom columns and rules to stay consistent
- –Complex cross-team portfolio backlog views need careful structure design
- –API-driven integrations can require non-trivial mapping of custom column types
Best for: Fits when teams want low-code backlog workflows with status automation and board-based governance.
Conclusion
After evaluating 10 technology digital media, Jira 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.
How to Choose the Right product backlog software
This buyer's guide covers Jira, ProdPad, Airfocus, Linear, Azure DevOps, Productboard, Aha!, Craft.io, ClickUp, and monday.com for product and delivery teams managing product backlog work.
It focuses on how each tool handles backlog refinement workflows, prioritization context, sprint handoffs, and automation via API and webhooks so teams can pick the right operational model.
Product backlog software that turns refinement, ranking, and delivery handoff into tracked workflows
Product backlog software manages backlog items as system records with statuses, ownership, and work hierarchies so teams can refine work and then plan execution. It reduces manual coordination by standardizing acceptance criteria, routing rules, and sprint-ready transitions.
Jira represents backlog items as issues with epics and sub-tasks plus board-driven sprint planning. ProdPad represents backlog work as product stories with acceptance criteria templates and a shared Definition of Done to keep refinement repeatable.
Backlog system capabilities that determine governance, automation, and integration depth
The right backlog tool needs automation hooks that can move items between workflow stages and keep external systems synchronized. Teams also need a configuration surface that supports consistent refinement, not just static lists.
Jira and Linear both show how API and webhooks connect backlog state changes to other systems. ProdPad, Airfocus, and Productboard show how shared templates and traceability keep decision context attached to each item across the workflow.
Workflow automation that enforces backlog rules at the item lifecycle level
Jira can update fields, move issues between statuses, and trigger notifications based on workflow events. monday.com can run board automations that react to field changes to drive backlog refinement and sprint handoffs without custom code.
Issue and hierarchy modeling for epics, sub-tasks, and sprint-ready breakdowns
Jira supports story hierarchies with epics and sub-tasks so backlog depth maps cleanly to execution planning. Azure DevOps supports hierarchical linking with work item relationships that connect acceptance criteria and test case linkage across the backlog.
Template-driven readiness gates for acceptance criteria and Definition of Done
ProdPad provides acceptance criteria templates and a shared Definition of Done that standardize how stories become sprint-ready. Aha! relies on configurable fields and workflow transitions to keep backlog items connected to releases so refinement stays consistent across teams.
Prioritization engines that keep rationale attached to ranked outcomes
Airfocus ties impact and confidence prioritization to the same item across workflow stages so the rationale stays with the work. Productboard keeps prioritization traceable to customer evidence and strategic goals by linking product requests to roadmap artifacts.
API and webhook surfaces for end-to-end backlog automation and external synchronization
Linear exposes an API and webhook surface that drives end-to-end issue automation for creation, updates, and lifecycle reactions. Azure DevOps provides a documented REST API and webhooks that support backlog automation tied to boards and delivery pipelines.
Goal or roadmap context routing that reduces link drift across backlog layers
Craft.io routes work through goal-linked prioritization and configurable workflow rules so higher-level outcomes guide backlog item routing. Aha! keeps roadmap and release context attached via configurable relationships and workflow transitions to reduce link drift.
Choosing a backlog system based on workflow control and automation surface
First decide which operational model fits backlog work. Some tools center the backlog as a delivery execution system like Jira and Azure DevOps. Others center refinement and prioritization records like ProdPad, Airfocus, and Productboard.
Then validate that the automation and integration surface matches the handoff points where backlog state must change. Linear and Jira are strong when end-to-end lifecycle automation must sync into external planning tools.
Pick the system record model that matches how the team actually executes
If backlog work needs epics, sub-tasks, and board-driven sprint execution, choose Jira or Azure DevOps because both map backlog items into issue or work item workflows. If backlog work needs product-request evidence and decision context, choose Productboard because it routes prioritized requests tied to customer evidence and strategic goals.
Choose the refinement control style that can standardize readiness
If story readiness must be consistent across teams, choose ProdPad because acceptance criteria templates and Definition of Done gates standardize refinement steps. If the team needs a single ranked record carrying rationale from intake through status changes, choose Airfocus so impact and confidence stays attached across stages.
Confirm the automation and integration points where backlog state must change
For automation that must react to lifecycle events and trigger external updates, choose Linear because API and webhooks support issue lifecycle automation. For automation tightly tied to board workflows and delivery pipelines, choose Azure DevOps because REST API and webhooks support backlog automation end to end.
Decide whether backlog context must stay attached via configurable relationships
If roadmap-to-feedback traceability must stay linked without manual reconciliation, choose Productboard or Aha! because both tie roadmap context to backlog items via configurable artifacts or relationships. If outcome goals must drive routing through rules, choose Craft.io because goal-linked prioritization feeds configurable workflow routing.
Select a governance and audit posture that fits scaling reality
If governance must cover user roles, permissions scoping, and audit visibility across boards, choose Azure DevOps or monday.com because both include governance controls tied to project or board activity. If governance is secondary and the priority is flexible workflow stages, choose ProdPad or ClickUp, but enforce process discipline to prevent uneven story quality or inconsistent hierarchy.
Teams that benefit from different product backlog software operating models
Backlog tools work best when they match the primary bottleneck in refinement and planning. Some organizations struggle with delivery alignment, while others struggle with decision context and story readiness.
The tool choice should reflect which backlog layer must stay consistent across cross-team work, such as execution workflows in Jira or readiness templates in ProdPad.
Cross-team delivery teams that need consistent execution workflows
Jira fits because configurable issue workflows and board views support sprint planning and backlog grooming with lifecycle automation that enforces backlog rules. Azure DevOps fits when work items must connect acceptance criteria and test case linkage to code and delivery pipelines.
Product teams that need template-driven story readiness before sprint planning
ProdPad fits because acceptance criteria templates and a shared Definition of Done standardize how stories become sprint-ready. Aha! fits when roadmap and release context must stay attached via configurable relationships and workflow transitions.
Product teams that need prioritization-first backlog records with attached rationale
Airfocus fits because impact and confidence prioritization stays attached to the same item across workflow stages. Productboard fits because backlog items stay traceable to customer evidence and strategic goals through roadmap-to-feedback linking.
Engineering-aligned teams that need issue lifecycle automation through API and webhooks
Linear fits because API and webhooks drive end-to-end issue automation for creation, updates, and lifecycle reactions. ClickUp fits when backlog and sprint execution are managed inside one customizable workspace using board views, custom field schemas, and status automations.
Cross-functional teams that want low-code board governance and status-driven refinement
monday.com fits when backlog workflows must be built with configurable boards, status automation, and audit visibility across boards. Craft.io fits when goal-linked prioritization must drive backlog item routing through configurable workflow rules.
Buyer pitfalls that create backlog drift, inconsistent refinement, or weak automation control
Many teams fail when the tool is configured without matching operational discipline. Others fail when backlog dependencies and traceability are treated as an afterthought.
These mistakes show up repeatedly across Jira-style execution workflows, product template workflows, and board automation setups.
Using flexible templates without enforcing consistent usage
ProdPad can standardize story readiness with acceptance criteria templates and Definition of Done, but uneven template usage creates uneven story quality. Set a process rule for template adoption and monitor readiness fields using board filters in ClickUp.
Under-modeling dependencies and traceability in complex cross-team programs
Linear and Jira both require disciplined modeling for dependency mapping and requirement traceability when graphs get complex. Azure DevOps can support traceability through work item links and acceptance criteria fields, but it still depends on consistent linking and field usage.
Treating workflow automation as harmless until lifecycle rules multiply
monday.com and ClickUp can automate backlog refinement with board rules, but overlapping triggers can make automation hard to audit. Jira also supports automation for field updates and status moves, but workflow and field configuration can become complex across many projects.
Building a backlog workspace without a clear ownership model for hierarchy
ClickUp can mix epics, stories, and tasks in one workspace, but backlog hierarchy can become inconsistent without clear ownership rules. monday.com supports nested work breakdowns in configurable boards, but backlog grooming cadence depends on board discipline.
Expecting sprint mechanics and heavy execution reporting from a prioritization-first tool
Airfocus centers impact and confidence prioritization and carries ranked outcomes through workflow stages, but it has limited depth for sprint-level execution mechanics versus ALM tools. Productboard and Aha! can connect roadmaps to backlog items, but deep sprint planning still depends on Jira-style execution tooling.
How We Selected and Ranked These Tools
We evaluated Jira, ProdPad, Airfocus, Linear, Azure DevOps, Productboard, Aha!, Craft.io, ClickUp, and Monday.com on features coverage, ease of use, and value, then used those signals to produce an overall rating where features carried the most weight and ease of use and value each contributed equally. Each score reflects the presence and maturity of backlog-specific mechanisms such as workflow automation, lifecycle triggers, API and webhook surfaces, and structured backlog workflows tied to refinement and execution.
Jira separated from lower-ranked options because configurable issue workflows plus automation triggers enforce backlog rules at the item lifecycle level, and that strength ties directly to higher features coverage and higher ease of use for teams that want sprint planning and backlog grooming driven by board views and integration-friendly issue state changes.
Frequently Asked Questions About product backlog software
What integration patterns matter for syncing backlog data with delivery tools?
How do acceptance criteria templates and Definition of Done change backlog refinement?
How is backlog item hierarchy represented across Jira, Aha!, and Azure DevOps?
When should teams pick prioritization-first backlog tools like Airfocus or Airfocus over issue-led systems?
What breaks if a team needs roadmap-to-backlog traceability without link drift?
Where does governance and audit visibility differ between Azure DevOps, Monday.com, and Jira?
How should teams handle SSO and role-based access for cross-team backlog visibility?
How does data migration usually work when moving backlog items into Jira, ClickUp, or Monday.com?
What technical requirement is easiest to miss when automating backlog workflows?
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
Technology Digital Media alternatives
See side-by-side comparisons of technology digital media tools and pick the right one for your stack.
Compare technology digital media tools→