
GITNUXSOFTWARE ADVICE
Technology Digital MediaTop 10 Best Kotlin Development Services of 2026
Top 10 kotlin development services ranked for Android builds with provider comparison of EPAM Systems, MindInventory, and Instinctools. Criteria and tradeoffs.
How we ranked these tools
Before any source is gathered, an editor locks the question, what qualifies, and how the piece will be judged.
Search agents gather the source set and the review record, including transcriptions of video reviews and podcasts.
Framework: Features 40% · Ease 30% · Value 30%
Gitnux may earn a commission through links on this page — this does not influence rankings. Editorial policy
EPAM Systems is the best choice when Android Kotlin work needs backend alignment, repeatable releases, and disciplined delivery governance, while MindInventory is a strong alternative fit for Android teams that want Kotlin implementation plus test-ready API integration through its releases.
Editor’s top 3 picks
Three quick recommendations before you dive into the full comparison below — each one leads on a different dimension.
EPAM Systems
Contract-aligned mobile and backend delivery practices that reduce API drift during Kotlin feature rollout.
Best for: Fits when Android Kotlin work needs backend alignment, repeatable releases, and disciplined delivery governance.
MindInventory
Editor pickClient-to-backend Kotlin integration execution that includes Gradle wiring and DI alignment for feature delivery.
Best for: Fits when Android teams need Kotlin implementation plus API integration through test-ready releases.
Instinctools
Editor pickDelivery centered on integration artifacts like API-aligned modules and build automation for repeatable Kotlin releases.
Best for: Fits when integration risk drives timelines for Kotlin Android plus backend builds.
Comparison Table
EPAM Systems
enterprise_vendorGlobal digital engineering firm with dedicated Kotlin practice areas.
Contract-aligned mobile and backend delivery practices that reduce API drift during Kotlin feature rollout.
EPAM’s Android delivery model fits teams that need both Kotlin implementation and integration with existing services, because work often spans REST or GraphQL API consumption, client SDK layering, and backend alignment for contract changes. Kotlin codebases are commonly structured for maintainability using modular components and dependency injection patterns that support unit testing and staged rollout. EPAM’s engagement tends to fit organizations that require repeatable delivery processes across multiple Android builds, because releases are usually treated as an operational workflow instead of a one-off build.
A tradeoff for EPAM is that standardized delivery and cross-team coordination can slow down very small scope changes when the team needs only a single feature and has no integration work. EPAM is a strong fit when Android work must coordinate with backend evolution, QA test automation, and long-lived platform constraints such as shared libraries and multi-app consistency. It is less aligned when the only requirement is local UI work without service integration or rollout governance needs.
- +Engineering teams that manage Android Kotlin plus backend API integration
- +Delivery workflows suited to repeatable releases across multiple app tracks
- +Code modularization patterns that support unit testing and faster change cycles
- +Strong cross-team coordination for contract-aligned client updates
- –Cross-team alignment adds overhead for tiny, isolated feature requests
- –Requires clear integration ownership to avoid client-server mismatch
- –More process-heavy than boutique teams for rapid one-off prototypes
Enterprise product teams
Android Kotlin feature builds with service integration
Fewer integration regressions
Platform engineering groups
Shared architecture and app consistency
Consistent implementation patterns
Show 1 more scenario
QA and release owners
Automated testing and controlled rollout
Higher release confidence
EPAM supports Android test coverage for logic and UI flows tied to release workflow checkpoints.
Best for: Fits when Android Kotlin work needs backend alignment, repeatable releases, and disciplined delivery governance.
MindInventory
agencyIndian software development agency with Kotlin Android expertise.
Client-to-backend Kotlin integration execution that includes Gradle wiring and DI alignment for feature delivery.
MindInventory works as a delivery partner for Kotlin development that spans Android application work and backend Kotlin services, which reduces integration handoff friction. Teams typically receive implementation support that covers Gradle-based build wiring, dependency injection integration, and API consumption patterns for production features. Engagement fit is strongest when Android teams have clear feature scopes and need a partner that can execute through testing and release readiness rather than only advising.
A tradeoff is that Kotlin Multiplatform depth is not the center of every engagement, so teams seeking shared UI across platforms may need a scope that explicitly includes multiplatform modules and expect actual structure. A common usage situation is when a product team has tight timelines for Android releases and requires dependable API integration plus instrumentation testing coverage to stabilize feature delivery.
- +Strong Android-to-API implementation support across Kotlin client and services
- +Practical Gradle and DI integration for maintainable feature modules
- +Testing-focused delivery artifacts for Android instrumentation stability
- +Clear handoff outputs for ongoing release iteration
- –Kotlin Multiplatform work requires explicit scope to avoid shallow coverage
- –Orchestration overhead can be higher when requirements change frequently
- –Advanced compiler plugin or build-extensibility needs may require additional scoping
- –Team onboarding can take time if existing architecture differs materially
Android product teams
Release stabilization with API-backed features
Fewer integration regressions
Mobile engineering leads
New module onboarding to DI and build
Faster addition of features
Show 1 more scenario
Platform integration teams
Android client updates for service changes
Cleaner API compatibility
MindInventory updates Kotlin client integration patterns to match backend contract evolution.
Best for: Fits when Android teams need Kotlin implementation plus API integration through test-ready releases.
Instinctools
agencySoftware development company offering Kotlin backend and mobile services.
Delivery centered on integration artifacts like API-aligned modules and build automation for repeatable Kotlin releases.
Instinctools fits teams that need Kotlin work split across Android application development and server-side Kotlin tasks with shared libraries and consistent build practices. Delivery is oriented around creating reusable code units, aligning API contracts for client and backend work, and reducing handoff friction through structured development artifacts.
A tradeoff appears when internal stakeholders expect a UI-first engagement model without deep focus on integration and build wiring. Instinctools is a better match when the bottleneck is cross-module coupling, API contract alignment, or Android-to-backend synchronization rather than isolated screen work.
- +Integration-focused Kotlin delivery across Android and backend modules
- +Reusable Gradle-based code organization for faster iteration
- +Works well for API contract alignment between client and server
- +Automation-heavy delivery workflow for consistent builds
- –UI-only Android efforts may receive less emphasis than integration work
- –Complex onboarding is likely when build standards are not yet defined
Mobile engineering leads
Android Kotlin module integration with backend APIs
Fewer handoff defects
Platform teams
Kotlin multiplatform library extraction
Lower duplication
Show 1 more scenario
Tech leads
Automation for repeatable Kotlin builds
More predictable releases
Implements build automation so releases follow the same integration steps across repos.
Best for: Fits when integration risk drives timelines for Kotlin Android plus backend builds.
Touchlab
specialistKotlin Multiplatform development and consulting firm founded by Kevin Galligan.
Kotlin Multiplatform engineering that pairs shared module implementation with native iOS integration work for end-to-end mobile releases.
Touchlab is a Kotlin development services firm that combines Android implementation with Kotlin Multiplatform execution aimed at sharing logic across mobile targets.
Work typically includes Gradle-based setup for multiplatform modules, implementation of shared code, and integration into Android and iOS apps.
Teams benefit most when they already have a clear shared-domain boundary and want a single delivery team to own build structure and integration details.
- +Strong Kotlin Multiplatform delivery for shared app logic across Android and iOS
- +Android engineering that accounts for real-world Gradle and release workflows
- +Practical guidance on concurrency patterns for maintainable suspend and Flow usage
- +Engineering support that emphasizes testability and CI-ready integration
- –Kotlin/Native depth can slow schedules when teams lack prior multiplatform experience
- –Limited evidence of heavy server-side Kotlin breadth for backend-only roadmaps
- –Some governance and automation needs require client-side build and release maturity
- –Expect extra coordination for cross-platform API contracts and shared domain boundaries
Best for: Fits when teams need Android-first delivery plus Kotlin Multiplatform sharing into iOS within one execution track.
Netguru
agencyPolish software house offering Kotlin backend and mobile development services.
Netguru execution pairs Kotlin code delivery with contract-first REST and GraphQL integration for mobile and backend touchpoints.
Netguru delivers Kotlin development for Android teams that need end to end implementation across mobile and backend. It supports Kotlin Multiplatform workflows for shared codebases, Jetpack Compose for UI, and Kotlin server stacks built around coroutines and reactive patterns.
Netguru also provides integration and automation surface through documented REST and GraphQL work plus CI oriented delivery processes. Its delivery emphasis centers on interface contracts, Android module structure, and maintainable release engineering rather than prototype builds.
- +Strong Kotlin Multiplatform delivery for shared business logic across targets
- +Practical Jetpack Compose implementation with reusable design system patterns
- +API integration work covers REST and GraphQL contract surfaces reliably
- +Android engineering favors clear module boundaries and testable coroutine flows
- –Kotlin Multiplatform requires planning for expect actual splits and build setup
- –Governance artifacts for large org rollouts depend on engagement scope and tooling choices
- –Advanced instrumentation test depth may need extra time for device farm access
- –Complex architecture refactors can extend timelines when app modularization is weak
Best for: Fits when mid-market teams need an Android focused partner that also handles Kotlin backend integration.
Intellectsoft
agencyDigital transformation agency providing Kotlin development services.
End-to-end release engineering for Kotlin shared modules, including Gradle-driven workflows and cross-team integration checks.
Intellectsoft targets Android application development and multiplatform Kotlin work with an engineering-led delivery approach. The service typically covers Kotlin for JVM apps, Kotlin Multiplatform for shared client logic, and backend integration through APIs and build automation.
Delivery quality is strongest when projects require frequent releases, shared components, and tight coordination across mobile and server teams. Governance, documentation, and automation practices tend to matter most in larger codebases where Android build stability and review velocity are key.
- +Multiplatform Kotlin delivery fits teams sharing business logic across Android and iOS
- +Codebase-scale Android builds benefit from structured Gradle and release workflows
- +API integration work supports consistent client-server contracts for Kotlin clients
- +Engineering oversight reduces churn during refactors across shared modules
- –Requires early agreement on shared module boundaries and module ownership
- –Automation depth can feel heavy for small one-off Android apps
- –Shared-logic timelines depend on how quickly backend contracts stabilize
- –Complex UI stacks need clear responsibilities between client and platform engineers
Best for: Fits when teams need Kotlin-first Android builds plus shared components and dependable API-driven integration.
Selleo
agencyPolish software development house offering Kotlin services.
Android client implementation that couples feature work with API contract integration and regression-focused testing.
Selleo delivers Kotlin and Android engineering with a focus on implementation depth across app and integration layers. Client teams get hands-on work on Android architecture, Kotlin language patterns, and test coverage that fits real release workflows.
Delivery scope typically spans build setup, feature implementation, and API integration support for Android clients consuming backend services. Engineering engagement is most useful when the objective includes maintaining Kotlin quality over successive iterations, not just shipping one feature slice.
- +Engineering work spans app features and Android integration touchpoints
- +Structured delivery supports multi-iteration Kotlin maintenance and refactors
- +Test coverage planning aligns with instrumentation and regression needs
- +Kotlin implementation emphasizes readability and safe concurrency patterns
- –Less suitable for teams needing deep research into unknown Android subsystems
- –Proactive governance depends on client-provided release processes and standards
- –Complex multiplatform scopes may require additional internal alignment time
Best for: Fits when mid-market teams need staffed Kotlin Android delivery with integration and test ownership.
Merixstudio
agencyPolish software development agency with Kotlin mobile capabilities.
Integration-focused delivery that coordinates Android and Kotlin service API contracts through the implementation workflow.
Merixstudio is a Kotlin development service provider known for delivering end-to-end Android and server-side Kotlin work with an integration-first delivery model. Engagements typically cover Kotlin Multiplatform or Android app development, Kotlin backends, and API integration patterns that keep client and server contracts consistent. Merixstudio also emphasizes engineering workflows around Gradle builds, testing, and release-ready handoff rather than leaving integration details to the client team.
- +API contract integration focus between Android clients and Kotlin services
- +Kotlin-centric build and testing workflow using Gradle Kotlin DSL
- +Structured delivery for multiplatform and Android code-sharing scenarios
- +Practical Kotlin concurrency patterns for responsive UI and backend throughput
- –Multiplatform expect and actual coverage can require more upfront mapping
- –Java interop edge cases can increase review cycles for complex models
- –Some Android UI coverage depends on Compose adoption in the host codebase
- –Heavier governance needs ongoing alignment for large org RBAC models
Best for: Fits when teams need Kotlin app and backend integration with repeatable build, test, and release handoff.
Future Processing
agencyPolish IT services company offering Kotlin development.
Delivery with end-to-end API contract alignment between app and backend engineering teams.
Future Processing delivers Kotlin development services across Android application development and server-side Kotlin work. Teams typically use it for building and maintaining Kotlin-based products with integration to existing Java services and backend endpoints.
The service scope often covers architecture, API integration, and test automation to support stable release cycles. Delivery quality is most consistent when requirements can be translated into clear Kotlin module boundaries and build workflows.
- +Kotlin module engineering fits mixed Java and Kotlin codebases
- +API integration support reduces client and server contract drift
- +Test automation focus supports repeatable regression coverage
- +Clear build and release workflow for multi-module projects
- –Deep native mobile work needs tighter scoping for platform variants
- –Faster iterations require early agreement on app architecture choices
- –Extensibility beyond agreed interfaces can add additional iteration cycles
- –Complex stakeholder governance can slow down review turnaround
Best for: Fits when teams need Kotlin implementation with API integration and repeatable testing for Android and Kotlin backends.
Turing
freelance_platformAI-powered remote developer platform offering Kotlin engineers.
Engineer onboarding into client CI and Gradle workflows to minimize integration time during Kotlin delivery.
Turing delivers Kotlin development staff augmentation that targets production shipping, not just ad hoc consulting. Kotlin teams typically use it for Android application development plus Kotlin backend work where a single vendor-delivered workflow reduces coordination overhead.
The service focuses on integrating assigned engineers into existing Gradle and CI pipelines while aligning on coding standards, review cadence, and delivery milestones. Coverage commonly extends across Kotlin Multiplatform tasks when shared business logic needs reuse across JVM and native targets.
- +Engineering delivery process fits teams that already run Android build pipelines
- +Staffed Kotlin projects benefit from hands-on code reviews tied to release milestones
- +Works well for mixed Kotlin scope that spans Android and server-side components
- +Supports Kotlin Multiplatform work where teams share logic across targets
- –Multiplatform depth can depend on which skills are available for the engagement
- –API integration work may require tighter spec writing from the client
- –Automation and governance artifacts can be inconsistent across short engagements
Best for: Fits when teams need managed Kotlin engineering support to deliver Android and backend features together.
Conclusion
After evaluating 10 kotlin development, EPAM Systems 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 Kotlin Development
Kotlin development services in this guide focus on delivering Android application development with contract-aligned client and backend work across staffed teams at EPAM Systems, MindInventory, and Instinctools. The included providers also cover Kotlin Multiplatform release tracks and integration-heavy workflows when Android and shared logic must ship together.
The ranking emphasizes integration depth, automation and API surface, and governance controls that affect how Kotlin feature rollouts stay aligned between mobile modules and server endpoints. EPAM Systems leads for repeatable releases that reduce API drift during Kotlin feature rollout, while MindInventory and Instinctools stand out for client-to-backend Kotlin integration execution and API-aligned module delivery.
Kotlin Development Services for Android and Contract-Aligned Client-Backend Delivery
Kotlin development services deliver production Android builds using Kotlin codebases that connect to backend services through defined API contracts and test-ready release artifacts. EPAM Systems targets Android Kotlin plus backend API integration with delivery workflows designed to prevent API drift during feature rollout.
MindInventory pairs Android-to-API implementation with Gradle wiring and dependency injection alignment so feature modules move through maintainable, test-oriented releases. Instinctools organizes delivery around integration artifacts and build automation so Android and backend modules progress with fewer contract mismatches during Kotlin feature delivery.
Kotlin Development capabilities that determine Android delivery outcomes
Kotlin development services succeed when Android implementation stays aligned with backend API contracts during feature rollout. Providers with contract-aligned delivery practices reduce mismatches between client modules and server endpoints.
Android Kotlin work also depends on automation depth in Gradle-driven build and release workflows. Services that standardize integration artifacts and release handoffs lower the effort needed to ship repeatable updates across app tracks.
Contract-aligned client-backend delivery governance
EPAM Systems ties mobile and backend delivery practices to reduce API drift during Kotlin feature rollout. Instinctools centers delivery on integration artifacts and build automation to keep Android and backend modules aligned.
Gradle wiring and dependency injection alignment for feature modules
MindInventory pairs Android-to-API implementation with practical Gradle and dependency injection alignment for maintainable feature modules. Intellectsoft supports Kotlin shared modules using Gradle-driven workflows and cross-team integration checks.
Integration-focused build, test, and release handoff mechanics
Merixstudio coordinates Android and Kotlin service API contracts through an implementation workflow with a Kotlin-centric build and testing pipeline using Gradle Kotlin DSL. Selleo couples Android feature work with API contract integration and regression-focused testing.
Kotlin Multiplatform sharing into end-to-end mobile releases
Touchlab delivers Kotlin Multiplatform with shared module implementation and native iOS integration work within one execution track. Netguru and Intellectsoft also deliver multiplatform Kotlin, but Touchlab most directly combines Android-first delivery with iOS integration.
Backend integration breadth for mixed Kotlin and Java codebases
Future Processing provides end-to-end API contract alignment between app and backend teams with Kotlin module engineering in mixed Java and Kotlin environments. EPAM Systems emphasizes repeatable delivery governance that helps teams manage Android Kotlin plus backend API integration across multiple app tracks.
How to choose Kotlin Development services for Android plus contract-driven integration
The best fit depends on whether the engagement risk is contract drift, module integration execution, or multiplatform scope. Providers differ in how they operationalize API alignment, build automation, and handoff governance.
Selection also needs a team match. Some services assume client-owned release processes that teams already run, while others bring heavier release engineering and onboarding into existing CI and Gradle workflows.
Classify the primary failure mode in the current Android-to-backend flow
If API drift during Kotlin feature rollout is the bottleneck, EPAM Systems is the most direct match because its delivery practices reduce client-server mismatch during feature rollout. If the bottleneck is integration artifact readiness and repeatable module delivery, Instinctools is structured around API-aligned modules and build automation.
Pick an integration execution philosophy: Gradle and DI alignment versus contract artifact handoff
MindInventory focuses on Gradle wiring plus dependency injection alignment so feature modules move through test-ready releases. Merixstudio and Intellectsoft coordinate API contract integration through the implementation workflow, with Merixstudio using Gradle Kotlin DSL for the Kotlin-centric testing and build loop.
Decide how much multiplatform scope the roadmap will tolerate
If shared Kotlin logic must land on Android and iOS within one track, Touchlab is the most explicit provider for Kotlin Multiplatform with native iOS integration work. If multiplatform is needed but mostly for shared business logic, Netguru and Intellectsoft offer multiplatform delivery with planning emphasis on module boundaries and expect-actual splits.
Match the engagement’s release maturity to the provider onboarding model
If the client already runs Android build pipelines and needs fast alignment into CI and Gradle workflows, Turing offers onboarding into the client CI and Gradle workflows to minimize integration time. If the engagement requires structured release workflows across multiple app tracks, EPAM Systems is built around repeatable releases and disciplined delivery governance.
Confirm the expected level of server integration specification from the client
If backend API integration needs tighter spec writing and contract clarity from the client to avoid schedule risk, Turing’s model reflects that dependency. If the project aims to reduce contract drift through integration-focused delivery practices, Future Processing and EPAM Systems provide end-to-end API contract alignment paired with repeatable testing and delivery handoffs.
Who should buy Kotlin Development services for Android integration work
Android teams should buy Kotlin development services when Kotlin feature delivery depends on consistent API contracts and test-ready integration artifacts. These services are most effective when the work needs repeatable releases that keep client modules and server endpoints aligned.
The right buying target changes by whether the roadmap includes Kotlin Multiplatform sharing and how much server integration governance must be handled by the vendor.
Android teams shipping frequent releases with contract drift risk
EPAM Systems fits teams managing Android Kotlin plus backend API integration because its delivery governance reduces API drift during Kotlin feature rollout. Instinctools also fits teams where integration risk drives timelines because it organizes delivery around API-aligned modules and build automation.
Teams that need Gradle and dependency injection alignment for Kotlin module delivery
MindInventory supports client-to-backend Kotlin integration execution with Gradle wiring and dependency injection alignment for maintainable feature modules. Intellectsoft fits teams that need Kotlin-first Android builds paired with shared components and integration checks through Gradle-driven workflows.
Organizations building shared logic across Android and iOS
Touchlab fits Android-first teams that must deliver Kotlin Multiplatform shared logic and native iOS integration work within one execution track. Netguru fits when shared business logic delivery is the priority while mobile UI implementation can be handled through practical Jetpack Compose patterns.
Mid-market teams requiring structured Android integration plus regression testing
Selleo is designed for staffed Kotlin Android delivery that spans app features and Android integration touchpoints with regression-focused testing. Future Processing fits teams needing Kotlin module engineering in mixed Java and Kotlin codebases while keeping app and backend API contracts aligned.
Common mistakes when buying Kotlin Development services for Android integration
A frequent mistake is selecting a provider based only on Android feature velocity while ignoring how API contracts are managed across releases. Another mistake is treating multiplatform scope as a toggle instead of a build and module governance exercise.
These failures show up as integration churn, late contract fixes, and slow onboarding into CI and Gradle workflows.
Assuming backend contract alignment will happen automatically during Android development
EPAM Systems and Instinctools place integration artifacts and delivery governance at the center of rollout to prevent contract mismatches. Teams that skip explicit integration ownership risk client-server mismatch that both providers flag as overhead.
Buying for Kotlin Multiplatform without defining shared module boundaries early
Netguru and Intellectsoft call out planning needs for expect-actual splits and module boundaries. Touchlab still can slow schedules when teams lack multiplatform experience, so scope and capabilities must be defined before execution.
Choosing a provider without matching release maturity and CI ownership expectations
Turing’s model emphasizes onboarding into the client CI and Gradle workflows, which can work well when build pipelines already exist. Selleo and Merixstudio depend more on how client release processes and standards are provided, so incomplete release governance can delay onboarding.
Under-scoping integration effort when UI-only Android work is the main priority
Instinctools prioritizes integration artifacts and build automation, so UI-only Android efforts can receive less emphasis. Teams focused on UI subsystems should assess whether integration-centric workflows will produce the expected throughput.
How We Selected and Ranked These Providers
We evaluated EPAM Systems, MindInventory, Instinctools, and the other included providers on features, ease, and value, with features weighted at 40% and ease and value weighted at 30% each. Features emphasized integration depth for Android Kotlin with contract-aligned client-backend work, including integration artifacts and repeatable release handoffs.
EPAM Systems set the ranking pace through contract-aligned mobile and backend delivery practices that reduce API drift during Kotlin feature rollout, which aligned tightly with rollout risk. MindInventory ranked highly for integration execution that included Gradle wiring and dependency injection alignment, while Instinctools scored strongly for API-aligned module delivery and build automation focused on repeatable Kotlin releases.
Frequently Asked Questions About Kotlin Development
How should Android Kotlin teams choose between EPAM Systems, MindInventory, and Instinctools when backend contract changes drive release timing?
Which provider is better for Kotlin Multiplatform sharing when the project must also integrate iOS endpoints and native libraries?
When does Gradle wiring and dependency injection alignment matter more than Kotlin code style for Android delivery?
What breaks if a Kotlin Android project treats API integration as a UI-only task instead of a contract-driven module boundary?
How do these providers handle instrumentation testing as part of the release workflow for Android builds?
Where does provider extensibility typically fall short when teams need to add new API endpoints and keep client and backend in sync?
How does each provider approach client-to-backend API integration when REST and GraphQL both exist in the same Android product?
When is data migration planning a deciding factor for choosing a Kotlin development partner for Android and server-side changes?
What onboarding model reduces coordination time during Kotlin delivery across Android and Kotlin backend projects?
Tools reviewed
Primary sources checked during evaluation.
Referenced in the comparison table and product reviews above.
- AI In IndustryTop 10 Best Kotlin App Development Services of 2026
- Technology Digital MediaTop 10 Best Android Development Services of 2026
- Technology Digital MediaTop 10 Best Developer Services of 2026
- Technology Digital MediaTop 10 Best App Development Software of 2026
- Remote And Hybrid Work In IndustryTop 10 Best Development Team Software of 2026
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→