Console
Developer tools reviews
Each week Console reviews the best tools for developers.
✦ Disclosure: All reviews are editorially independent and partners must meet our selection criteria.
Interesting Tools by email
Our free weekly newsletter picks out the 2-3 most interesting tools. See the latest email.
Join 25k+ developers
What we like: ELT-like sync from source(s) to destination(s). Sources can be APIs e.g. AWS or GCP resources, SaaS e.g., HubSpot, PagerDuty, or infra e.g. Terraform, Vercel. Destinations can be databases e.g. Postgres, SQLite, or cloud e.g. S3. Full sync or incremental changes. Typed fields. Option to maintain old records or remove them. Open source.
What we don't like: Concurrency may need to be tweaked to avoid rate limits when syncing resources, but this will increase sync times. Incremental sync only supports local state.
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Library to provide structured errors in JS/TS. Set props on errors with typed fields. Wrap, aggregate, normalize errors. Core library provides base functionality which can be extended via plugins. Official plugins for specialist cases: CLI (colorized, pretty print, verbosity levels), HTTP (structured HTTP responses), clean stack traces, and others. Open source.
What we don't like: JS/TS only. Be sure to configure TS to output ES modules, not CommonJS.
What we like: Minimalist CLI designed just to make it easier to navigate directories i.e. a replacement for `cd` and `ls`. Fuzzy search makes it navigating through the directory tree very fast. Shortcuts to preview, delete files, and exit with or with navigating to the directory. Prebuilt binaries for Mac, Linux, Windows. Open source.
What we don't like: Requires a workaround to work properly in PowerShell. Have to trigger fuzzy search on every directory change.
What we like: Impressive level of UI flexibility and customization - simple drag & drop to writing custom JS & React with external dependency support. Auto-generates UIs from database schemas including those tedious features like sorting, pagination, filtering & search. Real browser devtools-like debugger. Can also build native mobile apps and automated data pipelines & workflows.
What we don't like: Themable, but no true dark mode. Remotely querying databases over the internet has inherent latency challenges (you can self-host Retool or use their cloud database).
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Generate honeypot files (Word, Excel, PDF, executables) and tokens (AWS) which send alerts when triggered e.g. when a file is opened or the API credentials are used. Also supports DNS record, MySQL dump and other types of honeypot tokens. Email or webhook URL notifications. Provides another layer of detection e.g. from malware scraping credentials from laptops. Free service.
What we don't like: Token types are more-or-less sufficient, but somewhat limited e.g. only supports AWS tokens (Slack tokens were deprecated).
What we like: Easily take input from stdin or a specified file then plot a graph in the terminal. Supports bar, line, scatter, box plots, histograms and density plots. Minimal setup needed - assumes first column is x axis and second column is y axis, but this is configurable. Can handle real-time data. Uses default terminal colors. Open source.
What we don't like: Does not support time series. No static binary - installed via Ruby gem.
What we like: Enables code to live where it belongs - alongside code (in Markdown). Auto-syncs as you refactor, rename, move code around. Comments on PRs when docs break. Supports Mermaid syntax for diagramming. IDE extensions (VS Code, JetBrains) reveal docs in-context with code. Editor supports dark mode.
What we don't like: Need to edit the docs using their editor (or the Markdown directly). In-IDE doc authoring is on the roadmap.
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Replaces `less`, `more`, or `tail -f` with more features for parsing text - section delimiters, search, mark position, color highlights, and parsing of columnar text. Mouse support with proper select + copy to clipboard. Keyboard shortcuts. Guides for replacing the pager in other CLIs e.g. psql, git, mysql, procs.
What we don't like: Reads the entire file into memory. Default keybindings are different from `less`, so if you rely on them it’s not a drop-in replacement.
What we like: Provides a dev environment for creating email templates in React - local dev server with previews and a built-in sender for dynamic rendering at runtime. Supports MJML for creating responsive emails that are compatible across clients. Sending API wraps Nodemailer, which has lots of useful features. Open source.
What we don't like: Unclear whether it runs properly on Windows (there’s an open GitHub issue about this).
What we like: Provides team and task management workflows within Slack. Understands team load to provide warnings when the team might not complete tasks within a sprint. Shows whether team members are overloaded with tasks, including tasks outside the sprint or assigned to others.
What we don't like: Only supports workflows using Slack, JIRA, and GitHub.
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Simple commands to cut, copy and paste. Supports pipe in or out and can read from and write to files (the whole file can be in the clipboard). Use multiple clipboards and show/clear the contents of all. Clipboards exist as temporary files which can be mounted to shared drives to use across systems. Can also make clipboards persistent instead of just temporary.
What we don't like: No support for GUI clipboard manager on Wayland (but supports X11, Windows and macOS system clipboards). Installation defaults to compiling source, but you can download binaries if you prefer.
What we like: Well-documented open standard for defining containerized development environments. Supported by several tools for consistent environments locally and in the cloud. Allows the environment to be versioned alongside the code. Can define resource usage limits, environment vars, endpoints. Samples provided in the open registry.
What we don't like: Very k8s centric even though the spec can be used generically. Another standard (see xkcd 927).
What we like: Point at a directory and it auto-detects file formats, parses, colorizes, merges, and displays them in your terminal. Can pretty print structured data e.g. JSON. Search as you type also streams in new log lines. Sessions can be restored. Query and filter the logs with SQL, which includes “virtual tables” to allow for comments, tags, and bookmarking.
What we don't like: Official downloads don’t include Arm binaries (although the macOS version via Homebrew is compiled for Apple Silicon). Does not inherit the terminal theme - need to configure custom colors separately.
What we like: Fully customizable - fonts, colors, positions, notch size, animations. Can subscribe to general events e.g. space change as well as OS notification events e.g. Spotify track changed, to trigger scripts. Supports graphing arbitrary values. Items can be linked to spaces. Can pull in items from the macOS status bar e.g. Control Center or WiFi.
What we don't like: Config file is a bit fiddly to work with. Community plugins could be more structured - currently just config files + scripts shared in a GitHub discussion thread.
What we like: Makes it really easy to create good-looking blocks for dashboards. Lots of components from graphs to cards, callouts, tables, and toggles. Each component has an API reference. Includes basic application layout and shells. Components are responsive. Open source.
What we don't like: You can choose from 22 different color palettes, but not create custom colors. No dark mode.
What we like: Build a custom dashboard within your terminal. Lots of modules out of the box - IP info, clocks, system status, feed reader, Hacker News feed, GitHub, various monitoring tools, etc. Create custom modules in Go or use a simple command runner module. Customize layout via config file. Cross-platform & open source.
What we don't like: Long config files can be a bit annoying to work with. Some stability issues reported on Windows and if there is no internet connection.
What we like: Makes it easy to deploy a replicated cluster of SQLite backed database nodes. Writes distributed to a quorum or they fail. Provides HTTP API, CLI, and client libraries for Go, Python, Node, Java. Runs in-memory, but backed by on-disk Raft logs to avoid data loss risk. Supports full-text search, JSON documents, encryption, hot backups.
What we don't like: You must use the HTTP API (directly or via client libraries) to get all the functionality. Writes scale vertically - only reads scale horizontally. 2GB database size limit (switch to on-disk to avoid this, but with a write-performance tradeoff).
What we like: Run a serverless function as a background job, in response to an event, on a schedule, or as a webhook. Supports JS and TS with framework integrations for NextJS, Express, Cloudflare Pages & RedwoodJS. Supports multi-step functions. Local dev server. Functions run on your own platform. Open core (paid cloud platform).
What we don't like: Functions written in JS/TS-only (but you can trigger events from any language). AWS Lambda is not yet supported. You need to register functions with Inngest after every deploy (which can be automated).
What we like: Easy to remember commands for building and running containers without having to install/learn multiple tools. Can pull from container registries or build locally (creating an OCI image from a Dockerfile). Supports specifying the platform for running/building for different architectures. Acts as a layer on top of nerdctl so it is effectively Docker compatible, but uses containerd and BuildKit.
What we don't like: macOS only (Windows & Linux are on the roadmap). Docs are limited, so you need to work out the commands from the nerdctl docs.
What we like: Understands infrastructure state to allow parallelized runs and collaboration on infrastructure as code changes. Supports Terraform, Pulumi, Cloudformation, and k8s. Integrates into existing workflows e.g. pull requests. Policies allow RBAC and approval flows, defined using Open Policy Agent. Drift detection. Product has some personality e.g. subtle space references in log output.
What we don't like: The docs are well written, but there is a steep learning curve and a UI with lots of components to work out.
What we like: Reads logs from stdin and pipes them back to stdout formatted and easier to read. Also adds colors. Options to skip log keys, ignore keys that are the same as the previous entry, and truncate values. Binaries for macOS, Linux, and Windows.
What we don't like: Only formats logs in JSON or logfmt - everything else is ignored. No ARM binaries.
What we like: Monitors not just service status pages, but also synthetic tests against APIs to check things like creating an S3 bucket, upload objects, access them, etc. Supports cloud (AWS, GCP, Azure) and SaaS e.g. GitHub, Cloudflare, Google Drive. Degraded (average latency has increased) or down (not responding) alerts. Optional agent to test from within your own account.
What we don't like: The Metrist agent can auto discover API calls using eBPF on the OS level. This allows unknown APIs to be monitored, but has some limitations on the traffic it can inspect e.g. outgoing TLS/SSL calls, but only on Linux if they use OpenSSL (dynamically linked).
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Smart caching and tasks distributed across multiple build agents significantly improves build time. Only runs build tasks with changes. Remote caches can be shared. Migration functionality can keep all workspace dependencies up to date for everyone. Built-in task executors support linting, testing, dev servers, etc.
What we don't like: All the examples, docs, core plugins etc, assume you’re working in the JS/TS ecosystem, but it is actually a general purpose build system.
What we like: Define and execute HTTP requests in plain text. Config format makes it easy for anyone to understand and manage. Supports headers, query params, form submissions, APIs, CSRF tokens. Can assert responses for testing e.g. content, headers, JSON body, endpoint performance. Runs as a single binary CLI. Open source.
What we don't like: Uses curl underneath, but doesn’t fully support/expose all the features/options. Hurl syntax is custom, so text editors will struggle to highlight and provide autocomplete.
What we like: CLI or web UI for real time visualization of logs. Supports most log formats and includes predefined config for AWS CloudFront, S3 & load balancers, Apache, Nginx, GCS, Squid, IIS, Caddy. Can export to JSON or CSV. Single binary - point it at one or many log files and it runs. Packages for all major platforms. Open source.
What we don't like: Has limited built-in filtering, but is designed to be composable like any good Unix tool, so you can pipe output through grep, sed, awk, etc.
What we like: iPad optimized version of VS Code integrated into iOS conventions. Can connect to remote environments like Codespaces or SSH to execute code. Blink is a mobile terminal so Blink Code utilizes all of its functionality like using Mosh for reliable connections, customizable shell, keyboard shortcuts etc. Open source.
What we don't like: Needs a large iPad to work well. Great for quick mobile edits, or perhaps when traveling, but full development on an iPad feels like too much of a contortion when a full desktop is so much more flexible
What we like: Install the app (Android or iOS) and POST to the API to send yourself a notification. Can be a very simple message or include custom titles, priority (Android only), scheduled delivery, action buttons, attachments, icons. Also supports email and a CLI for notifications. Free hosted by the author, or open source so you can run your own private server.
What we don't like: Topics are open with read/write access by anyone - access control is supported and you can run your own server to protect it further.
What we like: Follows 12-factor architecture. Separation of concerns with API backend (Python + GraphQL), admin dashboard, and storefront UI (TS + React) all separate projects/instances. Includes GraphQL Playground to make it easy to test API queries. CLI and SDK for custom storefront implementation, or use NextJS template. Open source or run on their cloud.
What we don't like: Storefront and dashboard are static, but the backend APIs need to be managed for scalability. You need to manage your own task runner for background tasks.
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Offloads scripts from the main thread to a separate web worker. Allows third-party scripts to be sandboxed and throttled so the main thread can be dedicated to code you control. Easy to enable on any script via a custom attribute, but known to work well with analytics e.g. Google Tag Manager and support e.g. Intercom. Integrates with major frameworks. Open source.
What we don't like: Network tab shows lots of proxied requests, which makes it a bit noisy. Not suitable for UI intensive scripts due to DOM throttling. preventDefault() doesn’t work.
What we like: All your code needs to do is write to stdout and read from stdin. websocketd deals with managing the websocket endpoint. This means you can add websockets to any application in any language. Single binary runs on all platforms - minimal dependencies (written in Go). Includes WebSocket developer console. Open source.
What we don't like: Designed as a quick and simple way to get websockets working - each connection opens a new process, which may not work well at scale.
What we like: Provides in-line code quality analysis in your IDE as you code. Supports VS Code, JetBrains, Eclipse, Visual Studio. Language specific rules with in-editor docs make it easy to avoid problems e.g. deprecated APIs, complex definitions, useless try/catch branches, etc. Team rules sync. Extensions are open source.
What we don't like: Supports common languages like JS, TS, Python, C, C++, Ruby, Java, PHP, HTML but is missing support for the likes of CSS, Rust and Go.
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Web app or CLI to generate typesafe code from JSON, GraphQL or TypeScript. Supports output in lots of languages e.g. Go, Java, Ruby, TypeScript, Elm, Python, Rust. Can parse from files, schemas, or URLs. Also generates a basic client library. Extensions for VS Code, XCode, Visual Studio. Open source.
What we don't like: IDE extensions haven’t been updated for a few years.
What we like: Minimalist approach - small codebase and focus on simplicity by calling out to shell commands for extra functionality e.g. grep. Supports fuzzy search, syntax highlighting, split views, auto indent. Can be scripted and run in headless mode to run edit commands and output the result. Runs on all platforms with official packages. Open source.
What we don't like: Default keybindings are somewhat intuitive e.g. Ctrl+S for save, but don’t take advantage of the muscle memory from other terminal editors. Help docs are limited.
What we like: Provides endpoint discovery and request monitoring via middleware, which makes it easy to integrate into an existing API. Records API requests for debugging - can be replayed from the dashboard or via a Postman download. API spec drift detection with alerting. Easily create a dashboard for API users to login and review their usage. Sensitive fields can be masked. Cloud or self-hosted.
What we don't like: API integration and instrumentation SDKs only available for Go, Typescript, Java. Self-service API key rotation not yet supported.
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Makes it easy to create tests for web, mobile, email, etc. Layered on top of Python so tests can be coded and then set up using the custom Robot syntax. Flexible configuration and tagging makes it easy to vary tests and associated data. Detailed reports show the full execution log for debugging. Community plugins e.g. for Selenium, databases, REST APIs. Open source.
What we don't like: Yet another custom language to learn. May just be easier to write tests in the same language / framework as your actual codebase.
What we like: Very lightweight stats for your website: visitors, top pages, referrers, etc. Includes automatic bot detection and campaign stats. Tracking JS is very small (3.5 kB) and has the option to use a pixel, trigger from server middleware or import raw logs. Doesn’t track users with IDs. Open source and can be self hosted (written in Go and uses either SQLite or Postgres)
What we don't like: It is very lightweight, so if you’re used to Google Analytics you may be disappointed - but do you really need all that data? No dark mode.
What we like: Makes it easy to build a live-updating web app with a document database. Strictly-typed fully relational schemas defined in code (optional, but recommended). Data mutations are automatically reflected and re-rendered. Built-in dashboard and logging. Can deploy to a hosting provider like Netlify or Vercel, and Convex handles the backend.
What we don't like: TypeScript only. All functions must be deterministic, so you need to call external functions to call third-party APIs e.g. Stripe, Vercel functions, etc. Convex provides a client to share the state with those functions.
What we like: Desktop app for searching and browsing technical docs. Large number of available docsets for languages, frameworks, apps, libraries, and packages. Cheatsheets and user contributed docs, including an offline Stack Overflow. Integrates with editors like VS Code, JetBrains, Vim. Add your own private and shared annotations, which can be shared within teams. Quick launch keyboard shortcut.
What we don't like: macOS only - see Zeal, a free, open source alternative for Windows and Linux that uses the same docsets. Images in some docsets still require internet access, e.g. Stack Overflow.
What we like: Designed for very fast data analysis, particularly where whole tables or large joins are involved. Simple to operate - no dependencies and nothing to install because it runs in the host process, thereby increasing performance. Supports complex SQL queries. Fast loading of data from CSV, Parquet, Postgres, SQLite, read/write data from S3.
What we don't like: Not designed for high volume transactional queries or where the database needs to be written to from multiple processes.
What we like: API, SDK, and CLI for creating sandboxed test environments inside your own infrastructure (or locally). Create parameterized templates with dependencies and fine-grained customizations to test changes to one or many services. Spin up environments from integration tests and CI. Supports resource creation e.g. databases or message queues.
What we don't like: Requires Kubernetes. Limited number of resource plugins - MariaDB, Amazon SQS, and RabbitMQ - you need to create your own for anything else.
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Set up connections and SQL queries to databases like MySQL, Postgres, BigQuery, MongoDB, etc. Auto-complete query editor with results browser that can visualize and export data. Desktop app or web interface. Queries can be private, shared, or public. Build dashboards and templated UIs to allow others to easily execute queries safely.
What we don't like: Desktop app not built for Apple Silicon (works via Rosetta 2 translation, but it becomes a bit laggy). Option for direct connections avoids their cloud service, but also means they can’t be used via their web app version i.e. desktop only.
What we like: Pipe the output of a command to get a JSON translation. Or, run in reverse to have jc execute the command and pick the parser automatically. Supports parsing files e.g. YAML, CSV, /etc/hosts. Colorizes output by default. Supports streaming e.g. commands like ping which provide continual output. Tool and parsers open source. Also available as a Python package.
What we don't like: When piping you need to specify the parser - there are lots of options, but not every command is supported.

Semgrep Supply Chain
Semgrep Supply Chain
Find reachable vulnerable dependencies.
What we like: Analyzes your code to determine not just if you have a vulnerable dependency, but also whether your usage triggers the vulnerability. Helps triage dependency security alerts based on vulnerability reachability, rather than just a version comparison. Run via CLI or CI. Can comment on PRs, alert via Slack/email, and optionally propose auto-fixes.
What we don't like: Only analyzes usage of direct dependencies - can still alert on vulnerabilities in transitive or indirect dependencies, but does not yet support detection of their usage relevancy.
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Highlights React components in your browser so you can click to go directly to their source code. Understands NODE_ENV so runs only in dev. Works for most modern frameworks out of the box (React, NextJS, Preact, Solid, Vue, Svelte). Use as a dependency or as a browser extension (all browsers supported). Configurable open path to launch your editor.
What we don't like: Modern React frameworks are supported, but some additional setup is needed with custom webpack configs or Babel. Setting the config in two places can initially be confusing.
What we like: Displays Postgres stats and queries in a real time terminal interface. Toggle running, waiting, blocking queries. Includes system info (CPU, memory, query counters) and on a per query level. Query table can be sorted and refresh paused. Has a special flag for optimized RDS support.
What we don't like: Minimum refresh rate of 0.5s is too infrequent to show fast queries, but those are probably not the ones you’re interested in anyway. Requires superuser to get all the data, but falls back to display what it can without superuser.
What we like: Manage CI/CD, seed data, dev preview environments, and prod infrastructure from a single config file. Makes it easy to spin up new feature branches with duplicate infrastructure in separate cloud projects. Provides VS Code web instances for cloud-based dev against fully configured environments. Supports custom VS Code/vim/emacs configs.
What we don't like: Cloud support limited to AWS and GCP. Assumes you’re using GitHub - GitLab + Bitbucket support on the roadmap.
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Framework agnostic CSS variables with minimalist styling for all HTML elements. Includes dark+light mode. Supports CSS, PostCSS, JSON, or props as Javascript. Covers colors, gradients, typography, animations, media queries, and masks. Available via NPM, CDN, or CLI. Open source.
What we don't like: Docs don’t provide quick “get started” examples, although the GitHub repo has example commands for generating output e.g. PostCSS files or minimized bundles.
What we like: Native (Swift) terminal emulation and SSH client for iPhone/iPad. Generate device specific keys stored in the secure enclave (or sync keys + settings over iCloud). Store a series of commands as snippets for easy execution. Built-in session keepalive via an agent or Tmux. Lots of themes. Env vars. PowerShell for Windows hosts.
What we don't like: Obviously iPhone/iPad only. You can choose the theme, but not customize it.
What we like: Augments OpenTelemetry to integrate logs and remote calls. Traces are visualized step by step, which makes it easier to understand the flow. Splits out each remote call e.g. HTTP or Kafka to show all parameters and attributes. Generates replication code for each call to reproduce issues. Integrates with CI to provide build failure visibility.
What we don't like: Limited number of official SDKs (Go, Java, .NET, JS, Node, Python, Ruby) - for anything else you can manually connect to an existing OpenTelemetry collector.
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Visualizes the output of continuously executed shell commands. Build a dashboard of charts, sparklines, barcharts, gauges, text, and ascii components. Managed via a config file. Perform conditional actions e.g. terminal bell or exec command. Can connect to databases, Docker, and SSH. Open source.
What we don't like: No stable release since 2019, but seems to be under active development.
What we like: Menu bar app to show notifications from GitHub and Linear. Keyboard shortcuts for all actions (including a global keybinding to show the UI). Preview full notification without marking as read. Mute options to filter by user, repo, notification type.
What we don't like: Simply replacing a flood of emails with notifications is not recommended - make sure to use the filters and whether you actually want a desktop notification.
What we like: Single API/SDK for pub/sub, queues, and streaming. Handles global distribution, scaling, and availability with latency-based routing. Client connection recovery with replay and queuing for disconnected clients. Official SDKs for most major languages & compatible with MQTT, AMQP, STOMP, REST, SSE, XHR, JSONP, Kafka, SQS, webhooks, and other integrations.
What we don't like: Beware of the default rate limits - 50/msg/sec per client and 100/msg/sec globally (increased by upgrading the pricing plan). Peak connection and bandwidth limits also apply.
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Web testing with full devtools on multiple devices. Simulate slow/mobile network connections, OS chrome, responsiveness, color schemes, locale, with cursor, nav, input, and scroll sync. Test OG social previews (Twitter, FB, Google, Slack), override fonts and styles. Take screenshots, gifs and videos as if on the device.
What we don't like: Primarily for UI viewport testing - it does not actually simulate the native browser engines. The underlying renderer is Chromium.
What we like: Simple CLI which analyzes code for secrets. Can run on standalone directories or files as well as Git repos. Scanning repos includes the full history - a baseline can be set to scan from, excluding prior commits. Official GitHub action. Open source.
What we don't like: Most useful when combined with the pre-commit hook rather than manual scanning, which must be set up separately (really a Git limitation, but worth mentioning).
What we like: Provides a single user ID for purchases & subscriptions across app platforms (Apple, Google Play, Amazon, Stripe/web). Single subscription backend & mobile SDKs with analytics e.g. customer count, MRR calculation. Event webhooks and data/ETL integrations with third-parties like S3, Firebase, Intercom, Slack to take actions on subscription events.
What we don't like: Web SDK is via REST endpoints - no Python, Go, TypeScript SDKs. A/B testing of product/pricing options in private beta.
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Secure Git-like method of syncing .env secrets. Team access with permissions per environment makes it easy to give access to different resources. Direct sync with infra e.g. Vercel, Netlify, GitHub, AWS, or dotenv CLI. Version history for secret values allows for rollbacks. VS Code extension.
What we don't like: Only the JS/TS library is official - libraries for other languages are available, but developed by third parties.
What we like: Full terminal emulator with built-in SSH client. Configure themes, fonts, scrollback, bell, and shortcuts. Built-in tabs and splits (which are remembered with session history on restart). Quake mode global shortcut to show/hide terminal. Notify on process completion. Cross-platform + web client (beta). Open source.
What we don't like: Can be laggy, especially on startup. Memory intensive.
What we like: Drop-in spreadsheet-like UI for Firestore. Typed fields e.g. dates, checkboxes, uploads, Markdown, JSON. Supports cloud functions workflows on field changes. Integrates with SendGrid, BigQuery, Twilio. Can pull in data from HTTP endpoints or import CSVs. Table/field-level RBAC. Dark mode. Open source.
What we don't like: Only runs on Firestore (Postgres & MongoDB on the roadmap) which means it only supports GCP. Actions managed by Rowy can’t use npm - have to use Google’s callable functions instead.
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Fulltext search without any backend infrastructure - indexes the output of static site build process i.e. the HTML. Integrate with your site using a provided UI component or with the JS API. Supports string or array filters and search across multiple sites. Static binary with no dynamic dependencies.
What we don't like: Compatibility issues with WASM and Content Security Policies means you need to set script-src to ‘unsafe-eval’ for full browser support (mainly lagging on Safari).
What we like: Inspect, tail, write to, or redirect events in message queues. Supports a wide variety of queues e.g. Kafka, RabbitMQ, SQS, NSQ, GCP Pub/Sub. Pipe messages into the queue. Can decode various message formats in real-time e.g. protobuf, JSON, etc. Single binary for macOS, Windows, Linux.
What we don't like: Limited docs for getting started e.g. connecting to backends requires passing IDs via CLI options or manually setting different environment variables. The --help flag provides useful details.
What we like: Easy, but flexible CLI for running scripts as commands, which are stored in a `justfile` i.e. per project/directory. Commands can take arguments and load .env files. Write commands in arbitrary languages e.g. JS, Python, Ruby. Editor plugins for Vim, VS Code, JetBrains, etc. Proper error handling. Works on Mac, Linux, Windows.
What we don't like: Assumes existence of `sh` on all platforms, but can be set to use something different e.g. PowerShell.
What we like: Run independent backups that would otherwise be a pain to deal with e.g. offsite AWS, GCP, DO volumes, MySQL, MongoDB, Postgres databases. Serverless backup runner or hosted on your own instances. Bring your own storage e.g. S3 (or any compatible), Google Drive, Dropbox. Can also backup apps like WordPress and repos from GitHub.
What we don't like: Encryption is a premium feature. Missing support for some managed database features e.g. serverless export on Google Cloud SQL to avoid degrading the primary instance.
What we like: Real-time view of your k8s cluster in a TUI. Provides a high level view of deployments, sets, pods, jobs, volumes, CPU, memory, etc. Drill-down views with more details and related resource usage. Log streaming view. Run commands e.g. scale, shell, kill. Keybindings, plugins, themes. Works on Mac, Linux, Windows.
What we don't like: Generally expects the latest version of k8s and sufficient RBAC permissions, otherwise it may not work properly. Log output is quite raw and difficult to read.
What we like: Generates visualizations of code relationships to help understand how the codebase works. Create visual tours of code to help onboard new engineers or document functionality. Maps are posted to pull requests like a visual diff of what was changed and can be used to tour the changes in logical order. Maps auto-update with commits.
What we don't like: No dark mode. Only supports JS, TS, Python, Java, Go.
All reviews are editorially independent, and partners must meet our selection criteria.
Postgres Playground, from Crunchy Data
Postgres Playground, from Crunchy Data
Postgres in the browser.
What we like: A full Postgres instance compiled to WASM and running in your browser. Provided as an ephemeral playground which makes it easy to test commands and learn how things work. Several tutorials provided, including for features like partitioning and PostGIS. Interact via psql CLI.
What we don't like: No persistence. Browser sandboxing prevents any other connection method.
What we like: Hooks into your shell to auto-load/unload environment variables when you cd into a directory. Loads a simple .envrc file in each directory. First-run in each dir asks for permission to mitigate malicious execution. The .envrc file can just be a list of exports, but it is also a bash script which allows you to execute other code. A useful stdlib of utility functions is provided.
What we don't like: Aliases and functions not exportable due to how direnv loads the environment from a sub-process back into the original shell.
What we like: Combines markdown notes with a collaborative whiteboard. Developer specific components such as code blocks, browser frames, tech related icons, and sequence and entity relationship diagrams defined in code. Notes can link to specific areas of canvas. Keyboard commands for most actions. Signup not required.
What we don't like: No dark mode. Images can be exported with a solid or transparent background, but the solid background is not configurable (it’s always white).
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Can manage schedules from whichever calendar you already use e.g. Google Calendar. Ingests alerts from a wide range of sources including Grafana, Prometheus, AWS, New Relic, Datadog. Handles rotations, overrides, upcoming shift notifications, and escalations. Configs can be managed in Terraform. Open source.
What we don't like: Limited chat integrations (Slack, Telegram, MS Teams). More advanced features e.g. auto-create Zoom bridge & Slack room, take incident notes, timeline reports are in a separate product that is in private preview.
What we like: Supports Cloudflare Workers, Deno, Bun, Fastly, plus anything else that supports Web Standard API, which makes it simple to use and (mostly) works cross-platform. Built-in middleware for auth, cache, CORS, JSX, logs, JWT, JSON and static assets. Written in TS so you get proper types. Open source.
What we don't like: There are some minor differences between platforms, such as the JWT middleware not being supported on Bun.
What we like: Automate chaos testing in k8s, Docker, and Linux environments. Run experiments such as shut down instance or pod, simulate packet loss, drop DNS requests, and stress CPU. Control what is affected by attributes such as cloud zone, pod name, % of containers, etc. Simulate rippling outages across multiple applications. Trigger and monitor tests via CI/CD.
What we don't like: Weak spot analysis not supported on GCP. Windows hosts are not supported.
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Provides a suite of tools for creating flame graphs, profiling CPU, GC, memory allocation, and async calls. Docs do a good job of walking through what the output means and how to solve common problems. Visualizes how async calls chain together and where time is spent. Open source.
What we don't like: NodeJS only. Not supposed to run in production, so doesn’t help with prod-related issues.
What we like: Easier to work with than UUIDs e.g. you can double click and copy them from a URL. Uses more (configurable) characters than UUID so the ID size can be reduced (also configurable). Faster to generate than UUID. Collision probability can be calculated based on config values so you can trade off usability for chance of collision. Available for lots of languages.
What we don't like: If you need to (effectively) guarantee uniqueness then UUID is better. Can’t take advantage of specialist database types e.g. UUID in Postgres.
What we like: Config is defined in a TS|JS|YML file in your code repo. Query caching is automatic, but can be made smarter by syncing the schema (via CLI or CI). Fine-grained cache rules per type or field. Cache invalidation can be based on TTL or mutations. Supports query batching without any server-side changes.
What we don't like: There are some size limits to be aware of e.g. 40KB maximum query size and 10MB response cache limit. Empty responses are also not cached. No support for rate limits.
What we like: Simple CLI to run scripts across multiple Git repos or all repos in an org. Can run a shell script or run code through a runtime e.g. Python or node. Clones the repo, runs the script, then submits a PR with the changes. Can run against branches. All configurable e.g. PR title and description. Open source.
What we don't like: Requires some kind of Git host - GitHub, GitLab, Gitea, BitBucket.
What we like: Builds on standard web APIs e.g. Fetch and Form rather than custom implementations. Clear separation between client and server with strong preference for server-side rendering. Progressive enhancement - JS not required. Performance focused by only reloading what has changed. TypeScript by default. Accessibility built in.
What we don't like: Some libraries / modules don’t work where they assume they run in the browser or a full Node environment. There are workarounds, but this can be a constraint.
What we like: New passwordless feature enables WebAuthn e.g. Apple TouchID, FIDO keys, etc, to authenticate users. Users can be provisioned on demand e.g. assuming a particular role with restricted permissions. “Just in time” access requests via tickets (JIRA) or chat (Slack) for approval flows. All this helps implement concept of least privileged access. Open source.
What we don't like: Windows Hello only supports Web UI, not terminal access. Teleport Connect local GUI offers an easy way to access all resources, but is Mac only.
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Very lightweight and minimalist. Syntax highlighting for lots of formats. Basic content parsing e.g. highlighting matching braces. Supports splits. Has themes, or just uses macOS default look. Text editing features like outline, snippets, smart substitutions. Implemented in Swift and open source.
What we don't like: Default font is Helvetica - nice for plain text, but feels strange for code.
What we like: Auto-detects which package manager you should be using from npm, yarn, pnpm, or bun. Supports install, run, execute, upgrade, uninstall, and clean install which adds common arguments for each of the supported package managers. Also has an alias command so other raw commands can be executed.
What we don't like: Assumes lockfiles exist to detect the right package manager (why would you not be using a lockfile?). Requires some tweaks with PowerShell on Windows which has a conflicting command name.
What we like: Single view of all assets across AWS, GCP, Azure, k8s, Datadog, Okta. Highlights (and can alert on) assets not managed by IaC e.g Terraform or that have drifted from the expected state. Auto-generates Terraform and Pulumi (TypeScript) code representing those assets. Reports common issues e.g. publicly accessible S3 buckets or instances with public IPs.
What we don't like: Only supports Terraform & Pulumi TypeScript - other languages, CloudFormation and CDK are on the roadmap.
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Provides Git-like commands for data, mapped to SQL e.g. writes are staged, then committed. You can work on branches, diff the working set and revert changes for both data and schema changes. Fully MySQL compatible so any MySQL client will work. Work from a Git-like CLI or with SQL commands that act on system tables or stored procedures.
What we don't like: No support for socket interfaces. Drop database is unrecoverable, but Dolt supports remotes like Git for syncing copies (push, pull, etc) which can be used for restores.
What we like: Easy to use CLI which scans the specified container image for OS and language vulnerabilities. Supports various major container OSs e.g. Alpine, Debian, Distroless, Ubuntu. Scans packages from languages (Ruby, Java, JS, Python, Dotnet, Golang, PHP, Rust). Configurable ignores, output formats, and vulnerability data sources.
What we don't like: If your preferred OS/language isn’t supported, you need to add vulnerability sources to the database - list of sources could be larger.
What we like: SDKs (Node, Ruby, Python, Go, Java, etc) to make it easy to add SSO, MFA, directory sync and audit logs to your app. Also supports email magic links and OAuth via Google & Microsoft. Admin dashboard for your users to configure their SSO settings so you don’t need to build it.
What we don't like: User store is not provided so it needs to sit on top of your existing database e.g. Auth0, Firebase Auth, custom system. GitHub login not supported.
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Auto-generates a REST backend based on your Postgres data schema with TypeScript definitions. Schema designer includes common patterns e.g. foreign key constraints, Postgres Policies for access control, cascading delete actions. Handles schema migrations. Open source.
What we don't like: SDKs only available for JS, TS, React - have to use a REST API for any other language. Does not support JOIN queries.
What we like: Provides remote cloud dev workspaces - SSH and code remotely e.g. with Vim or Emacs, connect your IDE e.g. VS Code or Jetbrains. Forward ports to localhost so runtimes & servers etc can be accessed as if local. Share URLs and setup scripts so environments can be reproduced/accessed by others. Manage via CLI or web UI.
What we don't like: Can’t choose the location of the remote environment, and it’s not clear where they are deployed, which may mean latency becomes a problem.
What we like: Easily copy production databases to dev. Exclude data from certain tables (but maintain the schema). Transform or reduce data to redact private data (replacements are consistent across snapshots) with custom JS. CLI for restoring snapshots to your local DB. Can choose to restore all data or specific tables.
What we don't like: Postgres only. Incomplete docs for advanced data operations like transform, reduce, generate.
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Incredibly lightweight (3MB) because it focuses on just text editing. Good font rendering. Themes and syntax highlighting out of the box. Splits, global find, multi-cursor editing. Command palette. Cross platform - Windows, macOS and Linux. Decent plugin ecosystem. Open source.
What we don't like: The focus on being a lightweight text editor is at the cost of deeper language support out of the box (have to install plugins), autosuggest, built-in terminal, etc. This is the point, of course.
What we like: Makes it easy to manage tags in Terraform from a single CLI. Cascade tags/labels to AWS, GCP, and Azure. All managed via templates so they can be added, updated, removed at any time. Recurse directories of Terraform configs. Open source.
What we don't like: Only has packages for Mac, but binaries available for Windows and Linux.
What we like: Connects to any SQL database and provides an API (REST, GraphQL), JS SDK, a CLI, and a web UI. Provides an analytics dashboard from your data. Configure web hooks on write events. Data flows can trigger on events, transform data, perform actions e.g. send emails, send webhook. Supports SSO & RBAC. Open source.
What we don't like: No WebSockets for the web UI. No support for GraphQL subscriptions.
All reviews are editorially independent, and partners must meet our selection criteria.
What we like: Provides an overview of local and remote origins, tags, submodules and code hosting features like PRs, issues, and CI/CD e.g. GitHub Actions. Use the GUI alongside the built-in terminal, or switch it to CLI-first, which provides enhancements like a visual tree view and autocomplete/suggest. Supports Mac, Windows, Linux.
What we don't like: Working with private repos is a paid feature.
404 Tools Not Found. Try changing the filters.
Interesting Tools by email
Our free weekly newsletter picks out the 2-3 most interesting tools. See the latest email.