GITNUXSOFTWARE ADVICE
Digital Transformation In IndustryTop 10 Best New Technology Software of 2026
Ranked roundup of top new technology software tools for technical buyers, with comparison notes on Snowflake, Confluent, MuleSoft Anypoint.
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
Gartner Hype Cycle is the best fit for leadership that needs a repeatable maturity view to time evaluations and budget decisions, while Toolify is the quickest way for teams to shortlist early on, and CB Insights works best for strategy teams doing ongoing market monitoring.
Editor’s top 3 picks
Three quick recommendations before you dive into the full comparison below — each one leads on a different dimension.
Gartner Hype Cycle
Technology maturity charting that ties expectations, trough risk, and adoption progress into planning sequences.
Built for fits when leadership needs a repeatable maturity view to time evaluations and budget decisions..
Toolify
Editor pickUse-case tagged catalog pages for narrowing tools to workflow needs before technical validation.
Built for fits when teams need fast, task-oriented tool discovery for early-stage evaluation and shortlisting..
CB Insights
Editor pickTheme and company signal tracking that ties emerging technology topics to funding and competitive movement.
Built for fits when strategy and research teams need ongoing technology market monitoring without building data pipelines..
Related reading
Comparison Table
Gartner Hype Cycle
enterpriseResearch and analysis platform that tracks emerging technology categories and software trends.
Technology maturity charting that ties expectations, trough risk, and adoption progress into planning sequences.
Gartner Hype Cycle is built around lifecycle stages that support technology planning decisions and stakeholder alignment. It links technology directionality to practical adoption timing so teams can prioritize evaluation work and avoid premature scaling. The output is editorially standardized across many technology categories, which helps compare expectations versus adoption readiness across the portfolio.
A tradeoff appears when operational teams need system-level integration details, because Hype Cycle is a market research artifact rather than an API-driven product design. It fits best when executives and architecture councils need a shared model for sequencing pilots, procurement reviews, and governance checkpoints before implementation starts.
- +Lifecycle stages and maturity signals support consistent portfolio comparisons
- +Editorial structure improves cross-team alignment on evaluation timing
- +Directional trajectories help prioritize pilot sequencing and governance reviews
- –Lacks API, automation hooks, and machine-readable integration surfaces
- –Does not provide execution guidance for deployment, governance, or implementation details
CTO and technology strategy teams
Sequence innovation themes across quarters
Fewer premature rollouts
Enterprise architects
Align platform roadmaps to maturity
Clearer roadmap ordering
Show 2 more scenarios
Innovation portfolio managers
Time pilots and selection criteria
More disciplined selection
Use Hype Cycle directionality to set pilot timing and reassessment checkpoints.
Procurement and governance groups
Review vendor risk and readiness
Lower adoption variance
Reference maturity stages to structure approvals and reduce risk of early adoption.
Best for: Fits when leadership needs a repeatable maturity view to time evaluations and budget decisions.
More related reading
Toolify
AI-firstAI software directory that aggregates active tools for writing, image generation, coding, and automation.
Use-case tagged catalog pages for narrowing tools to workflow needs before technical validation.
Toolify supports fast evaluation by aggregating many tool entries into a single browsing experience with task-oriented page structure. Tool pages typically include descriptive summaries and category tags that reduce time spent moving between vendor sites. The tradeoff is that Toolify does not provide a native automation surface such as webhooks, an API gateway, or a programmable workflow engine. Shortlisting works well when teams need a starting set of candidates rather than implementation-ready integration specs.
A clear usage situation is early-stage research when product, IT, or operations teams want to shortlist tools for a defined workflow. A second situation is internal enablement when staff need a shared source of candidate links and notes for review meetings. For teams that require API-based governance, event-driven integration, or environment provisioning, Toolify often ends at discovery and still requires vendor technical validation.
When a team already has a shortlist and needs implementation details, Toolify functions as an index and not as an engineering control plane. Vendor documentation, SDK references, and contract-level specs remain necessary inputs for production readiness decisions.
- +Task-based search and catalog browsing for rapid shortlist creation
- +Consistent page structure with use-case labeling across many entries
- +Curated collections reduce time spent finding alternatives for a workflow
- +Quick cross-checking of multiple vendors without switching tools repeatedly
- –No documented automation surface for integrating tool recommendations into workflows
- –Limited depth on integration contracts like REST or webhook event schemas
- –Governance details like RBAC or audit logs are not a native concern
- –Implementation artifacts like deployment runbooks and provisioning steps are not provided
Product managers
Shortlist tools for a new workflow
Shortlists prepared for review cycles
IT procurement teams
Compare vendor options quickly
Fewer RFI follow-ups
Show 2 more scenarios
Operations leaders
Find automation candidates for recurring tasks
Faster candidate identification
Teams browse catalog groupings tied to operational use cases.
Solution architects
Triage candidates before integration design
Design time focused on fewer options
Architects use Toolify as an index, then validate APIs and deployment requirements elsewhere.
Best for: Fits when teams need fast, task-oriented tool discovery for early-stage evaluation and shortlisting.
CB Insights
enterpriseMarket intelligence platform that tracks technology vendors, startups, and software market shifts.
Theme and company signal tracking that ties emerging technology topics to funding and competitive movement.
CB Insights delivers an analyst workflow built around technology themes, venture and market signals, and competitor tracking across large datasets. The platform supports repeatable research through saved queries, company lists, and recurring monitoring so teams can maintain continuity across investigations. It is best when the buying team already needs market context to inform product planning, partnering, or competitive strategy.
A tradeoff appears in automation depth because CB Insights is not positioned as an API-first data backbone for operational systems. Results can be limited by the granularity of its intelligence coverage and by how quickly analysts can translate research findings into engineering actions. A strong usage situation is an investor relations team or product strategy team monitoring a specific technology theme for new entrants and funding momentum.
- +Structured market and company signals for repeatable investigations
- +Saved lists and monitoring to reduce analyst rework
- +Theme-based views that connect technology shifts to companies
- +Competitive tracking workflow supports ongoing portfolio context
- –API and automation surface is not designed for systems integration
- –Automation depends on research workflow conventions, not event pipelines
Product strategy teams
Track a technology theme for entrants
Faster agenda setting
Competitive intelligence analysts
Monitor rivals across company cohorts
Earlier competitive alerts
Show 2 more scenarios
Investment teams
Assess emerging technology momentum
More focused diligence
Compare companies and signals within an emerging theme to prioritize diligence targets.
Partnership teams
Find partnering candidates in segments
Higher quality outreach
Use curated intelligence signals to shortlist companies aligned to market and technology movement.
Best for: Fits when strategy and research teams need ongoing technology market monitoring without building data pipelines.
Datadog
observabilityDatadog provides infrastructure monitoring, logs, distributed tracing, security monitoring, and APM.
Real-time trace search linked to monitor incidents and log context inside the same operational workflow.
Datadog brings a unified observability workflow across metrics, logs, and distributed traces, using agents and managed integrations to reduce hand wiring. Live dashboards, SLO tracking, and alert routing connect telemetry back to operational context without exporting to separate stacks.
Datadog also offers a high-surface API for monitors, events, dashboards, and synthetic checks, plus automation via webhooks and event-driven workflows. Its control plane supports role-based access and audit logging to govern multi-team usage of data and alerting.
- +Agent-based ingestion supports fast telemetry coverage across hosts and containers
- +Monitor and SLO workflows tie alerts to trace and log context
- +API exposes monitors, dashboards, and synthetic tests for automation
- +RBAC and audit logs help govern shared observability data
- –Wide integration surface increases configuration sprawl across teams
- –Deep custom parsing for logs can be labor-intensive at scale
- –Maintaining high-cardinality tagging strategies requires disciplined practices
- –Cross-environment setup often needs careful index and retention alignment
Best for: Fits when platform and app teams need end-to-end observability automation with governed access across shared services.
Crossplane
API-firstKubernetes-native control plane for composing and provisioning cloud infrastructure.
Provider packages expose external systems as Kubernetes custom resources with controller reconciliation for continuous drift handling.
Crossplane turns Kubernetes into an infrastructure control plane by using custom resources to drive external resource provisioning. It integrates with cloud and SaaS APIs through provider packages and reconciler loops, so desired state stays continuously enforced.
Crossplane adds GitOps-friendly workflows by pairing declarative manifests with controller behavior, which supports repeatable environments. Governance is handled through Kubernetes-native RBAC and resource scoping patterns that constrain who can create and manage infrastructure objects.
- +Uses Kubernetes controllers to reconcile external resources continuously
- +Provider packages standardize API integration behind Kubernetes CRDs
- +RBAC applies directly to infrastructure objects via Kubernetes permissions
- +GitOps workflows map cleanly to declarative manifests and controller reconciliation
- –Requires Kubernetes operations knowledge to run and troubleshoot controllers
- –Custom resource lifecycles can be complex to model for every external system
- –Correctness depends on provider behavior and reconciliation semantics per resource kind
- –Deep audit and change attribution may require additional observability plumbing
Best for: Fits when platform teams want declarative infrastructure provisioning managed through Kubernetes controllers.
Pulumi
infrastructure-as-codePulumi provisions cloud infrastructure with general-purpose programming languages and reusable components.
Pulumi Automation API enables headless previews and deployments driven by external workflows, not just CLI usage.
Pulumi fits teams that need infrastructure provisioning expressed in general-purpose code rather than a fixed declarative DSL. It supports API-driven cloud resource management with an execution engine that tracks changes and produces plans before apply.
Pulumi integrates with policy workflows via Pulumi Automation API, which can run previews and deployments from CI systems. It also provides extensibility through custom components and packages so teams can standardize modules across providers and environments.
- +Automation API lets CI and apps run previews and deployments programmatically
- +General-purpose language support improves reuse of logic across infrastructure modules
- +Custom components package opinionated infrastructure patterns for multiple teams
- +State and diffing model supports repeatable planning before changes are applied
- –Team onboarding cost rises with language runtime and Pulumi program structure
- –Cross-provider resource modeling can still require provider-specific escape hatches
- –Large dependency graphs can slow previews and require careful factoring
- –Policy enforcement typically depends on external tooling and repo workflow integration
Best for: Fits when teams want code-based infrastructure provisioning with CI automation and reusable modules across cloud providers.
Argo CD
API-firstGitOps continuous delivery controller for Kubernetes applications.
Application controller continuously reconciles Git state to cluster state with health evaluation for sync gating.
Argo CD provides GitOps continuous delivery by reconciling a desired cluster state from a Git repository to Kubernetes resources. It adds an application abstraction that lets teams group multiple manifests under a single sync lifecycle with automated drift detection.
Extensibility comes through custom resource kinds, configuration management via Helm and Kustomize, and a documented API surface for automation and integrations. RBAC and audit visibility are supported through Kubernetes auth and Argo CD server features for controlled operations.
- +Git-driven reconciliation with automated drift detection and controlled sync policies
- +Application abstraction groups resources and sync lifecycles across clusters
- +Works with Helm and Kustomize for templated and layered configuration
- +API access supports programmatic app management and sync orchestration
- –Multi-application setups can become complex without strict repo and sync conventions
- –Advanced rollout behavior needs careful configuration across sync and health checks
- –Operational tuning of controllers is required for large fleets to avoid slow sync feedback
- –RBAC design requires deliberate mapping of repo and namespace ownership
Best for: Fits when teams want GitOps delivery for Kubernetes with automated sync control and API-driven operations.
Temporal
workflow orchestrationTemporal runs durable workflows that coordinate long-running, distributed, and failure-prone processes.
Workflow state durability with deterministic replays and event-driven execution for long-running, failure-tolerant business processes.
Temporal orchestrates distributed work with durable workflow executions instead of relying on background jobs that can be lost or retried unpredictably. Workflow code runs with strong retry and compensation semantics through Temporal’s task queues and stateful execution model.
An API-first integration surface lets services start, signal, query, and cancel long-running workflows with consistent contracts. Operators gain control via namespaces, task queue partitioning, and observability hooks that emit traces and logs for workflow and activity execution.
- +Durable workflow executions preserve state across failures and restarts
- +Signal, query, and cancel APIs support interactive long-running business processes
- +Task queues provide controlled worker scaling and workload partitioning
- +Tracing and structured logs map workflow decisions to activity outcomes
- –Workflow code model has a steeper learning curve than stateless job systems
- –Operational overhead increases with worker concurrency tuning and task queue design
- –Complex cross-service orchestration can grow large without clear workflow boundaries
- –Local-only development needs additional setup for a running Temporal server
Best for: Fits when microservices need durable orchestration with interactive signals and reliable retries across failures.
LaunchDarkly
release managementLaunchDarkly manages feature flags, progressive delivery, experimentation, and release controls.
Flag decision events include a full evaluation context for downstream analytics and operational debugging.
LaunchDarkly delivers an API-driven feature flag service that controls rollout behavior in real time. Flags are evaluated in client and server SDKs so applications can decide behavior per user, account, or environment without redeploys.
Teams configure rules for targeting, gradual releases, and experimentation-style cohorts while receiving event streaming and audit visibility for flag changes. Governance features include RBAC and an audit log so changes can be reviewed across environments.
- +API-first flag evaluation in app SDKs supports runtime behavior changes
- +Granular targeting rules enable per-user and per-segment rollout control
- +Event streaming exports flag decisions for analytics and monitoring pipelines
- +RBAC and audit log support controlled flag administration
- –Flag modeling can become complex with many interdependent rules
- –Best results require consistent client SDK integration across services
- –High-volume decision streams can demand careful observability plumbing
- –Environment sprawl increases review overhead for rule changes
Best for: Fits when distributed teams need controlled, runtime feature rollouts with governance.
Sentry
application monitoringSentry monitors application errors, performance transactions, releases, and distributed traces.
Issue grouping with release association and regression view across projects and environments.
Sentry fits teams that need production error visibility across web, mobile, and backend services with minimal friction. It collects exceptions and performance signals, then links them to releases so regressions are traceable over time.
Data routing supports multiple environments and projects, which helps separate staging from production. Alerting and issue workflows connect directly to owning teams so error triage stays actionable.
- +Release-aware error grouping ties regressions to deployments
- +Multiple SDKs cover common stacks for exceptions and transactions
- +Source context shows stack frames and surrounding code at fault
- +Issue workflows connect alert noise to triage ownership
- –High-volume ingestion can require careful sampling and routing setup
- –Advanced environment and alerting rules take governance discipline
- –Correlating deep traces requires additional instrumentation beyond baseline errors
- –Large multi-org setups can feel operationally heavy without conventions
Best for: Fits when engineering teams want fast exception triage plus release-linked regression tracking across services.
Conclusion
After evaluating 10 digital transformation in industry, Gartner Hype Cycle 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 new technology software
New technology software buying starts with whether the tool provides a repeatable mechanism for decision support, integration automation, or controlled execution inside existing engineering systems. This guide covers Gartner Hype Cycle, Toolify, CB Insights, Datadog, Crossplane, Pulumi, Argo CD, Temporal, LaunchDarkly, and Sentry.
The reviews focus on how each option surfaces machine-actionable interfaces such as automation APIs, controller-driven provisioning, Git reconciliation loops, and runtime event context. That emphasis matters because tools can look similar on usability while differing sharply in integration depth, operational governance controls, and the ability to connect outcomes to pipelines and services.
New technology software for integration-first evaluation, provisioning, rollout, and operations control
New technology software is used to turn emerging-technology information and execution workflows into managed signals, repeatable planning sequences, or automated runtime changes. Gartner Hype Cycle fits when leadership needs a structured maturity view that ties technology expectations and adoption timing into evaluation order.
For teams that need direct integration into systems and delivery machinery, tools like Datadog and LaunchDarkly shift from research or dashboards to operational workflows. Datadog links trace search to monitor incidents and log context for incident-linked automation, while LaunchDarkly provides API-first flag evaluation context for governed runtime feature rollouts.
Machine-actionable decision, integration automation, and governed execution
This category separates research and dashboards from tools that drive execution inside engineering systems. Machine-actionable interfaces like automation APIs, controller reconciliation loops, and runtime evaluation context determine whether teams can wire signals into pipelines and operational controls.
Gated execution matters because multiple teams share services and rollout responsibilities. Datadog links trace search to monitor workflows, while LaunchDarkly delivers API-first flag evaluation context for runtime feature changes.
Automation and integration surface for programmatic workflows
Pulumi includes an Automation API that enables headless previews and deployments driven by external workflows rather than CLI usage. Gartner Hype Cycle supports planning sequences for maturity expectations but does not provide API or machine-readable integration hooks for systems orchestration.
Controller-driven reconciliation and drift handling
Crossplane exposes provider packages as Kubernetes custom resources and uses controller reconciliation for continuous drift handling. Argo CD runs an application controller that reconciles Git state to cluster state with health evaluation for sync gating.
Runtime event context tied to operational workflows
Datadog links trace search to monitor incidents and log context so operational teams can automate around the same investigation thread. LaunchDarkly includes flag decision events with a full evaluation context for downstream analytics and operational debugging.
Durable orchestration for long-running, failure-tolerant processes
Temporal provides workflow state durability with deterministic replays for long-running failure-tolerant processes. Sentry focuses on issue grouping with release association and regression views across projects and environments rather than durable business process orchestration.
Structured decision support that sequences technology adoption risk
Gartner Hype Cycle ties expectations, trough risk, and adoption progress into planning sequences for leadership evaluation order. Toolify organizes use-case tagged catalog pages for shortlisting rather than maturity-sequenced planning artifacts.
Governance-grade targeting and rollout control
LaunchDarkly provides granular targeting rules for controlled runtime rollouts across users and segments. Argo CD adds sync policies with health evaluation so rollout behavior follows Git state and cluster health gates.
Select by execution model, integration endpoints, and operational governance fit
Choose the execution model first because each tool optimizes a different control loop. Gartner Hype Cycle and CB Insights prioritize decision support and ongoing market signals, while Argo CD, Crossplane, and Pulumi drive continuous infrastructure and delivery reconciliation.
Then validate the automation endpoint and governance depth that match current engineering machinery. Datadog and LaunchDarkly connect runtime context to operations and app behavior changes, while Temporal turns retries and long-running state into deterministic workflow execution that engineering teams can build into microservices.
Pick the control loop: planning timeline, delivery reconciliation, or runtime decision
Use Gartner Hype Cycle when leadership needs a repeatable maturity view that maps evaluation timing to lifecycle stages. Use Argo CD when continuous Git state reconciliation to cluster state with health-based sync gating is the delivery control loop.
Choose the integration philosophy: headless automation, controller reconciliation, or research signal feeds
Select Pulumi when CI and external automation systems need headless previews and deployments through the Automation API. Select CB Insights when strategy teams need theme and company signal tracking that fits ongoing monitoring without building event pipelines for systems integration.
Match integration endpoints to your operational workflow
Choose Datadog when operational execution needs trace search linked to monitor incidents and log context within the same workflow. Choose LaunchDarkly when application teams need API-first flag evaluation context embedded into runtime decision paths for governed rollouts.
Decide what must survive failures and replays
Pick Temporal when long-running business processes require durable workflow execution with deterministic replays and interactive signals. Pick Sentry when the primary requirement is fast exception triage with release-linked regression tracking rather than durable orchestration.
Validate operational overhead and specialization tradeoffs
Expect Crossplane to require Kubernetes operations skills to run and troubleshoot controllers and to model custom resource lifecycles across external systems. Expect Temporal to require worker concurrency tuning and task queue design to manage operational overhead.
Check rollout and governance mechanics end-to-end
For progressive delivery control tied to infrastructure state, evaluate Argo CD sync policies and health evaluation gates. For runtime behavior governance tied to user targeting, evaluate LaunchDarkly targeting rules and how consistently client SDKs feed the same evaluation context.
Who should use which new technology software mechanisms
Different teams need different control loops. Delivery and platform teams typically evaluate reconciliation and provisioning tools, while application and operations teams evaluate runtime context and incident workflows.
Strategy teams evaluate decision support and market monitoring mechanisms, and engineering teams evaluate durable execution frameworks and operational triage systems that tie regressions to releases.
Platform and Kubernetes operations teams
Crossplane standardizes external system integration behind Kubernetes custom resources with controller reconciliation and continuous drift handling. Argo CD groups resources into applications and enforces Git-driven sync control with health evaluation.
CI and infrastructure automation teams
Pulumi Automation API supports programmatic headless previews and deployments that external workflows can trigger. Gartner Hype Cycle supports planning sequences for maturity timing but does not provide API integration surfaces to connect those plans to execution.
Distributed product and engineering teams running runtime rollouts
LaunchDarkly delivers API-first flag evaluation context and granular targeting rules that help govern per-user and per-segment runtime behavior changes. Datadog links trace search to monitor incidents and log context for incident-linked operational automation.
Engineering teams building long-running business processes
Temporal provides durable workflow executions with deterministic replays and event-driven execution for failure-tolerant business processes. Sentry provides exception triage and release regression views but does not provide deterministic workflow state and replay semantics.
Common failure modes when teams select new technology software
Teams often fail by selecting tools that do not match the execution loop they need. Others underestimate integration sprawl or operational modeling complexity that emerges once multiple services and teams share the same control plane.
The most frequent mistakes involve assuming research signal tools can replace automation endpoints, or assuming operational observability can substitute for durable orchestration and replayable workflow semantics.
Assuming Gartner Hype Cycle can replace an automation API for connecting evaluation to pipeline execution
Use Gartner Hype Cycle for planning sequences that tie lifecycle expectations to adoption timing. Use Pulumi Automation API when the requirement is headless previews and deployments triggered by external workflows.
Buying a controller-based reconciliation tool without committing to Kubernetes operations practices
Crossplane relies on provider packages implemented as Kubernetes custom resources and continuous controller reconciliation. Argo CD also depends on Git conventions and sync policy configuration to avoid complex multi-application setups.
Treating observability integration breadth as a substitute for runtime rollout governance
Datadog can tie trace search to monitor and log context for operational automation, but it does not provide runtime flag evaluation context. LaunchDarkly models flag evaluation events with full evaluation context and supports granular targeting rules for controlled rollouts.
Choosing a triage-first exception platform when business processes require deterministic replay semantics
Sentry groups issues with release association and regression views for fast exception triage across projects and environments. Temporal provides durable workflow state with deterministic replays and interactive signals for long-running processes.
Overloading error ingestion without planning sampling and routing governance
Sentry can require careful sampling and routing setup when ingestion volume is high. Datadog can add configuration sprawl when teams enable many integrations, so telemetry scope planning reduces operational overhead.
How We Selected and Ranked These Tools
We evaluated each tool by features first because the category separates research and dashboards from machine-actionable mechanisms and governed execution loops. Ease and value were weighed next to capture whether teams can operationalize the tool without creating high ongoing configuration overhead.
Features and ease were both critical for controller-driven tools like Argo CD and Crossplane, where sync gating and drift handling require careful operational setup. Gartner Hype Cycle ranked highest because its technology maturity charting ties expectations, trough risk, and adoption progress into planning sequences that leadership teams can repeat across portfolios, even though it lacks an API or automation hooks for systems integration.
Frequently Asked Questions About new technology software
How do Datadog and Sentry connect telemetry to incidents when teams use multiple services?
Which tool is built for durable long-running workflow execution with retries, signals, and queries?
When teams need GitOps delivery for Kubernetes resources, how does Argo CD handle drift and sync control?
How do Crossplane and Pulumi differ when provisioning external systems through Kubernetes and CI pipelines?
What breaks if a governance model lacks RBAC and audit log coverage in Datadog or LaunchDarkly?
How does LaunchDarkly implement runtime rollout control without redeploying applications?
When data must be moved into a governed analytics or integration platform, which tool provides a reference maturity track for timing risk and adoption?
How do SSO and directory sync expectations shape Crossplane versus Argo CD administration patterns?
Which tool is designed to monitor and recommend based on use-case labeling rather than building integration endpoints?
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
Digital Transformation In Industry alternatives
See side-by-side comparisons of digital transformation in industry tools and pick the right one for your stack.
Compare digital transformation in industry tools→