9 selected tools
A more useful terminal
Practical additions to a command-line workflow: retrieve commands, navigate files, inspect data, and automate repeated work. Choose the pieces that solve a task you do often.
Choose an area to explore, or start with a small selection organized around a development task.
Browse all tools →9 selected tools
Practical additions to a command-line workflow: retrieve commands, navigate files, inspect data, and automate repeated work. Choose the pieces that solve a task you do often.
9 selected tools
An archive selection covering repository hosting, workspaces, CI, packages, storage, and deployment on infrastructure you control. These are separate building blocks, not a tested integrated stack.
9 selected tools
Investigate infrastructure from inventory and network paths to processes, logs, database queries, container layers, and costs. Start with the question you need to answer.
APIs for adding capabilities to your application without building every service yourself. Compare integration effort, failure handling, and the boundaries of each service.
Services for adding messaging and communication to applications. Consider delivery guarantees, supported channels, and how failures reach your users.
Compute services for running application workloads. Compare execution models, infrastructure control, and operational responsibilities.
Tools for connecting services and controlling network access. Compare connectivity models, setup requirements, and visibility into failures.
Application platforms that take on part of the deployment and operations work. Look at supported workloads, portability, and what you still need to manage.
Platforms for running functions and event-driven workloads. Compare runtime constraints, local development, and how state and background work are handled.
Storage services for application data and objects. Compare access patterns, compatibility, and the operational tradeoffs described in each review.
Tools for building and working with machine-learning systems. Compare integration requirements, supported workflows, and the limits noted during review.
Databases organized around documents rather than fixed relational tables. Compare query capabilities, data modeling, and deployment requirements.
Key-value stores for retrieving data by key. Consider persistence, concurrency, and whether the tool runs inside your application or as a separate service.
Tools for querying, inspecting, and operating databases. Compare supported engines, access controls, and how they fit into development and production workflows.
Relational databases and SQL engines. Distinguish analytical workloads from transactional ones, and consider concurrency and operational requirements.
Tools for managing access to and operation of APIs. Compare routing, policy controls, and visibility into requests.
Tools for building, testing, and deploying changes automatically. Compare execution environments, configuration, and debugging failed runs.
Tools for building, running, and managing containers. Compare local development support, runtime compatibility, and operational requirements.
Tools for provisioning and operating infrastructure. Compare configuration models, state handling, and the work that remains your responsibility.
Tools for collecting and investigating application logs. Compare ingestion, query workflows, and how much context is available when debugging.
Tools for moving work and events between application components. Compare delivery semantics, retry behavior, and deployment complexity.
Tools for inspecting network paths and connectivity. Compare the measurements available, diagnostic output, and supported environments.
Tools for understanding application behavior through telemetry. Compare instrumentation requirements, supported signals, and investigation workflows.
Tools for processing streams of events and data. Compare integrations, delivery guarantees, and the complexity of writing transformations.
Servers and runtimes for handling web application traffic. Compare application support, lifecycle management, and operational visibility.
Clients for exploring and testing APIs. Compare supported protocols, repeatable requests, and collaboration or automation features.
Tools for packaging and distributing applications. Consider supported platforms, update mechanisms, and the work required to ship reliably.
Frameworks for server-side application development. Compare language support, data access, deployment assumptions, and flexibility.
Tools for measuring performance and exercising applications under load. Look at workload modeling, useful output, and integration with your development process.
Tools for testing behavior in a browser. Compare browser coverage, local feedback, and how tests run in continuous integration.
Tools for sharing and working on code together. Compare review workflows, access models, and integration with your source-control system.
Tools for understanding and maintaining application dependencies. Compare supported ecosystems, update workflows, and the context provided for changes.
Tools for creating, publishing, and maintaining technical documentation. Compare authoring formats, code integration, and maintenance requirements.
Frameworks and libraries for building web interfaces. Compare rendering models, application complexity, and the amount of infrastructure each approach introduces.
Tools for Git workflows, repository hosting, and reviewing changes. Compare how each fits your branching model and existing development habits.
Development environments and coding workspaces. Compare language support, local versus remote execution, and how much of your workflow they bring together.
Tools for building interfaces and workflows for your team. Compare data integrations, deployment control, and how much custom code you can use.
Tools for running and iterating on applications during development. Compare setup effort, environment reproducibility, and feedback speed.
Tools for applications split across multiple services. Consider service boundaries, local development, and the operational complexity they introduce.
Tools for installing and managing software packages. Compare ecosystem support, reproducibility, and how environments stay consistent.
Tools for adding search to a website or application. Compare indexing, relevance controls, and integration requirements.
Tools for tracking and coordinating changes to code. Compare collaboration models, hosting options, and compatibility with your existing repositories.
Frameworks for writing and running automated tests. Compare language support, test isolation, and the quality of failure feedback.
Editors for working with code and text. Compare navigation, language tooling, customization, and how each fits your daily workflow.
Tools for constructing application interfaces. Compare control over generated code, design workflows, and integration with your frontend stack.
Tools for coordinating development tasks and repeatable workflows. Look at automation boundaries, integrations, and how failures are handled.
Tools for identifying users and controlling sign-in. Compare integration requirements, supported methods, and deployment responsibilities.
Tools for storing and distributing credentials and other secrets. Compare access controls, development workflows, and operational requirements.
Tools for identifying and managing software vulnerabilities. Compare coverage, prioritization, and the work required to act on findings.
Utilities that improve working in a browser. Compare supported browsers, workflow fit, and the permissions or setup they require.
Programming languages and language runtimes. Compare interoperability, tooling, and the constraints recorded at the time of review.
Operating-system tools and low-level application infrastructure. Compare platform support, compatibility, and how much system knowledge they require.
Terminal applications for command-line work. Compare platform support, session management, and customization.
Command-line tools for everyday development and system tasks. Compare input and output formats, composability, and the behavior they replace.
Independent devtool reviews and the latest betas, in your inbox every Thursday. Free.