GITNUXSOFTWARE ADVICE
Business FinanceTop 10 Best Ready Software of 2026
Top 10 ready software tools ranked with evaluation criteria for builders and operations teams, including Appsmith, Quickbase, and Odoo.
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
Appsmith is the best fit when teams need to rapidly reshape internal apps tied to existing databases and operational APIs, while Quickbase is a strong alternative for operations that want configurable, permissioned apps with reporting and integrations.
Editor’s top 3 picks
Three quick recommendations before you dive into the full comparison below — each one leads on a different dimension.
Appsmith
Event-driven UI workflows that trigger configured backend queries and requests in a single app.
Built for fits when teams need fast internal app changes tied to existing operational APIs..
Quickbase
Editor pickRelational data model with linked records plus API-driven access preserves permission-aware automation across integrated systems.
Built for fits when operations teams need configurable apps with enforced access, reporting, and integrations..
Odoo
Editor pickCross-module procurement, inventory, and invoicing flows connected to shared accounting documents and valuations.
Built for fits when a single integrated suite must coordinate sales, finance, and fulfillment processes..
Related reading
Comparison Table
Ready software tools pre-configure data models, UI scaffolding, and workflow primitives so teams can move from idea to deployable apps with fewer build cycles. This list ranks platforms for integration coverage, configuration depth, and governance features like RBAC and audit logging, helping analysts compare delivery tradeoffs beyond marketing claims.
Appsmith
API-firstAn open-source platform for building internal applications connected to databases and APIs.
Event-driven UI workflows that trigger configured backend queries and requests in a single app.
Appsmith’s core strength is tying frontend interactions to backend actions through configurable queries and request flows, so a user click can trigger data reads and writes. Its reusable pages, components, and resources support consistent patterns across multiple apps, which reduces duplicated logic for teams shipping many admin screens. The tradeoff is that very complex domain logic often still needs external services, because Appsmith can orchestrate calls but is not a full application runtime. This tool fits teams that need frequent UI changes tied to operational APIs, such as internal admin portals and workflow consoles.
A governance tradeoff appears when apps proliferate, because fine-grained access control and review processes require disciplined project organization. Appsmith works well when a central team maintains shared resources and downstream teams contribute page-level changes. A common usage situation is building a tool that searches records, shows results in tables, and triggers a series of API calls for approval or provisioning actions. In that setup, Appsmith reduces handoff latency compared with custom frontends that require rebuilds for each workflow tweak.
- +Directly binds UI events to API and database requests
- +Reusable components and shared logic reduce duplication
- +Self-hosting option supports controlled network environments
- +Extensibility via scripting and custom request configuration
- –Complex business rules may need external services
- –Governance needs disciplined app and resource organization
- –Some advanced integrations rely on connector and API patterns
- –Large projects require careful naming and module boundaries
Operations engineering teams
Create approval consoles for ticket workflows
Fewer manual steps and faster turnaround
Data engineering teams
Build admin dashboards for ETL control
Reduced runbook reliance
Show 2 more scenarios
IT platform teams
Provision access via internal tooling
Consistent provisioning runs
Forms validate inputs then trigger API calls that manage entitlements and audit trails.
Support teams
Build customer lookup and actions app
Quicker case resolution
Search results feed dynamic components and request flows for support operations.
Best for: Fits when teams need fast internal app changes tied to existing operational APIs.
More related reading
Quickbase
enterpriseA no-code application platform for managing operational processes and structured business data.
Relational data model with linked records plus API-driven access preserves permission-aware automation across integrated systems.
Quickbase fits teams that need a prepared application layer for internal operations without starting from scratch on custom UI. Its data modeling lets apps define multiple tables, link records across tables, and enforce field-level constraints through validations. Automation supports multi-step business rules triggered by record changes, and reporting updates as underlying records change. The API surface allows external systems to create, update, and query records while preserving Quickbase’s permission checks.
A key tradeoff is that complex user interface customization stays within Quickbase’s component model, which can limit highly bespoke front ends. A common usage situation is scaling a shared intake workflow across departments, where new forms and approval steps are added over time while keeping one shared data backbone.
- +Relational record linking supports cross-table operational workflows
- +Automation triggers run on record lifecycle events without custom code
- +REST API enables system-to-system record synchronization
- +Granular permissions control visibility across apps and records
- –UI customization is constrained by Quickbase components
- –Advanced automations require careful governance to avoid workflow loops
- –External integrations often need custom mapping between data structures
- –Large app portfolios can create admin overhead for permissions and templates
Operations and program teams
Run intake to approval workflows
Faster cycle times
IT automation and integration teams
Sync work items with external systems
Reduced manual rework
Show 2 more scenarios
Revenue operations teams
Track pipeline process steps
Cleaner operational visibility
Model deal stages as linked tables and report on throughput by owners.
Compliance and risk teams
Manage audit evidence workflows
More consistent evidence collection
Control access to sensitive records and trigger follow-up tasks as fields change.
Best for: Fits when operations teams need configurable apps with enforced access, reporting, and integrations.
Odoo
SMBAn integrated business suite covering CRM, accounting, inventory, manufacturing, and other operations.
Cross-module procurement, inventory, and invoicing flows connected to shared accounting documents and valuations.
Odoo is a turnkey-style suite where core operations share common objects like partners, products, invoices, and stock moves, which reduces rework when processes cross departments. Workflow automation is built into many app screens with configurable rules, status-driven actions, and automated document generation. Integrations are handled with REST API access and application-to-application hooks, plus add-on modules for common external systems.
A key tradeoff is that deeper configuration can require governance so module interactions do not conflict across accounting, taxation, inventory valuation, and order fulfillment. Odoo fits teams that want one integrated process footprint and are willing to manage change as they enable additional modules and automation rules.
- +Integrated business objects across CRM, accounting, and inventory workflows
- +Server-side workflow rules automate approvals, document creation, and routing
- +Custom module development supports domain-specific processes and screens
- +API access enables external systems to read and write operational records
- –Module-heavy implementations can create configuration dependencies across processes
- –Some advanced workflows need custom code for edge-case logic
- –Data hygiene is required to keep partner, product, and tax records consistent
- –Multi-team rollouts often need RBAC tuning and audit discipline
Manufacturing operations teams
Link production orders to inventory and invoices
Fewer manual handoffs
Revenue operations teams
Turn leads into invoiced orders
Shorter order-to-cash cycle
Show 2 more scenarios
Accounting teams
Standardize invoice posting and reconciliation
More consistent financial records
Use consistent journal generation tied to sales and purchase documents across modules.
System integrators
Sync CRM and ERP data with external tools
Lower integration glue work
Connect external services through Odoo’s API while mapping operational objects and states.
Best for: Fits when a single integrated suite must coordinate sales, finance, and fulfillment processes.
OutSystems
enterpriseAn enterprise low-code platform for developing, integrating, and managing business applications.
Built-in application lifecycle management that supports promotion, versioning, and controlled rollout across environments.
OutSystems is a low-code application platform used to build and run business apps with a full lifecycle tooling for development, deployment, and operations. Visual development, server-side logic, and UI generation come together inside a single environment that supports API-first integration with REST services.
OutSystems also provides environment management for promoting changes across dev, test, and production, with role-based access controls and audit visibility for governance. Automation and extensibility options cover integration hooks, reusable components, and scripted workflows for release and operations tasks.
- +End-to-end app lifecycle features for build, release, and production operations
- +API integration support with REST endpoints and published service consumption
- +Environment promotion controls for moving changes across dev, test, and production
- +Reusable component model for faster delivery of consistent app patterns
- –Complex projects need strong architecture discipline to avoid model sprawl
- –Advanced governance depends on correct RBAC and release process setup
- –Deep UI customization can add overhead versus fully custom code approaches
- –Integration-heavy apps may require platform-specific performance tuning
Best for: Fits when teams need fast delivery of enterprise workflows with managed release governance and API integration.
Mendix
enterpriseA low-code platform for building business applications across web, mobile, and connected systems.
Expose app capabilities through generated REST APIs backed by microflow logic for consistent business rules across UI and integrations.
Mendix builds web and mobile business applications from visual models and reusable components. It offers a documented API surface through REST endpoints, microflows, and data access that supports system integration.
The platform includes role-based access controls, environment management for dev through production, and audit-friendly operational settings for app governance. Automation is handled through scheduled jobs, workflow-like microflow logic, and integration actions that can call external services via web requests.
- +Visual modeling for microflows and pages with predictable runtime behavior
- +REST endpoint generation tied to exposed actions and business logic
- +RBAC and environment separation support basic governance across deployments
- +Extensibility via custom modules and connector patterns for integrations
- –Large apps can require architectural discipline to keep microflows maintainable
- –Advanced integrations often need custom connector or module work
- –Workflow complexity can fragment logic between pages, microflows, and server actions
- –Local development and test data setup can take time in multi-environment teams
Best for: Fits when teams need configurable low-code app delivery with strong API-driven integration and RBAC governance.
Kissflow
enterpriseA business process platform for workflows, forms, applications, and operational approvals.
Kissflow workflow designer combines forms, routing, and SLA behavior in one configurable process model.
Kissflow is a configurable workflow and process management solution built for business teams that need faster approvals, intake, and tracking without building every workflow from code. It supports model-driven workflow design, task routing, SLAs, forms, and role-based access to keep process execution consistent across teams.
Administrators can configure process templates, manage worklists, and control who can view or act on process data. Kissflow also exposes integration options through REST APIs and webhooks for syncing work items with external systems.
- +Workflow templates speed up rollout across business units
- +Built-in approval routing supports complex roles and decision steps
- +Role-based access controls limit process visibility and actions
- +API and webhook integrations support external system sync
- –Advanced automation paths can become hard to debug
- –Cross-process reporting requires careful workflow data modeling
- –Some governance tasks need more admin time than expected
- –Complex integrations often require custom mapping logic
Best for: Fits when mid-size teams need configurable workflow automation with controlled access and external system sync.
Glide
SMBA no-code platform for creating responsive business apps from spreadsheets and data sources.
App behavior built directly on spreadsheet data, with form-driven updates and live views for operational workflows.
Glide turns spreadsheets into interactive app-like interfaces without requiring traditional app development. It connects to data sources, renders views such as tables, galleries, and forms, and supports user workflows through actions and triggers.
The key differentiator is fast iteration from existing spreadsheet data with limited build-time complexity. Glide also offers automation through integrations and an extensibility path via platform features that fit workflow tracking and lightweight operations.
- +Spreadsheet-first app builds that minimize schema and UI setup
- +Forms, views, and workflow actions map well to internal tracking
- +Good integration coverage for common business data sources
- +Readable app behavior helps non-developers iterate quickly
- –Complex relational logic needs careful data modeling and testing
- –Real-time multi-user consistency can lag during heavy edits
- –Role separation and governance controls are limited for regulated teams
- –Automation depth is weaker than API-first workflow systems
Best for: Fits when teams need fast, spreadsheet-driven apps for tracking, intake, and simple operations.
Softr
SMBA no-code platform for portals, internal tools, directories, and client-facing applications.
Role-aware portals built from connected records, with forms that write back to the underlying data source.
Softr is a low-code builder for turning Airtable and other structured data into web apps with pages, portals, and internal tools. It focuses on connector-driven page generation, role-based access for gated content, and workflow features like forms and record creation.
Softr also provides an automation and API surface for syncing data to and from external systems, which matters when apps must stay consistent with upstream sources. The result is a configurable SaaS app layer that reduces custom UI work while keeping integration responsibilities explicit.
- +Fast page building from external data sources without custom front-end code
- +Portal access controls support gated content for different user groups
- +Built-in form flows can create and update records tied to the data source
- +API and webhooks enable event-driven sync with external services
- –Complex app logic can require extra automation work outside the builder
- –Authorization patterns can become harder to maintain at scale
- –Less control over UI edge cases than custom front-end development
Best for: Fits when structured data in Airtable or connected systems must power public pages and member portals quickly.
WeWeb
API-firstA visual web application builder with external database, API, and authentication support.
Web app generation from a visual UI builder that composes reusable components and binds them directly to API-driven actions and state.
WeWeb generates responsive web app UIs from visual page building and component composition, then wires those UIs to data and actions. The tool’s integration story centers on connecting UI state to external services through APIs and event-driven calls, including webhook-style patterns.
WeWeb also supports application packaging for deployment and environment-based configuration so the same project can target development and production workflows. Admin-ready capabilities include role-based access controls for collaborators and project governance to keep larger teams aligned.
- +Visual component system speeds reusable UI construction
- +API-first actions map UI events to external service calls
- +Role-based access controls support multi-user governance
- +Environment configuration supports consistent dev and production builds
- –Some complex UI logic still needs careful custom code boundaries
- –Workflow automation depth depends on available connectors and APIs
- –Debugging multi-step integrations can be slower than code-first apps
- –Team scaling can require stricter conventions for components and actions
Best for: Fits when teams need branded web apps with visual UI building and API-driven workflows.
FlutterFlow
API-firstA visual development platform for mobile and web applications with Flutter code export.
Generated Flutter code plus custom widget hooks lets teams mix visual composition with bespoke Flutter logic.
FlutterFlow is a low-code builder for production Flutter apps, with an editor tuned for mobile-first UI composition. It supports end-to-end wiring of screens to backends using built-in connectors, plus custom code hooks when UI logic needs native Flutter behavior.
Real apps often need authentication, database reads and writes, and event-driven flows, and FlutterFlow covers those workflows through configurable components and integrations. Extensibility via custom widgets and API requests helps teams keep standard screens out of custom code while still handling edge cases.
- +Visual UI builder maps directly to Flutter widgets and layouts
- +Built-in integrations cover common auth and backend data flows
- +Custom code and custom widgets support nonstandard UI logic
- +Reusable components speed up consistent screen patterns
- –Some advanced backend patterns require deeper custom code
- –Complex multi-step workflows need careful state management
- –Debugging runtime issues can be harder than code-only workflows
- –Role-based permissions and governance controls are limited for enterprise needs
Best for: Fits when teams need a Flutter app UI workflow with backend integrations and occasional custom code.
Conclusion
After evaluating 10 business finance, Appsmith 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 ready software
This buyer's guide covers Appsmith, Quickbase, Odoo, OutSystems, Mendix, Kissflow, Glide, Softr, WeWeb, and FlutterFlow for teams that need configurable, ready-made software without starting from scratch.
It focuses on integration, automation and API surface, and the governance and admin controls that matter once multiple apps, environments, or teams are involved.
The guide maps concrete capabilities from each tool to selection decisions so buyers can match build style, workflow shape, and operational constraints to the right platform.
Ready software platforms that package application logic, UI, and integrations for fast delivery
Ready software tools are prebuilt application platforms where teams configure screens, workflows, and integrations into working apps using built-in components, visual modeling, or code-adjacent wiring. They solve the need to ship operational workflows, intake forms, internal tools, and app interfaces tied to existing systems without building every layer from raw code.
Tools like Appsmith and WeWeb bind UI events to backend API calls and state changes inside a packaged development environment. Tools like Quickbase and Kissflow focus on relational record workflows and approval flows that run on structured process models with permission-aware execution.
Evaluation criteria for picking a ready software platform that matches real workflows
Ready software platforms differ most in how they connect app behavior to data and external systems and how safely that behavior runs at scale.
The criteria below prioritize automation and integration mechanisms, then admin and governance controls that prevent workflow loops, permission drift, and release breakage across environments.
Event-driven UI and workflow triggers that call backend requests
Appsmith delivers event-driven UI workflows that trigger configured backend queries and requests in a single app, which reduces glue code for interactive internal tools. Kissflow routes approval and task steps through a configurable process model, and those steps can sync work items through REST APIs and webhooks.
Permission-aware data access with granular control over who can see and act
Quickbase uses granular permissions control visibility across apps and records and ties automation to record lifecycle events. Kissflow adds role-based access controls that limit process visibility and actions, which keeps approvals and worklists consistent across teams.
Relational record modeling that keeps linked operational data consistent
Quickbase’s relational data model with linked records supports cross-table operational workflows while preserving permission-aware automation through API-driven access. Odoo’s cross-module procurement, inventory, and invoicing flows connect to shared accounting documents and valuations, which keeps key operational artifacts aligned.
Application lifecycle management with environment promotion and release governance
OutSystems provides built-in application lifecycle management that supports promotion, versioning, and controlled rollout across development, test, and production environments. Mendix also includes environment management for dev through production so teams can separate changes across releases while keeping operational settings auditable.
API-first integration surface backed by the platform’s business logic
Mendix exposes app capabilities through generated REST APIs backed by microflow logic so business rules stay consistent between UI use and system-to-system integrations. Quickbase’s documented REST API supports record synchronization, and it also provides event-driven updates with webhooks.
Spreadsheet and portal front ends tied to underlying structured data
Glide builds app behavior directly on spreadsheet data with form-driven updates and live views for operational workflows. Softr generates role-aware portals from connected records and uses forms that write back to the underlying data source so gated content and record updates stay aligned.
Decision framework for selecting the right ready software build style and operating model
Selection works best by matching workflow shape and integration requirements to the platform’s native execution model. It also works better when governance and release mechanics are verified early, because multi-app and multi-environment setups fail in predictable ways.
The steps below force those checks using concrete tools like Appsmith, Quickbase, OutSystems, Mendix, and Odoo.
Choose a build philosophy based on where the business logic should live
If UI-driven workflows must trigger backend queries and requests inside the same app, Appsmith fits because its standout capability is event-driven UI workflows that call configured backend actions. If the primary unit is a record and workflow process with approvals and SLAs, Kissflow fits because forms, routing, and SLA behavior are modeled together.
Match the data model to operational reality before mapping integrations
If linked records across operational tables drive the workflow, Quickbase fits because it centers on a relational data model with linked records and permission-aware automation. If business operations must coordinate sales, inventory, and invoicing with shared accounting documents, Odoo fits because cross-module procurement and invoicing connect to valuations and accounting artifacts.
Validate the integration and automation surface end to end
If systems must call into app capabilities through a generated REST interface backed by the same rules used in the UI, Mendix fits because it generates REST APIs backed by microflow logic. If the app must react to record lifecycle events and sync changes outward, Quickbase fits because it supports REST access plus webhooks for event-driven updates.
Check release governance and environment promotion mechanics for multi-team delivery
If teams need controlled promotion across dev, test, and production with lifecycle tooling, OutSystems fits because it includes built-in application lifecycle management with promotion, versioning, and controlled rollout. If teams want environment separation with operational governance settings and REST integrations backed by business logic, Mendix fits because it pairs microflow-based logic and audit-friendly operational settings with environment management.
Pick the UI delivery model based on where the user work starts
If the workflow starts from spreadsheet artifacts and teams need fast operational tracking and intake, Glide fits because apps are built directly on spreadsheet data with form-driven updates and live views. If the workflow starts from brandable web UI components and actions must call external APIs, WeWeb fits because it generates web app UIs that bind API-driven actions to reusable components and state.
Plan for where complex rules go when configuration hits edge cases
If complex business rules are expected to exceed built-in configurations, plan for an external service call or custom code boundary using Appsmith or OutSystems instead of assuming every rule stays in configuration. If complex backend patterns and multi-step workflows are expected, FlutterFlow and Mendix both support custom hooks or code paths, but runtime state management and debugging can require stronger engineering discipline.
Who should use which ready software platform based on actual workflow needs
Different ready software tools are optimized for different starting points and execution models. The best fit depends on whether workflows are record-centric, approval-centric, ERP-centric, spreadsheet-centric, or UI-centric.
The segments below map those needs directly to tools with matching best-for profiles from the ranked set.
Operations teams building configurable apps with enforced access and reporting
Quickbase fits because it builds configurable apps around relational operational data and supports granular permissions with audit-oriented administration. It also pairs record lifecycle automation with REST API and webhook-based updates for system synchronization.
Organizations coordinating sales, inventory, and finance through one integrated operational suite
Odoo fits because it coordinates cross-module procurement, inventory, and invoicing flows that connect to shared accounting documents and valuations. Its server-side workflow rules automate approvals and routing across those modules.
Teams delivering enterprise workflows that require controlled rollout across development and production
OutSystems fits because it provides application lifecycle management with promotion, versioning, and controlled rollout. It also supports API integration with REST endpoints and includes role-based access and audit visibility for governance.
Mid-size teams standardizing approvals, intake forms, and SLA-backed routing
Kissflow fits because its workflow designer combines forms, routing, and SLA behavior in one configurable process model. It supports role-based access controls and integration via REST APIs and webhooks for syncing work items.
Teams building internal tools or dashboards that must trigger backend actions from UI events
Appsmith fits because its event-driven UI workflows trigger configured backend queries and requests within a single app. It also supports self-hosting for controlled network environments and uses reusable components to reduce duplication.
Common buyer pitfalls that derail ready software projects
Ready software projects fail when governance, integration mapping, or workflow modeling are treated as afterthoughts. The pitfalls below reflect constraints and risks observed across the reviewed tools.
Each mistake includes a concrete corrective action and named tools that avoid the same failure mode.
Building complex business rules entirely inside configuration without a clear escape hatch
Appsmith and OutSystems can handle advanced behavior, but Appsmith may require external services when complex business rules need to live outside app configuration. Mendix also supports microflow logic, but advanced integrations and workflow complexity can fragment logic if rules are spread across pages and microflows without conventions.
Overlooking workflow loop risk in automation across record lifecycle triggers
Quickbase automation runs on record lifecycle events, so advanced automations can require careful governance to avoid workflow loops. Kissflow can also become hard to debug when automation paths grow complex, so workflow data modeling and process template standards should be set early.
Assuming role separation will scale automatically across a large app portfolio
Quickbase grants granular permissions, but large app portfolios can create admin overhead for permissions and templates. Odoo can require RBAC tuning and audit discipline for multi-team rollouts, so permission design needs to be reviewed before scaling beyond a single team.
Using low-code UI builders when relational logic needs deeper modeling discipline
Glide can turn spreadsheet data into fast apps, but complex relational logic needs careful data modeling and testing. WeWeb and FlutterFlow can generate UIs and bind API actions to state, but complex UI logic still needs careful custom code boundaries and stricter conventions as teams scale.
Skipping release workflow and environment separation for teams that ship frequently
OutSystems supports promotion and controlled rollout across dev, test, and production, so teams that skip release mechanics will lose governance control. Mendix similarly includes environment management for dev through production, so release planning should match the platform’s lifecycle tooling from the start.
How We Selected and Ranked These Tools
We evaluated Appsmith, Quickbase, Odoo, OutSystems, Mendix, Kissflow, Glide, Softr, WeWeb, and FlutterFlow on features, ease of use, and value, then combined those into an overall rating with features carrying the largest weight at forty percent while ease of use and value each account for thirty percent. Scores reflect criteria-based coverage of the concrete capabilities described in each tool profile, including event-driven workflow behavior, API and integration mechanisms, automation surfaces, and governance readiness such as environment promotion and role-based access controls.
Appsmith ranked highest because its event-driven UI workflows trigger configured backend queries and requests in a single app, and that specific integration-to-UI binding drove the top features score along with very high ease of use. That same mechanism also supported the platform’s extensibility through scripting hooks and custom request configuration, which helped performance in the categories most buyers use to avoid extra glue code.
Frequently Asked Questions About ready software
Which tool fits internal dashboards that call operational APIs from configurable UI workflows?
How do teams integrate ready software with external systems using APIs or webhooks?
When does RBAC and audit visibility matter during app configuration and collaboration?
How is data migration handled when moving from spreadsheets or Airtable-based sources into an app workflow?
What breaks if an integration needs complex UI state and conditional requests, not just form submissions?
Where does each platform fall short for admin control over environment changes and rollout?
Which tool is better for approval workflows with SLAs, routing, and worklists configured by admins?
How does extensibility work when built-in connectors do not cover a required backend pattern?
When should teams choose a unified modular suite instead of separate apps for CRM, ERP, and internal 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
Business Finance alternatives
See side-by-side comparisons of business finance tools and pick the right one for your stack.
Compare business finance tools→