Console
Devtool reviews
Each week Console reviews the best tools for developers.
✦ Disclosure: All reviews are editorially independent and partners must meet our selection criteria.
Latest Tools(100)
What we like: Easy APIs for upload, process, embed, stream video. APIs to generate images, clips & previews. Player React component which is themeable, including support for custom domains. Can also handle live streaming. Data APIs for playback and engagement analytics. API for adding subtitles or auto-generating captions.
What we don't like: Be sure to download your original files - there are some situations where Mux may have the only copy e.g. live streaming or if you uploaded then ran edits.
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Easily spin up a very lightweight GitHub-style UI & Git backend for self-hosting code. Includes YAML-defined pipelines like GitHub Actions which can run multi-step processes e.g. build, test, deploy. Includes a Pull Request UI and proper Git diffs.
What we don't like: Backed by sqlite on disk with no guidance for more robust/production deployments. No dark mode.
What we like: Scans infrastructure as code configs e.g. Terraform, CloudFormation, k8s, Helm, Dockerfile for misconfigurations. Large out of the box library. Can integrate with IDE and CI to help catch issues ideally as you write them, but definitely before they go to prod.
What we don't like: Conflicts with TFSec if you’re using Terraform, so best not to use them combined - pick one or the other.
What we like: Import and sync data from many sources (Webhooks, Snowflake, BigQuery, S3, etc). Build metrics and queries you want to create dashboards using GraphQL and REST. Supports time series, leaderboard, and counter outputs. Set tenant IDs for access control. Custom filters & mutations. Open source React components to add to your frontend & display to your users.
What we don't like: Would like to see more UI components and more flexibility for customization e.g. CSS variables.
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Parses log lines to highlight various data formats e.g. dates, IPs, UUIDs, numbers, HTTP methods, etc. Highlighting rules are configurable. Can watch files in a directory and follow files. Uses less as the pager, so supports keyboard navigation, search, and filtering.
What we don't like: Takes a long time to load large logs - more designed for piping/streaming. Doesn’t work on Windows.
What we like: Zero config search for static sites. Builds the index after the static site build step. No server required. Supports custom sorts, filtering, weighting, and multi-language. Includes a pre-built UI with highlighting of search terms. Indexes HTML by default, but can be customized to add any files e.g. PDFs, JSON, etc.
What we don't like: Non-HTML files must be added individually through the custom index config.
What we like: Build product (transactional) notifications based on events and advanced workflows. Send messages to the correct channel (email, in-app, SMS, Slack, etc), batching, throttling, avoiding duplicates. Pre-built UI components e.g. feeds (can also be run headless), and native SDKs for most languages. CLI for managing config/workflows locally - (edited in your IDE).
What we don't like: Notification flow configurations exist outside your codebase, although the Knock CLI for local development combined with environments & the commit/push workflow mitigates this.
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Explore Redis instances via a desktop GUI. Supports all Redis key types e.g. pub/sub, streams, hash, list, etc. Perform bulk actions. Built-in simple CLI and full workbench for constructing advanced queries / issuing commands. Includes observability, a profiler, and analysis tools for monitoring production clusters. Also supports AWS ElastiCache.
What we don't like: Built using Electron.
What we like: Designed for file management e.g. sync between directories, copying, uploading, tagging, etc. Connects to multiple sources local, physical disks, remote (Google Drive, Dropbox, S3, SFTP, etc). Themable. Manage files via a CLI. Preview files and edit text in place (even remotely).
What we don't like: macOS only. Triggers a lot of privacy permissions popups on first launch (blame macOS).
What we like: Control access to cloud resources (AWS, GCP, k8s, Postgres, Snowflake) with just in time approvals. Approved entitlements must have an expiry - great to avoid long-lived credentials. Route requests to the right approvers, configured in code. PagerDuty integration for auto-approving when on-call. IAM Audit feature highlights overly permissive policies.
What we don't like: IAM Audit currently only works with GCP (main approval flows work across multiple cloud resources).
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Terminal UI for exploring JSON files, streams, or piping JSON through pre-processing. Interactive mode for searching JSON and visually expanding the structure. Has Vim compatible keybindings. Includes built-in functions e.g. for fetching data, sorting, counting, etc. Open source & available as a single (Go) binary.
What we don't like: Missing some Linux packages e.g. Debian, Yum, etc.
What we like: Extension for Postgres to add columnar table types for analytics workloads. Means you can use existing Postgres clients and queries. Automatic vectorization for aggregate queries. Can copy tables between row and columnar. Built-in cron-like scheduler for regular tasks e.g. analytics queries. Open source. Great, original website theme.
What we don't like: Some Postgres features are not yet implemented e.g. upsert on conflict and foreign keys.
What we like: Automate SDK generation across multiple languages. Also supports generating Terraform providers. Source generation from OpenAPI or JSON Schema specs. Annotations allow deeper customization e.g. supplying docs, how objects are nested, parameters, preventing plan changes etc.
What we don't like: Requires your APIs be defined using OpenAPI or JSON Schema, but that’s definitely faster than building SDKs and building Terraform providers from scratch!
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Ever got stuck with constructing a mental representation of what’s happening with COPY in your Dockerfile? Terminal interface allows exploration of each image layer. Diff changes by layer. Integrate into CI to provide efficiency stats for image builds. Configurable UI with keybindings. Single binary.
What we don't like: Can’t distinguish between different architectures when examining a multi-arch image. Would be useful to be able to hide base image layers.
What we like: CLI to help manage and share GPUs. Share GPUs on your machine and manage remote machines. Find available GPUs across a pool of resources and reserve them for your own use. Monitor usage and pipe metrics to Prometheus or Grafana. Access GPUs from containers. Supports over subscribing resources. Integrates with VSCode, Jupyter and other IDEs.
What we don't like: It’s a management tool so needs to be installed across your fleet for everyone to use. Distributed as a Python tool rather than a single binary.
What we like: Exposes cloud object storage (S3 & S3 compatible, GCS, Azure Storage) as if it were a POSIX compatible filesystem with standard commands like copy, list, remove, etc. Appears as a new mounted filesystem plus a CLI for direct interaction (which offers better performance than a FUSE mount). Supports metadata like permissions, links, users, etc.
What we don't like: No Arm binaries. Be aware that whilst CunoFS works around the object storage write-once limitation, it may not be efficient.
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Full Postgres, but only a serverless model with compute and storage scaled independently. Branching from main makes it easy to prototype and test changes without worrying about the production branch. Integrates with Vercel preview environments for automatic branches per environment. Web UI for easy browsing & SQL execution. Hosted, but open source.
What we don't like: Still in technical preview. Can only deploy databases into a single region (chosen per project) - unclear how redundancy works across zones.
What we like: Add metrics to existing code with simple annotations or macros. Supports Rust, Go, Python, TypeScript, C#. Alerts and SLOs defined in code next to each instructed method. VS Code extension provides deep links to generated graphs. Can run locally, but designed to export to Prometheus.
What we don't like: Requires Prometheus for metrics, although it is based on top of OpenTelemetry.
What we like: The prompt is a native text field so you can click around and use shortcuts to move the cursor, highlight words, etc. Lots of small UI improvements e.g. the command pins to the top as you scroll. Each output is a “block” which can be shared and navigated. Get AI assistance for commands. Shell runs through SSH so you don’t lose all the benefits on remote servers.
What we don't like: Limited theme options. macOS only.
What we like: Converts Markdown or Notion pages into type-safe data ready to be imported into an ESM module. Type safety means you can loop through pages and parse out JSON, Markdown, MDX. Can also pull from remote sources. Integrates into Next.js with fast, incremental builds & hot reload.
What we don't like: No support for other frameworks (in consideration) or content sources like CMSs.
What we like: Protects runner workflows from exfiltration-style attacks by providing network observability for the runtime environment. Monitors files, process & network activity. Can block egress traffic (with allowlists), detect source code tampering, and compromised dependencies. Runs on GitHub hosted, self hosted, and VM runners.
What we don't like: Analysis and security recommendations are provided via a link to a web UI in the workflow output rather than natively as part of the output logs.
What we like: Define your schema in TypeScript with no build/generate step required. SQL-like interface with the option to call SQL directly and/or use prepared statements. Includes migration functionality with supporting CLI and a local GUI for exploring the database. Zero dependencies and supports edge/serverless functions.
What we don't like: No support for DynamoDB, CockroachDB, MS SQL.
What we like: Makes it easy to build product tours, onboarding, contextual help, and highlights. Can be themed via CSS and implements keyboard shortcuts. Everything configured and driven by code e.g. loading data before triggering a tour or starting a tour from a later step. Open source.
What we don't like: Based around page elements, popovers and highlighting which is great for most tours, but may be too limited for anything more advanced.
What we like: Generates a CHANGELOG, creates the GitHub release, and bumps versions in language specific files e.g. package.json, Cargo.toml, setup.py, etc. Supports a range of languages. Parses conventional commits so understands version bumps for breaking changes. Manages Git tags.
What we don't like: Requires conventional commit formats and does not handle publishing releases to package managers.
What we like: Standalone CLI for managing database migrations. Maintains a “current state” SQL file so you can always provision the database and diff changes. Migrations are specified in plain SQL with up and down states to support rollbacks. Runs migrations inside transactions. Single binary & can also be embedded in code (Go).
What we don't like: Framework agnostic, but may not play well if you do use a framework like Prisma and want to manage migrations for its schema across other languages. Not sure if that’s a limitation of DBMate or Prisma, though!
What we like: Linter CLI for enforcing a specific writing style. It’s not prescriptive - there are lots of open styles used by the likes of Microsoft, Datadog, Spotify, Grafana, which you can use. Customize the configuration to define your own rules. Works on formats like Markdown, HTML, AsciiDoc, code comments. Various editor plugins e.g. VS Code, Obsidian, Vim.
What we don't like: It’s designed for text files - great if that’s where you’re writing, such as for technical documentation, but there’s no support for other common editors like Google Docs or Word.
What we like: Opinionated methodology to help combine changes into a release, particularly when they span multiple packages. Changesets then get combined into a changelog and a version bump, which helps coordinate a package release. Can be integrated into CI to automate releases. Includes a GitHub Action and build/publish support for NPM.
What we don't like: Best for NPM / JS monorepos. It will work with other package types, but only if there’s a package.json.
What we like: Uses hardware acceleration for large string manipulation. Supports length, indexing, slicing, count, substring matching, and split. Works with strings and files. File supports memory maps without loading a copy into RAM and becomes immutable so can be shared across Python processes. Performance up to 12 GB/s vs native 14 MB/s.
What we don't like: Bindings for C and Python only. Rust & JS planned.
What we like: Single configuration for domains with support for 35+ providers such as AWS Route53, Bind, Cloudflare, DNSimple. Has migration scripts to bring in existing records. Makes it easy to store in Git and push changes via CI/CD. Supports notifications e.g. Slack, when changes are made. The config is JS so you can use JS language features e.g. loops.
What we don't like: The DSL is JS rather than TypeScript, however some editors e.g. VS Code, support autocomplete and type checking.
What we like: Windows app providing lots of useful common tools in a single (offline) app. Includes convertors e.g. JSON to YAML; encode/decode e.g. URL, base64; generators e.g. hashes, lorem ipsum; graphics e.g. format convertor. Supports compact mode and pinning to the start menu. Open source.
What we don't like: Windows only.
What we like: Based around React components which can be customized with CSS variables, inline CSS or Tailwind. Build custom flows with social signin, SSO, organizations, and MFA. Everything is available as an API for integration into backend code (there’s also a Go SDK). Has helpers for e2e testing using Cypress.
What we don't like: Backend SDKs are only available for Go, Ruby, and JS - you’ll need to use the API for everything else.
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Setup and connect environments via a private network. Require multi-step authentication with audit logging to gain access e.g. your SSO + customer approval to log into their network. Local client for viewing networks and managing connections. Create services for headless access, use DoH on the network, connect to serverless environments e.g. Fargate.
What we don't like: Doesn’t support connecting directly to managed services e.g. databases like RDS. UI has no dark mode.
What we like: CLI for transpiling, transforming, bundling and minimizing CSS. Built for performance (in Rust). Can help with using current CSS features even with older browsers by using vendor prefixes and conversion to older syntax based on desired browser targets. Works with Parcel, Deno, webpack & vite. Can also be used as a library in JS or Rust.
What we don't like: Missing full support for CSS modules.
What we like: Define your infra in TS, Python, Go, C# or YAML. Pulumi provides managed templates for which implement “best practices” e.g. security groups and IAM roles which makes it easy to deploy common services like ECS or Lambda. You can import Terraform modules. End to end CI & CD for infra and code e.g. build, upload, deploy a Docker image. Docs chat AI gives helpful code examples.
What we don't like: Some of the docs aren’t up to date on the latest release. Doesn’t support more complex code deployment models e.g. green/blue with easy (non Gitops) rollbacks.
What we like: Fast and easy to configure. Sets up HTTPS for public domains automatically using Let’s Encrypt. Can also be a reverse proxy. Configuration via a simple text file and/or via a JSON API so it can be managed programmatically. Has OpenTelemetry & Prometheus integrations. Open source and provided as a static binary for every platform (written in Go).
What we don't like: Requires a bit more work to get local HTTPS working, but that’s just due to how the custom root CA needs to be explicitly installed and trusted.
What we like: Makes it quick to search through the node_modules directory for specific packages. Can find all instances of a given package, including where it's a dependency of another package. Shows the version info and how that relates to the current latest release. Helps find all your sub-dependencies. Supports fuzzy search.
What we don't like: Missing full support for pnpm due to how pnpm structures node_modules with links.
What we like: Easily set up various auth methods - social login, passwordless, SAML, SMS. Integrations into frameworks like Next.js (including app router), React, Go, Python, iOS. Supports RBAC. Includes audit logs and webhooks for events. Dark mode. Can be cloud hosted, but is also open source so you can run it yourself.
What we don't like: Customization is through CSS injected into their UI - would be good to see these as more flexible React components.
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Manages language toolchains and integrates with the native package managers throughout your monorepo. Provides a single CLI for running tasks across languages and packages. Supports multiple languages e.g. you can trigger Node and Rust tests with one command. Remote caching and chained pipelines to speed up builds.
What we don't like: Works with most languages, but toolchain integration and integration into package manifests and lock files only currently supported in Node, Deno and Rust.
What we like: Point it at your protobuf files and you can easily interact with gRPC endpoints. Can also detect the services based on reflection, if supported by the endpoint. Supports TLS and plaintext (useful for development), plus streaming methods. Can be pipelined with tools like jq because it works with JSON request bodies that it translates to gRPC. Single binary (Golang) and open source.
What we don't like: Only supports JSON inputs. No release for a year even though development has happened on main.
What we like: Easy to self-host in a single container backed by SQLite, but can scale horizontally by connecting MySQL, Postgres, etc + load balancer. Official client libraries for a range of languages. Can split the audience into segments for conditional flagging. Supports gradual rollouts as a %.
What we don't like: Docs are primarily about deploying & running Flipt rather than explaining how to use the core feature flag functionality.
What we like: Works on the assumption that the file you’re looking for is probably higher up the directory tree, so optimizes the index for breadth rather than depth = faster results. Compatible with the find command, but with easier to remember arguments. Has better errors and suggests corrections. Packages available for most OSs.
What we don't like: Built for *nix systems - you could try building it on Windows through WSL.
What we like: Similar to Homebrew on macOS, lets Windows users install apps from the command line. Bypasses permissions and GUI wizards. Manages all dependencies and any extra setup. Has community packages for games, fonts, Java, PHP, databases. Scriptable for automating machine bootstrapping. Easy to write your own packages.
What we don't like: Windows only (obviously). Requires PowerShell to install.
What we like: Well thought through API for sending emails. Official SDKs for Node, PHP, Ruby, Go, Elixir, Python. Works with serverless or edge functions. Delivery logs to debug sending issues. Domain verification with DMARC. Webhooks for delivery events.
What we don't like: No recipient or subscriber management yet - you’ll need a separate system to manage a mailing list, for instance.
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Install as a GitHub app to automatically scan your PRs as dependencies change, which are an increasingly common attack vector. Detects various issues such as malware injection, changed package behavior, new authors, data exfiltration, license issues etc. Can also run as a CLI or VS Code extension.
What we don't like: Only supports JS/TS & Python ecosystems. Go in private alpha and other languages on the roadmap.
What we like: Makes it easy to run multiple processes as defined in your Procfile. Uses tmux behind the scenes so you can connect to any of the processes. Direct control of processes to restart specific ones without interrupting the others. Process output is properly captured so it doesn’t break colors.
What we don't like: Obviously assumes you’re using a Procfile, which is perhaps less common with container-driven development these days?
What we like: Easily create tours, checklists, highlight boxes, tips, and onboarding flows. No-code UI to define flows, logic & branches, but there’s also a full JS SDK for customizing components. Supports custom styles, targeting rules, state management, and analytics. Can trigger webhooks when steps are reached.
What we don't like: Limited to frontend onboarding - SDKs are only for JS and React.
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Bring third-party code into your repo and keep it up to date. Supports syncing from files, git, downloading and extracting from remote URLs. Pulls in specific revisions and can auto-update when new versions are published. Can be run as part of a build process - commit the config to your repo.
What we don't like: Supports limited sources, but actual packages & dependencies are probably already managed as part of your language toolchain. Requires Python rather than a static binary.
What we like: Acts as a mail server (SMTP or API) for testing emails from your code. Static binary so can easily be run in CI/CD. API allows querying of received emails so you can check they were correctly “sent”. Can persist mail to a SQLite database. Has a web UI to inspect mail e.g. for local development.
What we don't like: Designed for integration testing rather than as a library for unit testing or mocking - which is probably what you want for email tests, but means you need to configure it as a service. Includes Docker images to support this.
What we like: CLI to provision preview environments based on your Docker Compose config. Runs in your own cloud (AWS Lightsail, GCP, Azure). Expose apps to the web or securely access via a tunnel. Run in CI e.g. for E2E tests. Auto configures HTTPs. Supports plugins for responding to events e.g. posting environment URLs to a GitHub PR. Open source.
What we don't like: Tunneling uses the Authorization header, which may break your services if you also rely on it e.g. for auth or WebSockets. Assumes you use Docker Compose.
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Super simple k/v store API for JS. Defaults to in-memory with no dependencies, but has adapters for Redis, Mongo, SQLite, Postgres, MySQL. Handles all JSON types (supports custom serialization) with a Promise-based API. Supports TTLs and namespaces. Open source. Plugins for extra functionality e.g. memoize a function.
What we don't like: Limited to set, get, has, delete and clear functions. If you want more sophisticated options e.g. increment or setting fields on a hash, you’ll need to use something else e.g. Redis.
What we like: Integrates with AWS, GCP, and Azure to provide real time cost reporting and analysis. Provides a kubectl plugin to allow querying of cost data. Export pricing data to Prometheus to build into your queries/dashboards. Integrates with k8s to provide allocation by workloads, containers, etc. Override pricing data e.g. for on-prem deploys, or use cloud pricing APIs. Open source.
What we don't like: Requires a complex setup - you already need to be running k8s and Prometheus. There are multiple open GitHub issues related to Azure, so these are worth reviewing if you want to deploy there.
What we like: Ingest data from official SDKs (Node, Go, Rust, Python), integrations (Elastic, Vercel, Lambda, Cloudflare), extensions (tracing for Python, Next.js, Zap), or generic endpoints like syslog. Powerful query language with functions, expressions, field detection. Use this to build dashboards and set alerts. Offers unlimited retention & no sampling.
What we don't like: Field names limited to 200 bytes. There is an option to run it yourself, but this brings an ingest constraint of ~1.5TB/day/vCPU and requires you to run Postgres + object storage e.g. S3.
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Deployed as a single (C++) binary - no JVM. No Zookeeper. Use any Kafka library. Comes with a web console out of the box and can be managed via a CLI (which includes tuning features). Built-in schema registry. Prometheus endpoints. Tiered storage to offload to object storage. Run it yourself, in the cloud, or bring your own cloud.
What we don't like: Schema registry functionality is limited to registration - does not do any deep schema validation and docs are limited about how to use it with Kafka SDKs.
What we like: It’s very fast! The focus on performance really shows - launch speed, memory, insertion latency are all best in class. Supports Vim-mode. Every buffer is a CRDT which allows real-time collaboration like Google Docs. Language server built-in - auto detects based on the file. GitHub Copilot and OpenAI are built in (opt-in).
What we don't like: Basic Git support. macOS only. Very minimalistic - it’s still early in development so many of the features you might expect from VS Code or JetBrains are missing. But if you want a simple text editor-like experience with the necessary bits from an IDE, it’s in a good state.
What we like: Can bring in the context of your entire codebase when providing answers. Can generate suggestions based on code smells, performance optimization, adding docstrings or improving variable names. Can explain code, generate release notes, and summarize recent changes. Will also write code for you e.g. unit tests.
What we don't like: Limited to the web, VS Code or JetBrains IDEs.
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: It’s fast - launches within ~2 seconds vs Docker Desktop > 10 seconds. Speediness also extends to launching containers - uses Rosetta x86 emulation and modern i/o APIs on macOS to optimize performance. Native UI. Also supports creating Linux VMs with Intel emulation. Very low CPU usage.
What we don't like: Obviously macOS only. Doesn’t fully implement all Docker Desktop features e.g. directly browsing container files is not implemented in the UI.
What we like: Trigger a JS/TS function on a time interval (Vixie Cron syntax) or once on a specific date. Configure max runs, timezone, intervals between executions. Overrun protection. Can query the status (next run, is running, is stopped, etc) and control it (trigger, pause, resume) once initialized. Runs in Node, browser & Bun.
What we don't like: Runs entirely in memory - great to have no dependencies, but does mean there’s no persistence of state (which may not matter for idempotent cron triggers).
What we like: Preview environments for your entire app - frontend, backend, database, and any other containerized service. Spins up new environments on PRs or on-demand. Use for testing, QA, or demos. Access logs and monitoring stats. SSH into the environment for debugging. CLI to create and manage environments.
What we don't like: Only way to configure environments is via Docker Compose, although this does mean the preview environments match your local environment (and hopefully prod, too).
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Provides hints for commands before you run them. Understands complex data formats like JSON and tables to allow navigation and highlighting. Built-in scripting support. In-line spell checking and autocomplete. Error handling and debugging built in - use try/catch blocks, descriptive error messages.
What we don't like: Windows is supported, but not fully - recommendation is to run it within WSL.
What we like: Describe task steps in YAML and it executes them. Designed to be very simple, but supports advanced features like including other task files, dependencies, variables, platform specific commands. Doesn’t re-run commands if the output hasn’t changed. Easy to install in CI. Single (Go) binary. Open source.
What we don't like: Reports of high CPU usage if watching large numbers of files e.g. a node_modules directory. This is an optional mode used to watch and rerun tasks if the file changes.
What we like: Instant setup with easy schema-definition and predefined or custom field types - full access to all Postgres types. CSV import & export. Spreadsheet-like UI for searching, filtering, editing rows. Get a connection string for remote access. Query via SQL from within a Retool app. Redundancy & backup handled for you.
What we don't like: Designed for small use cases that don’t require high availability or scalability e.g. internal tools where it’s not a good use of time to manage your own database. Initial quota matches this - 5GB storage (can be increased on request).
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Static (Go) binary to search code in the current directory. Default mode is to launch a TUI, but the CLI can also take parameters and output the results. Supports exact matching, fuzzy matching, negations, and regex. Can output in text, JSON, or vimgrep. Understands .gitignore.
What we don't like: No installable packages for Mac (binaries aren’t signed, which means a bit of extra work to pass the macOS security). Designed to just work rather than for maximum performance (but it’s still very fast).
What we like: Generic library which makes it easy to build autocomplete. Keyboard navigation available out of the box. You only need to provide a container for the autocomplete and sources for it to get items from. Sources can be static e.g. links, or dynamic e.g. searching a database. Made by, but does not require, Algolia’s search product.
What we don't like: Designed specifically to solve autocomplete, which may be part of search, but can cover other use cases as well e.g. a command bar. This means it doesn’t provide a library of UI components - you’re in charge of building the UI.
What we like: Create & switch between isolated environments with all dependencies managed for you, powered by Nix. Abstracts away a lot of the hassle of using Nix. Makes it easy to deal with various platforms and CPU architectures. Easily bootstrap identical dev and prod environments. Can containerize any environment
What we don't like: Great if all the packages & dependency versions you need are already available on Nix. If not, Nix has a steep learning curve.
What we like: Easy to store, retrieve, and serve objects. Replication strategy can be defined when storing an object. Efficient for lots of small objects. Supports tiered storage in the cloud. Optionally supports directories, TTLs, mounting FUSE drives. You can use the API to serve objects publicly. Static (Go) binary.
What we don't like: Using it more than a key/value like object store requires a separate component which uses a database to persist metadata - this can be in-memory (but no persistence) or supports various datastores - but is an extra layer to manage.
What we like: Simulate a browser accessing a URL to retrieve screenshots, metadata (Open Graph, Twitter, JSON+LD, oEmbed & HTML), convert to PDF, track speed using Lighthouse. Provided as a managed API with a CLI, but it’s made up of various open source components they maintain so you can always run them yourself.
What we don't like: SDKs are JS-only (React, Vue, JS), so you need to use the API from other languages.
What we like: Generates boilerplate Node.js code for APIs (REST & GraphQL), data models, database, auth, and an admin UI. You own all your code (open source) so can customize or diverge. Changes to the framework are sync’d to your codebase via Git & PRs. Plugins make it easy to add other functions e.g. changing the database or adding Kafka.
What we don't like: Admin UI is not customizable. Only supports Docker-based deployments - other options are on the roadmap.
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Lightweight zero-dependency type validation for TypeScript (or JS) in Node or the browser. Gives you the power of types at runtime, not just when writing code e.g. checking responses from APIs or from user inputs. Supports complex types including datetimes, IP addresses, objects, functions, etc. Large ecosystem of uses e.g. JSON to Zod, Zod to OpenAPI.
What we don't like: The docs assume you know why you would want to use this, which isn’t completely clear until you experience the benefits.
What we like: Write functions in Python, TS, Go, Bash, or a Docker image and have them executed based on triggers (schedules, via a UI, webhooks, CLI, Slack). Supports step function flows with branching, loops, and error handling. Web IDE, local dev CLI, secrets, state & dependency management. Cloud or self-hosted.
What we don't like: Limited ability to scale past 100 parallel workers. Has a higher cold start latency than other serverless worker platforms e.g. AWS Lambda.
What we like: Provides user signup, login, and role-based authorization flows. Supports social logins, SSO, SAML, multi-tenancy & passwordless login methods. SDKs for most languages & tech stacks, with REST APIs for everything else. Can integrate with API gateways like Kong and AWS API Gateway. Can be self-hosted or cloud hosted.
What we don't like: WebAuthn and passkeys are only available in more expensive plans. Default UI looks a bit dated, so you will want to customize it.
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Send things into the pastebin via SSH and get a shareable web URL. No signup required - uses your SSH key. Viewer supports syntax highlighting and markdown parsing. SSH in for a full terminal UI to manage snippets. Each snippet can be set to private with an expiring URL. Can also be self hosted.
What we don't like: Can’t search the snippets once they’re uploaded.
What we like: Write your docs using MDX and React and store them in Git. Layers a nicely designed web UI with dark mode, search & SEO optimization on top. Supports a range of common components like code, callouts, cards, tables, snippets. Includes API documentation from specs like OpenAPI. Has a local dev CLI.
What we don't like: Limited customization options - makes everyone’s docs look the same.
What we like: Build & deploy models from Jupyter notebooks. Provides an inference endpoint accessible via a REST JSON API and from within data warehouses e.g. from SQL, Redshift, or Snowflake. Supports custom environments, packages, tests. Can also run training jobs from a notebook or from Git. Includes logs, monitoring & version control.
What we don't like: Everything is based around Python & Notebooks - this is the standard ML stack, but worth being aware of if you’re using something else.
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Use React & components to build interactive command line interfaces. Built-in components for text, colors, flex boxes, borders, hooks, working with stdin and stderr. Supports CSS-like props, testing and all features of React e.g. Devtools. Various open source components e.g. progress bar, table, form.
What we don't like: There’s a significant productivity gain from using React across web, terminal, mobile, etc, but purists might argue CLIs should be built in a more appropriate language like Go or Rust.
What we like: Save web pages to a single HTML file with all assets embedded - means you can load sites offline (or share them). Options to exclude specific assets e.g. videos or audio. Chrome extension is also available. Written in Rust, so is available as a static binary with packages for all major OSs. Open source.
What we don't like: Has no JS engine, so some sites may be broken or not work at all. You can pipe it through a headless Chromium to act as a pre-processor though.
What we like: Easy to run locally in Docker (1 command to get running). SDKs for Node, Go, Python, .NET, Java to produce and consume messages. Also has a REST API. Supports storage in memory, on disk, and remote e.g. S3. Native cluster mode for redundancy. Built-in web GUI for management.
What we don't like: Common queue protocols (AMQP, MQTT) are on the roadmap. Clustering requires k8s.
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Single binary CLI which triggers a notification when the process completes. Prefix the command with noti or attach to an already running process. Local notifications by default, but also supports services like Slack, Telegram, Twilio, or speech. Works on macOS, Windows, and Linux. Open source.
What we don't like: Packages only for macOS (Homebrew) - Windows and Linux need to download the binary. No official binaries for ARM.
What we like: Intercepts remote APIs via a proxy, storing the responses so they can then be simulated. Modify the API behavior locally e.g. mocking responses for testing. Supports sequenced requests and state across requests. Introduce chaos e.g. latency or status code randomization. Static binary. Open source.
What we don't like: Getting started docs are unclear. Native language bindings only for Python and Java, but you don’t really need them (they just make a few things easier, like HTTPS).
What we like: Build complex workflows with triggers from third-party apps (AWS, forms, SaaS, APIs, etc), webhooks, cron, email, and others. Process data and create conditional branching with filters and loops. Take actions with the results e.g. send to Slack, create calendar invites, trigger other functions. Drag & drop UI and write JS code. Cloud or self-hosted.
What we don't like: Cloud-hosted version requires a credit card for free trial signup. Cloud instances don’t auto-update to newer versions.
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Provides an orchestration layer and web UI for installing and managing self-hosted services. Provision databases and common apps like Ghost, MinIO & Plausible Analytics. Includes pre-packaged setup for common frameworks (NextJS, Deno, Laravel) and languages (PHP, Python, Rust). Can also run generic Docker containers. Open source.
What we don't like: Runs on a single server, which is great for self-hosting non-critical apps, but you then have to deal with server admin, updates, and scaling it yourself.
What we like: API-compatible with both Redis and Memcached, but with performance and scalability improvements. Benchmarks ~1ms P99 latency. Supports Redis and HTTP protocols. Includes an HTTP console & Prometheus metrics endpoint. Scales up to 1TB memory per instance and shards across CPUs. Single binary. Cloud & self-hosted.
What we don't like: Targets Redis 5 API compatibility - other versions in progress.
What we like: Supports classic feature flagging with targeting rules, but also enables experimental A/B testing, gated permissions, and ops rules to handle slow-rollout of backend changes. Separate by prod, staging, dev, environments. Feature opt-in allows users to manage their own involvement. Has both client and server-side SDKs.
What we don't like: Dark mode is available, but it’s hidden behind a beta feature flag! No Rust SDK.
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Free & open source library of UI components including form fields, navigation, data display, and layouts. Looks good (including auto-dark mode) out of the box. Fully customizable on each component and/or through global themes. Includes accessibility features. Extensive docs and examples.
What we don't like: Not yet at v1, but approaching stability. Missing some components you might expect e.g. full app containers and certain UI containers.
What we like: Nothing to install - just curl the URL e.g. curl cht.sh/ls to get the cheat sheet for the ls command. Can also be queried by appending a search term after. Also covers programming languages & databases e.g. ask how to open a file with Golang with curl cht.sh/python/open+file
What we don't like: There is a locally installable client, but it requires Python 2 and doesn’t install on Apple Silicon systems. Better to stick with the web client.
What we like: Developer focused log-style entry note format makes it quick to add time stamped notes as you’re working on things. Keyboard optimized, with optional vim keybindings. Tiny mode can float on top of all your other windows for easy access to manage notes. Attach code, images or make notes todo items. Use offline or with cloud sync. Markdown formatting.
What we don't like: Notes stored in a database on-disk, but can be exported to JSON. Theme doesn’t switch based on system settings (have to manually toggle dark or light mode).
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Toolchain helps manage protobuf APIs. Single library provides full gRPC support, but also allows usage of gRPC compatible HTTP clients for both HTTP1 and HTTP2. Useful where non-HTTP clients don’t yet work, such as in WebAssembly or Edge runtimes. Can generate both client and server SDKs. Drop-in OpenTelemetry.
What we don't like: Docs have no search. Some clients still in beta e.g. Node.
What we like: Combines frontend and backend SDKs to provide end-to-end session replay and error tracing. Backend logging integrations link up to the relevant user session for easier debugging. Records network activity & console logs. Supports data masking for privacy. Open source so can be self-hosted, or use the cloud version.
What we don't like: Can’t track WebSockets. Frontend session tracking has some client overhead (11kb bundle). The UI has no dark mode.
What we like: Generates type-safe and idiomatic SDKs from your API specs for Go, TS, Java, Python & PHP. Can output them to GitHub (individual or monorepos). Output can be customized e.g. adding comments, changing class names, custom HTTP clients. Automates generation in CI and publishing to package managers. Provides API key management & dev portal.
What we don't like: Only supports OpenAPI v3 specs or JSON schema files.
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Execute commands and define desired state across many remote machines, containers, or locally. Can install packages & manage config files. Understands groups, roles, multiple environments & typed actions against databases, firewalls, Git, etc. Can integrate with Terraform, WinRM, Docker, Ansible, and others. Extendable with Python.
What we don't like: Use of Python means it doesn’t require an agent, but obviously means it requires the Python runtime environment locally (remote side only requires a shell) and must be configured in Python.
What we like: Create self-hosted remote dev environments locally (Docker) or in the cloud (GCP, AWS, Azure, Digital Ocean, k8s). Connect via VS Code, JetBrains, SSH. Create workspace templates via Terraform. Connect via port forwarding and share URLs using P2P WireGuard or Coder-provided relays. Supports dotfiles & secrets. Browser GUI or CLI.
What we don't like: Common issues with remote dev environments include latency and inability to work offline, but are these just edge cases? Requires some work to get Docker in Docker set up or you could use a full VM instance per workspace.
What we like: Internal tools as code - write scripts, workflows, dashboards, custom UI for internal tasks. UIs are built using React. Connects to resources like databases & APIs. Provides infrastructure for logging, permissions, approvals, notifications, etc. Supports multi-step tasks & scheduling. Supports local development and self-hosting.
What we don't like: Limited language runtime support (TS, JS, Python, Shell, Docker). The UI doesn't support dark mode.
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Docs written in Markdown (MDX, with React component support). Built on top of Next.js. Native support for docs concepts like sections, tabs, callout, syntax highlighting. Supports server side generation from remote sources e.g. GitHub star count. Static search. I18n support. Dark mode. Open source.
What we don't like: Design customization is somewhat limited - you need to create a custom theme from scratch if you want to do more than minor tweaks.
What we like: Supports load testing and functional (assert) testing of APIs, message brokers, ecommerce systems, etc. Supports HTTP, WebSockets, Socket.io, HLS, file uploads, and other protocols via plugins. Reports p50, p95, p99, min and max. CI/CD runners to conduct continuous testing. Test scenarios written in code. Open source + cloud platform for distributed tests.
What we don't like: Can integrate with Playwright for headless browser testing, but this is experimental and the primary use case is backend testing.
What we like: Aggregates observability data from multiple sources (CloudWatch, Prometheus, Datadog, Grafana, etc) to calculate Service Level Objectives. Normalized data across sources - powerful query language for accessing the right data. Can be configured in code (YAML, Terraform, OpenSLO standard) or via the UI. Visual service health map dashboard view.
What we don't like: UI has no native dark mode. Can be complex to set up from scratch (docs provide useful examples and templates for some platforms e.g. k8s).
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Self-hosted. Each step is isolated and runs as a container. Define the commands in a config file in your repo with any Docker image as the context. Uses a persistently mounted volume to pass input/output files through the steps. Flexible conditional execution, supports matrix builds, services e.g. databases. Backed by SQLite by default.
What we don't like: Limited pre-built images and plugins - smaller ecosystem than GitHub Actions, for example. Self-hosting is the point, but it does mean you have to run and manage everything yourself.
What we like: Replaces cat. Supports syntax highlighting and has a Git integration showing modifications in the gutter. Includes line numbers (by default, can be disabled) and a pager. Detects non-interactive usage and turns off all the fancy features for full cat compatibility. Single, open source Rust binary with packages for most platforms.
What we don't like: Line numbers get in the way of copy/paste, so you need to remember to launch it with the -p plain flag as needed.
What we like: Create forms visually with simple flows or more complex logic e.g. variables or conditional steps. Integrations for submitting data to databases e.g. Postgres, webhooks, Slack etc. Also supports signup and login flows (Stytch & Firebase). Drop in with JS or use a React component to fully customize the form.
What we don't like: Can be integrated using a React component, but the config is in the cloud not your code. No UI dark mode.
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Write event-based background tasks in TypeScript to be triggered by webhooks, custom events, or scheduled. Supports delays, run once, trigger via a separate SDK. Runs as a Node process inside your infra so can connect to private resources. Integrates with Slack, GitHub, Notion. Partly open source.
What we don't like: You run the workflow code yourself, but triggers are via their SaaS platform which can’t (currently) be self-hosted. Workflows can’t yet be run on serverless platforms like Lambda or Vercel.
What we like: Insert into any pipe to provide a visual progress bar. Shows data transfer rate, time taken, percentage complete, and completion ETA. Supports multiple pipes to show progress between them all. Can optionally limit data transfer rate. Supports all major Unix-like OSs. Open source.
What we don't like: Latest release is Sep 2021, but it seems stable so that’s probably not an issue. Some reports of unreliability if backgrounded.
What we like: Uses TypeScript and integrates with (abstracts) common headless browsers like Puppeteer & Playwright which makes it easier to keep scripts up to date. Manages queuing, storing results, scaling & proxies. Extensive docs and examples. Open source.
What we don't like: Primarily designed to run locally (or in Docker), but there is a commercial SaaS option for hosting and scaling in the cloud.
Interesting Tools by email
Our free weekly newsletter picks out the 2-3 most interesting tools. See the latest email