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: Consumer & B2B SaaS auth APIs, with separation of top-level org as a unit of multi-tenancy. This allows different configs & users per org within the same top-level project. Supports social auth, magic links, passkeys, SSO, SCIM. Also includes RBAC permissions. Customizable JWT claims. Management UI has dark mode.
What we don't like: Device fingerprinting features aren’t available self-service. Missing some popular language SDKs e.g. PHP, Rust, .NET.
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Caches calls to NPM which makes resetting Node projects much faster on subsequent downloads. Particularly good for containerized applications where you regularly prune containers for a fresh dev environment. Runs as a lightweight container. Can override public packages.
What we don't like: Need to be careful how you specify the private registry otherwise it will be written to the package lock and break remote builds/deploys.
What we like: Generates idiomatic Go code based on your database schema and desired queries. Translates SQL to type-safe Go code. Interface to the generated code feels like proper Go. Can run static analysis on schema changes to detect breaking changes across the codebase. Useful tools to help ensure codegen is up to date and highlights SQL anti-patterns. Open source.
What we don't like: No support for cloud databases like BigQuery or ClickHouse (there is currently a waitlist). Primarily supports Go, but has some experimental plugins for Python and TypeScript.
What we like: Builds Docker images in the cloud rather than on your local machine. Links to Docker Desktop & CLI for transparent usage. Shared cache within a team speeds up builds for all users. Managed multi-arch builders for AMD & ARM platforms. Smart layer caching only builds what’s changed. Also integrates with CI.
What we don't like: Currently only running in US East so if you transfer lots of files in the build steps, latency and bandwidth can become a bottleneck. More regions on the roadmap. No web UI for managing what’s in the cache - can purge from the CLI.
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Use any runtime - Node, Bun, Cloudflare Workers, Vercel, Lambda, etc - with a (mostly) consistent API abstraction. Zero dependencies. Uses the Web Standard API. Supports sophisticated routing configurations, middleware, client components, validation, RPC. Includes a testing framework.
What we don't like: Environment variables can’t be accessed outside of the handler. Some features are limited by the runtime e.g. WebSockets only work on Cloudflare, Bun & Deno.
What we like: Build tasks and workflows in code (currently Python, Go, TS). Each stage of a workflow is independent and can be run durably and retried without losing progress so far. Run your own workers so you control underlying resources, location, and data privacy. Manage concurrency and rate limiting of steps to control resource consumption. Cloud service, but you can also run the control plane yourself.
What we don't like: Is Postgres appropriate for a distributed task queue? Seems to be, and it’s likely already part of your stack (or you’re using a managed service).
What we like: Flexible approach to building authorization logic with a DSL. No need to rely on a single centralized service - centralize the logic, which can return “yes, if” for validation with local data. Makes it easier to reason about complex auth across microservices. SDKs for Node, Python, Go, Ruby, and .NET. Check in your auth .polar files to Git.
What we don't like: Default model uses Oso Cloud, but there are options for self-hosting and running a hybrid cache layer for HA.
What we like: Creates & manages virtual environments and installs packages into them. Makes it easy to manage devtools, libraries, runtimes without conflicts. Handles dependency management for any installed packages. Easy to share environments with other people. Environments can be defined declaratively in a config file.
What we don't like: Uses Nix behind the scenes which is both great (declarative language for package management), but also quite complex to understand if you want to build your own packages.
What we like: Visual, browser-based editor for designing database schemas. Supports MySQL, PostgreSQL, SQLite, MariaDB, SQL Server, plus object relational databases with JSON schemas. Create templates for common designs. Export the results to SQL to actually create the database from your work. Free, open source, you can host it yourself.
What we don't like: Limited import support for existing databases - currently only from MySQL.
What we like: Single (Rust) binary for managing dotfiles. Works cross-platform with OS specific config options. Sync across machines with Git. Supports yaml, toml, or json config files. You can create files from templates using the Handlebars syntax. Configs can have dependencies before they are installed. Open source.
What we don't like: Relies on the system-installed Git. Supports distinction between OSs, but not distros within OSs e.g. commands for different Linux distros.
What we like: Generates API docs from your OpenAPI/Swagger file. Runs through an LLM to also generate detailed guides alongside the reference. Design can be customized with access to CSS variables. Includes an editor for real-time collaboration on the generated output. The generator and the output are open source, so you can self-host or use their hosted docs service.
What we don't like: No support for other types of APIs e.g. gRPC & Protobuf.
What we like: Simplifies publishing workflows for npm packages. Performs lots of useful checks like checking for the release branch, clean working directory, running tests, etc. Handles version bumps, GitHub releases, packaging, tagging. Includes 2FA. Handles rollbacks in case of failure.
What we don't like: Doesn’t support monorepos. Designed as an interactive CLI rather than as part of an automated workflow e.g. in CI.
What we like: Scale Postgres horizontally by configuring shards. Wire protocol compatible so all existing clients work - they don’t need to be shard aware. Includes connection pooler so you can replace PgBouncer et al. Can run multiple routers for HA. Live config reloading.
What we don't like: Doesn’t support cross-shard queries. Docs are limited - no quick start guide, but browsing the example configs gives you an idea of how to get going.
What we like: 3.0 release includes new layout components (box, flex, grid, section, container), new colors, and new components (skeleton, spinner, etc). Type safe via component props rather than utility classes e.g. as in Tailwind. Radix is a multi-layer framework so you can always get at the unstyled React primitives, icons, and colors.
What we don't like: This is a component library so you don’t get pre-built app/site layouts. Components don’t give easy customization options because they’re designed to fit into themes/color palettes, but you can get access to the CSS variables to create custom components.
What we like: Makes it easy to build sophisticated text editing features like undo, real-time collaboration, history tracking & versioning, and conflict resolution of multiple edits. Available as a Rust library as well as a JS package which uses WASM. Allows offline editing.
What we don't like: API is not yet stable so they don’t recommend using it in production.
What we like: Drop-in web UI for managing and observing Kafka clusters, topics, connectors, consumer offsets, etc. Easily edit & reprocess messages. Graphing and alerting on topics & partitions. Cluster managers can set up self-service for developers with different environments. Proxy gateway enables ACLs, RBAC, auditing, encryption, masking, load balancing.
What we don't like: You need to manage the console and gateway deployments by running the Conduktor container somewhere - no easy managed service.
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Download a URL to a single HTML bundle. Embeds all the assets into the file so it can be loaded offline (or more likely, when those resources disappear or change). Options to exclude assets like videos and audio. Can block domains e.g. to block ads or other included resources. Single binary CLI.
What we don't like: Requires a preprocessor if you want to save pages which use JS to load data after the initial page load.
What we like: Underlying platform for running containers (with Podman Desktop as a GUI). Now supports the latest macOS VM framework. Pasta networking backend now the default allowing rootless / unprivileged connectivity. Supports various OCI formats for running various containers. Simplifies k8s locally.
What we don't like: You may need to migrate to the new format if you were using the previous machines functionality.
What we like: Easily interact with APIs - manipulate requests, params, response. Build collections with different environments which are stored in a plain text markup language locally. Supports reading secrets. Includes scripting support for complex API interactions. Also has a CLI.
What we don't like: No sync of collections is a deliberate philosophy vs alternatives which makes collaboration harder, although you can just sync them via Git.
What we like: S3 compatible API so all your existing S3 tooling works as a drop-in. Key differentiator is the auto-migration & caching of objects to the region where they’re most used. Fixed pricing globally and no internet ingress or egress fees. Buckets are private by default (supports signed URLs), but can be public.
What we don't like: It’s built on and integrated with Fly, but has no visibility in the Fly web dashboard (only the CLI). Tigris has its own rudimentary web UI, but this really is a CLI/API first initial release.
What we like: Well designed native macOS app focused on Git diffs. Easily compare files and branches. Visual commit
What we don't like: macOS only. Does not support custom syntax highlighting themes.
What we like: Modern, open source package registry for JS/TS modules. ESM-only. Supports multiple package managers inc. npm, yarn, pnpm, Bun, Deno. Secure publishing workflows by default. Auto API doc generation and scoring to encourage best practices. Open source.
What we don't like: Requires a compatibility layer for npm. Forces you to use TypeScript and ESM, but it’s 2024 so this is also something we like!
What we like: Continually runs in the background, watching Rust files for warnings or errors. Also runs tests. Sits in your terminal. Configurable commands and watch directories. Supports .gitignore. Can run multiple instances e.g. for different build targets. Nvim plugin available. Open source.
What we don't like: Has some overlap with what you may already have in your editor e.g. rust-analyzer in VS Code.
What we like: CLI to export data from one source database and load it into another. Lots of different sources & destinations e.g. Postgres to DuckDB, SQLite to BigQuery, etc. Supports various incremental loading strategies - append, merge, delete+insert.
What we don't like: Requires specifying the source and destination tables - doesn’t copy the whole database schema.
What we like: Lots of integrations for ingesting alert triggers. Built-in notifications for email, SMS, phone, mobile app. On-call management, scheduling, escalations. In-bound phone option to route to on-call responder. Slack & Teams ChatOps. Create hosted status pages with custom domains.
What we don't like: Status page can be set to dark mode, but the main UI cannot.
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Easily access core Git commands via an interactive terminal interface. Supports most common commands with keybindings to quickly work through tasks. Inspired by Magit.
What we don't like: Still early in development, but has common commands implemented. Needs to be installed via Rust’s cargo - no packages yet.
What we like: Integrates with Git, Tmux, and your editor to manage the project file tree. Preview files with syntax highlighting, file fuzzy search, run commands across the project, explore the files with support for show/hide hidden files and .gitignore. Keybindings and custom command support.
What we don't like: Sections can’t be configured. Hasn’t had a release for a while.
What we like: Minimal setup required to get detailed cost reports. Breakdowns by service, account, environment, resource. Segment by team and calculate unit costs. Anomaly detection and notifications e.g. weekly Slack reports. Autopilot auto buys, applies, sells reservations to optimize spend. Terraform provider.
What we don't like: Would like to see additional integrations for other cloud services. Initial data load can take some time if you have a lot of accounts.
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Vendor executables without checking large binaries into source control. Makes it easy to standardize & pin specific dependency versions e.g. Node or an internal-only runtime build. Downloads and verifies the binaries. Can be generated using the included GitHub Actions workflow.
What we don't like: It’s not a package manager and is designed for a single binary. The main limitation of this is the lack of support for installing dependent packages.
What we like: Make text edits across many files in one go. Can be connected to fzf and a highlighter/pager to show the edits visually. Previews the changes by default so you can verify. Or pass a commit flag to make the changes right away. Supports regex replacements.
What we don't like: Requires some additional tools like fzf and a highlighter to improve the UX, but this is really just the Unix philosophy of doing one thing well and deferring to other tools for the rest!
What we like: Serverless access to GPUs for training and inference. Support for pipelining to allow transcriptions & encoding. Access to the latest LLMs and LoRA for fine-tuning. Supports parallel execution, cron jobs, queues. SDK allows easy switching between local and remote calls.
What we don't like: The SDK is Python only. 1s cold start, but you can warm up containers ready to serve traffic.
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Colorizes and highlights various common log formats. Can combine multiple (large) log files. Keybindings for jumping around and triggering search. Search supports regex. Can also tail.
What we don't like: Only available through pip rather than as a compiled binary or via OS packages. Doesn’t work on Windows.
What we like: Introduces concept of virtual branches which work off base and allow simultaneous changesets which can be committed & pushed separately, even in the same file. GUI makes it easy to understand and allows drag & drop of changes to other branches.
What we don't like: You can’t use git branches and virtual branches at the same time - you need to pick one.
What we like: Set of common components for email templates e.g. tables, headings, images, code. Can render Markdown. Components work across all major email clients. Local preview web UI for live development. Supports Tailwind for customization. Can convert existing React components.
What we don't like: VSCode integration and MDX support are on the roadmap.
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Lightweight library to benchmark TypeScript applications. Supports before & after hooks across tasks and globally. Reports stats for each run e.g. min, max, percentiles. Supports listeners on events. Open source.
What we don't like: Doesn’t do anything with the results by default - don’t forget to log or store them somewhere.
What we like: Nice enhancement to the ping command - adds a graph. Alternative cmd flag to measure the execution time of arbitrary commands. Customizable colors. Available from a range of package repos and as a single binary.
What we don't like: Nothing really - it’s a very simple tool.
What we like: Easily implement a globally distributed event gateway without worrying about scaling and redundancy. Direct incoming events to arbitrary destinations. Visual console to inspect requests and results. Options to throttle, transform, filter, delay, and replay event processing. CLI for local development. Pause event processing for maintenance and backfill later.
What we don't like: Rate limit to destination is only configurable as a simple limit per period e.g. 10 per second, with no advanced options.
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Create your own private network for all your devices, servers, environments. Simplify SSH login with auto managed keys linked to your identity provider. Define network rules for who can access what. Access private resources without opening firewalls. Connect ephemeral CI workflows to your network for access to resources e.g. test databases. Clients for all platforms.
What we don't like: Web UI has no dark mode. Configuring tags and ACLs can be confusing and difficult to debug.
What we like: Markdown-like so it’s not something brand new to learn. Built-in headless components like tables, buttons, videos, layout grids. Separates content from design and based around web components. Avoids MDX mixing complex imports and JS. Minimalist progressively enhanced content-first philosophy.
What we don't like: Primarily designed to work with bun, but will also work with pure Node if you prefer. This means access to the full React/TS/JS ecosystem is more limited
What we like: Define secrets in one place and sync them everywhere they’re consumed. Supports different environments for prod, staging, prod, etc. Track versions and change history. Automated rotation for common services e.g. AWS, GCP, Twilio. IDE integration and CLI for launching processes with secrets injected into the environment. Cached for offline use.
What we don't like: CLI works on Windows, but if you’re not using WSL it requires some additional setup. Limited SDKs for retrieving secrets in-code (you have to use the CLI instead).
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Block-based text editor designed for developers - like buffers in other editors. Global hotkey to show/hide. Code is auto-detected, syntax highlighted and auto-formatted. Blocks can run calculations e.g. unit or currency conversions. Runs on macOS, Linux & Windows.
What we don't like: Built with Electron. You can’t really tell, but how does it perform with lots of blocks…?
What we like: Write functions in any language that can be compiled to WASM e.g. Go, Rust, Zig. Tarmac adds platform features like callbacks, logging, k/v store, SQL and HTTP fetching. Functions get exported to WASM then deployed using Tarmac running as a container (or outside of Docker if you prefer). Chain together functions into services.
What we don't like: Official SDK only available for Go (using TinyGo), but you can call out into Tarmac platform primitives from other languages.
What we like: CLI for quickly creating standardized commits in conventional commit format. Define config in a repo JSON file e.g. to define formats and scopes. Can infer types and issue numbers from branches. Colorful interface. Emoji can be used, but also disabled.
What we don't like: Long default CLI name so you’ll want to create an alias.
What we like: Simple route definition with handlers that accept params, request methods, catch all, or more complex route rules. Includes middleware support, a storage layer for abstracting data storage, and a cache API. Handles static assets. It powers the Nuxt framework so is proven in production. Deployment adapters for Edge, Node, Bun, Deno, and lots of platforms.
What we don't like: Great for full stack web applications, but JS is probably not the best choice for a web server in performance-sensitive scenarios.
What we like: Visual representation of how your Rust code is executing with a full call tree. Capture all parameters and return values for all functions. Makes it easier to trace errors through Results so you don’t lose the context of the error. Only traces user code avoiding getting bogged down in libraries.
What we don't like: Only works if you are using Cargo Workspaces. No async Rust support.
What we like: CLI to deploy any containerized app to any server (VM, bare metal, etc). Works with a single or many servers. Handles rolling deploys with health checks. Includes Traefik to proxy traffic to the container. Supports persistence e.g. for databases and volumes. Much simpler than figuring out k8s.
What we don't like: Logs into servers directly (or via a proxy/gateway) over SSH, which means you still need to deal with connection security. You also need to maintain the server OS, unlike a managed k8s where your focus is the container.
What we like: True drop-in replacement for grep - it focuses on the UX to make it easier to search. This means an interactive TUI by default. Lots of small UX tweaks vs GNU grep e.g. matching unicode by default, can search archives like .zip, can search PDFs, docs, and other file formats. Different outputs e.g. JSON, XML.
What we don't like: Not much to dislike! It’s written in C++ rather than Rust, which some might consider vs something like ripgrep, but is that really an issue?
What we like: CLI & GUI to make submitting stacked Pull Requests easy. Auto-restack makes rebasing main into multiple branches a single command. Submit PRs and request reviews from the CLI. Trigger the merge queue from a GitHub tag which handles rebasing, status checks, and then merging sequential PRs with no interaction.
What we don't like: Shifting into a trunk-based model is quite a shift in mindset if you’re not used to a single PR per commit. GitHub only.
What we like: Lightweight web framework for building docs. Built-in client-side search. Customizable code highlighting with support for annotations and diffs. Write using Markdown, Markdoc and MDX. Built on top of Astro so it supports UI components e.g. React, Vue, Svelte, and server side rendering.
What we don't like: Supports Remark and Rehype plugins, but isn’t fully compatible due to how Astro’s rendering works.
What we like: Create web endpoints using Rust, bringing strong typing and robust compiler support to web applications. Routes are normal Rust functions with attributes defining their behavior e.g. as a GET handler. Strong typing of inputs allows for easy validation, typed URIs, and reading data into Rust data types, particularly useful for requiring authentication and defining authorization.
What we don't like: Web development really benefits from fast hot reloading, so the slower Rust compile-times can become a hindrance as a project grows (templates can be reloaded independently without needing to recompile). No support for HTTP/3.
What we like: Sync your shell history between machines - E2E encrypted, or host your own sync-server. Filter by host, directory, fuzzy search. Search from the CLI or use the interactive TUI. Generate fun stats e.g. most used commands (last 24hrs & full history). Import existing history.
What we don't like: Limited key binding customizations.
What we like: Combines ping and traceroute to visualize the network path to a target. Inspect each hop with stats for each, including AS lookup. Analyze the status of each hop with a graph as the tests run. Export JSON, CSV, text. Packages for all major platforms, single binary, open source.
What we don't like: Data shown in the UI columns can’t be customized. Doesn’t measure jitter.
What we like: Like an API gateway, but for databases - provides connection pooling and caching. Can be containerized and exports observability primitives (logging, Prometheus metrics, otel traces). Works at the transport layer so is protocol agnostic, with Postgres as the first supported protocol. Open source.
What we don't like: Currently only supports Postgres.
What we like: Embeddable Rust library with no infrastructure dependencies. Supports ACID compliant transactions. Includes save points and rollback support. Allows for concurrent readers & writers without blocking.
What we don't like: Limited documentation. Only has Rust bindings.
What we like: If you know jq then you can use jaq to manipulate, process, and work with JSON. Focused on simplicity and correctness, avoiding some of the quirks of jq e.g. some crashes and how numbers are handled. Helps to avoid rounding errors. jaq is written in Rust vs jq written in C.
What we don't like: jaq is missing a few jq features like advanced date/time filters and support for streaming. No Linux packages.
What we like: Focused on websites rather than web applications. Means it can optimize for server-side rendering, no-JS by default, and maintain a UI framework agnostic approach. Dynamic islands allow bringing in UI components for interactivity e.g. React, Preact, Vue, etc. TypeScript type-safety for Markdown.
What we don't like: It supports building APIs and other dynamic, interactive components, but the focus is on content. Consider a different framework for pure web applications.
What we like: Create and manage feature flags using the client-side and/or server-side SDKs. Opt in users based on characteristics like OS, location, ID, segmentation, etc. Split groups by percentage to gradually roll out changes. Run A/B tests and track stats/results to determine behavior changes.
What we don't like: Initializing the SDK requires a call to the Statsig service, but you can optionally provide initialization values to avoid this.
What we like: Development mode to help as you build a model e.g. create test cases and data validations. Validate performance and quality of responses. Monitoring mode to help once models are deployed e.g. performance, checking expected responses. Get notifications about problems. Can auto instrument OpenAI calls.
What we don't like: UI doesn’t default to using system settings for light/dark mode. Missing some documentation tutorials.
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Designed to be an easy systems language. Provides low-level control over memory (without GC) whilst still offering safety and avoiding ownership. Uses result types for error handling. Compilation metadata included with source code to avoid needing to rebuild every time. Has a built in module system.
What we don't like: It’s still experimental and some core features like memory management aren’t final yet.
What we like: Makes it easy to launch macOS CI VMs on Apple Silicon. Connects as a self-hosted runner for GitHub, BuildKite and GitLab. Can also run a script to start a runner for other systems. Significantly faster and cheaper than paying for the hosted runners! Open source.
What we don't like: Can’t run multiple VMs in parallel.
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: 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.
Interesting Tools by email
Our free weekly newsletter picks out the 2-3 most interesting tools. See the latest email