Developer Utilities
Free online developer utilities — JSON/SQL/XML/YAML formatting, regex testing, crontab, chmod, Docker, and Git references. Runs entirely in your browser.
Developer Utilities
- Git Commands Cheat Sheet — Git is a decentralized version management software. With this cheatsheet, you wi
- Random port generator — Generate random available port numbers in the range 1024–65535. Useful for setti
- Crontab generator — Visually build crontab expressions with a point-and-click interface. Auto-genera
- JSON Formatter & Validator — Format, validate, and beautify JSON online. Paste minified or messy JSON and get
- JSON Minify & Compress — Minify and compress JSON data by removing all whitespace, indentation, and line
- JSON to CSV Converter — Convert JSON arrays to CSV format online with automatic column header detection.
- SQL Formatter & Beautifier — Format and beautify SQL queries online. Supports MySQL, PostgreSQL, SQL Server,
- Linux chmod Permissions Calculator — Calculate Linux/Unix file permissions visually. Select read, write, and execute
- Docker run to Docker compose converter — Convert docker run CLI commands into docker-compose.yml files automatically. Pas
- XML Formatter & Beautifier — Format and beautify XML code online with proper indentation and syntax highlight
- YAML Formatter & Beautifier — Format and validate YAML code online with proper indentation and syntax highligh
- Email Address Normalizer — Batch normalize and deduplicate email addresses with support for Gmail + aliases
- Regex tester — Test regular expressions with real-time match highlighting, capture groups, and
- Regex cheat sheet — A comprehensive regex cheat sheet with common patterns for email, URL, phone, da
Developer Utilities Guides
More Development Guides
- React State Management in 2026: Context vs Zustand vs Redux Toolkit
- Frontend Architecture Patterns: Feature Slices, Component Libraries, and Scalable Codebases
- JavaScript Promises and Async/Await: The Complete Visual Guide
- Linux Terminal Productivity: Commands, Shortcuts, and Tools Every Dev Needs
- Advanced Docker Patterns: Multi-Stage Builds, Layer Caching, and Security Hardening
- Kafka Streams Real-Time Analytics: Stream-Table Joins, KTable, Window Aggregations, and State Stores
- TypeScript + React Best Practices: Typing Components, Props, and Hooks
- Building a REST API with Node.js and Express: Complete 2026 Guide
- Kubernetes for Beginners: Pods, Deployments, Services, and Your First Cluster
- Kubernetes Production Patterns: Health Checks, Resource Limits, RBAC, and Observability
- Data Pipeline Testing Strategies: Quality Checks, Great Expectations, Contract Tests, and CDC Testing
- Python Virtual Environments: venv, conda, and pyenv Explained
- TypeScript Advanced Types: Generics, Conditional Types, and Template Literals
- OpenSearch Full-Text Search: Index Design, Aggregations, Relevance Tuning, and High Availability
- React Hooks: Common Mistakes and How to Fix Them
- Python Type Hints: A Practical Guide With Examples
- Data Lakehouse Architecture: Delta Lake ACID Transactions, Time Travel, and Schema Evolution
- TypeScript Utility Types: Partial, Required, Pick, Omit and More
- JavaScript Prototype Chain Explained: Inheritance Without Classes
- Apache Airflow in Production: DAG Design, Dynamic Tasks, XCom, and Celery Executor
- Async/Await Error Handling: Every Pattern You Need
- Software Design Patterns in JavaScript and TypeScript: A Practical Guide
- dbt Data Transformation Guide: Models, Testing, Incremental Builds, and Documentation
- Redis Caching Patterns: The Complete Guide for Backend Developers
- Apache Flink Stream Processing: Event Time, Windows, State, and Exactly-Once Semantics
- TypeScript Utility Types: Partial, Pick, Omit, Record, and More
- React Server Components Deep Dive: How RSC Actually Works Under the Hood
- Apache Spark Data Engineering: DataFrames, Optimization, and Production Best Practices
- TypeScript Advanced Type Patterns: Conditional Types, Mapped Types, and Inference
- Pydantic v2 with FastAPI: Validation, Serialization, and Type Safety
- Database Design: Normalization, Denormalization, and When to Break the Rules
- Mobile App Security Best Practices: Pinning, Secure Storage, and Code Protection
- API Rate Limiting in Node.js: Token Bucket, Sliding Window, and Redis Strategies
- OpenAPI 3.1 Specification-First APIs in Node.js with Validation
- Scalable WebSockets in Node.js: Socket.io, Scaling with Redis, and Load Balancing
- Bun Runtime: Migrating Node.js Apps for 3x Performance
- PlanetScale and Vitess: MySQL Scaling with Database Branching
- Neon Serverless PostgreSQL: Scale to Zero and Branch Your Database
- Building Hybrid Apps with Capacitor: Native Plugins and Web-to-App Migration
- Node.js Authentication: JWT vs Sessions — Complete Implementation Guide
- Elixir Phoenix LiveView: Real-Time Apps Without JavaScript
- Hono.js: Ultra-Fast APIs for Edge Runtimes (Cloudflare Workers, Deno, Bun)
- Redis Caching Patterns in Node.js: Cache-Aside, Write-Through, and More
- Database Connection Pooling: PgBouncer, HikariCP, and Application-Level Pooling
- Vector Databases with pgvector: Semantic Search in PostgreSQL
- Expo EAS Build and Deployment: From Development to App Store
- Serverless Node.js on AWS Lambda: Performance, Cold Starts, and Patterns
- Django REST Framework in Production: Authentication, Throttling, and Deployment
- Java 21 Virtual Threads: Project Loom for High-Concurrency APIs
- DynamoDB Single-Table Design: Access Patterns and GSI Strategies
- TimescaleDB: Time Series Data in PostgreSQL
- Android Jetpack Compose Deep Dive: State, Animation, and Performance
- Apache Kafka with Node.js: Event Streaming for Microservices
- tRPC: End-to-End Type Safety for Full-Stack TypeScript Apps
- Prisma ORM Advanced Patterns: Transactions, Middleware, and Raw Queries
- ClickHouse for Analytics: Fast Aggregations on Billions of Rows
- Prisma vs Drizzle ORM: Choosing the Right TypeScript ORM in 2026
- Elasticsearch Full-Text Search: Mappings, Queries, and Relevance Tuning
- Swift Concurrency in Practice: async/await, Actors, and Structured Concurrency
- Rust Axum Web Framework: Build Fast, Safe REST APIs
- GraphQL API Design Best Practices: Schema-First Development in 2026
- gRPC with Node.js: Build High-Performance APIs Beyond REST
- Supabase: PostgreSQL with Superpowers — Auth, Realtime, and Edge Functions
- Zero-Downtime Database Migrations: Patterns and Strategies
- Linux Performance Analysis: USE Method, perf, eBPF, and System Profiling
- PWA in 2026: Service Workers, Offline-First, and Modern Install Experiences
- Python asyncio Advanced Patterns: Concurrency Without Threads
- Go REST API with Clean Architecture: Gin, GORM, and Dependency Injection
- MySQL 8.x Performance Optimization: Indexes, Query Cache, and InnoDB Tuning
- SQLite in Production: WAL Mode, Concurrent Writes, and Scaling Strategies
- Prometheus + Grafana Monitoring Stack: From Setup to Production Alerts
- AWS ECS Fargate: Deploy Containerized Apps Without Managing Servers
- Flutter Advanced State Management: Riverpod 2.0 Deep Dive
- Docker Compose for Local Development: Hot Reload and Service Orchestration
- Node.js Performance Optimization: Profiling, Clustering, and Worker Threads
- Spring Boot 3 + WebFlux: Reactive APIs with Project Reactor
- Redis Advanced Data Structures: Streams, HyperLogLog, and Probabilistic
- MongoDB Aggregation Pipeline: From Basic to Advanced
- GitHub Actions CI/CD: Complete Pipeline for Node.js with Docker and Kubernetes
- Terraform for AWS: Infrastructure as Code from Zero to Production
- React Native Performance Optimization: Hermes, New Architecture, and Beyond
- Bash Scripting: Automation, Error Handling, and Best Practices
- NestJS Microservices: Build Scalable Distributed Systems
- FastAPI Production Deployment: Docker, Gunicorn, and Nginx
- PostgreSQL Performance Tuning: Indexes, Query Plans, and Configuration
- Docker Compose for Production: Multi-Service Apps, Secrets, and Health Checks
- Kubernetes Deployment Strategies: Rolling, Blue-Green, and Canary
- Kubernetes Resource Optimization: VPA/HPA Configuration, Resource Requests and Limits, Node Affinity, and Cost Optimization
- Google Cloud Run: Serverless Containers That Scale to Zero
- SRE Incident Management: On-Call Rotation, Post-Mortems, SLO/SLI/SLA Definitions, and Error Budget Management
- AWS Lambda Node.js: Cold Starts, Layers, and Production Patterns
- Terraform State Management: Remote State, State Locking, Workspaces, and Modular IaC Best Practices
- MySQL Performance Tuning: Indexes, EXPLAIN, and InnoDB
- OpenTelemetry Distributed Tracing: Auto-Instrumentation, Custom Spans, Sampling Strategies, and Jaeger Integration
- Redis Pub/Sub, BullMQ Job Queues, and Rate Limiting
- Docker Image Security: Multi-Stage Builds, Non-Root Users, Image Scanning, and Dockerfile Best Practices
- PostgreSQL Full-Text Search: tsvector, GIN Indexes, and Rankings
- ArgoCD GitOps in Practice: App Sync, Multi-Cluster Management, ApplicationSet, and Rollout Strategies
- Node.js Streams: Process Large Files Without Memory Issues
- Prometheus and Grafana Production Setup: Scrape Config, Alerting Rules, and Dashboard Best Practices
- GraphQL API with Node.js: Apollo, DataLoader, and Subscriptions
- GitHub Actions Advanced Workflows: Matrix Strategy, Custom Actions, Cache Optimization, and OIDC Authentication
- FastAPI + Async SQLAlchemy 2.0: High-Performance Python APIs
- Building Production CLI Tools with Rust: clap, async, and Cross-Platform Packaging
- Spring Boot 3 + Java 21: Microservices with Virtual Threads
- Building Go Microservices with gRPC: Streaming, Interceptors, and Load Balancing
- NestJS: Building Scalable Node.js APIs with Dependency Injection
- Rust Systems Programming Patterns: Zero-Cost Abstractions and FFI
- Go Generics in Practice: Type Parameters, Constraints, and Real-World Patterns
- Rust Async Programming with Tokio: Building High-Performance Web Services
- Go Performance Profiling: pprof, Benchmarks, and Memory Optimization
- Rust Ownership in Practice: Building Memory-Safe Systems Without Fear
- Go Concurrency Patterns in 2026: Goroutines, Channels, and Structured Concurrency
- Module Federation in 2026: Building Micro-Frontends with Webpack and Vite
- Frontend Observability: Real User Monitoring, Error Tracking, and Performance Budgets
- CSS-in-JS vs Tailwind vs CSS Modules: Choosing the Right Styling Solution in 2026
- TypeScript Advanced Patterns: Conditional Types, Template Literals, and Branded Types
- React Performance Optimization in 2026: memo, Concurrent Features, and Profiling
- Playwright End-to-End Testing: Page Object Model, Visual Testing, and CI Integration
- Vitest Unit Testing: From Setup to Advanced Mocking and Coverage
- Vite Build Optimization: Code Splitting, Tree Shaking, and Production Performance
- Deno 2.0: Modern JavaScript Runtime vs Node.js - Migration and Comparison
- Web Workers for Parallel JavaScript: Optimizing CPU-Intensive Tasks
- LLM Fine-Tuning Guide: LoRA, QLoRA, and PEFT in Real Projects
- LangChain Production Patterns: Agents, Memory, and RAG Best Practices
- Vector Databases in Production: Pinecone, Qdrant, and Chroma Selection and Optimization
- LLM Prompt Engineering: From Basic Techniques to Advanced Chain-of-Thought
- Cloudflare Workers Edge Computing: Building Globally Distributed Applications
- Terraform in Production: Modules, Remote State, and GitOps with Atlantis
- WebAssembly Performance Guide: From WASM Core Concepts to Production Deployment
- Building LLM Applications with RAG, Function Calling, and Production Patterns
- Elasticsearch in Production: Indexing, Search Relevance, and Cluster Operations
- Kubernetes Helm Charts: Templating, Values Management, and GitOps with ArgoCD
- Redis Streams, HyperLogLog, and Probabilistic Data Structures in Production
- PostgreSQL Query Optimization: EXPLAIN ANALYZE, Indexes, and Schema Design
- MongoDB Schema Design Patterns: Embedding, Bucketing, Time-Series, and Validation
- ClickHouse Analytics: Schema Design and Query Optimization at Petabyte Scale
- Core Web Vitals 2026: INP, LCP, CLS Optimization and Real-User Monitoring
- PgBouncer: Scaling PostgreSQL to 10,000+ Concurrent Connections
- Flutter State Management with Riverpod 2: Architecture and Testing Patterns
- PostgreSQL Advanced Indexing: Partial, Covering, Expression, GIN, and BRIN
- React Native New Architecture: Fabric, JSI, and Performance Optimization
- Zero Trust Architecture: From Theory to Production Implementation
- OpenTelemetry in Production: Distributed Tracing, Metrics, and Log Correlation
- Kubernetes Security Hardening: A Production-Grade Guide for 2026
- gRPC with Go: Protocol Buffers, Streaming, Interceptors, and Production Patterns
- Redis Distributed Caching: Patterns, Pitfalls, and Production Strategies
- API Gateway Patterns: Rate Limiting, Auth at the Edge, and Request Aggregation
- Event-Driven Microservices: Kafka, Saga Pattern, and Eventual Consistency
- Service Mesh with Istio: Traffic Management, mTLS, and Observability at Scale
- FastAPI in Production: Auth, Caching, Background Tasks, and Kubernetes Deployment
- Python Async Programming: Mastering asyncio for High-Performance Applications
- Building Production ML Pipelines with Scikit-Learn: From Prototype to Deployment
- Python Data Science with Pandas: From Raw Data to Actionable Insights
- ML Model Deployment with Kubernetes and Seldon Core
- Time Series Forecasting with Python: ARIMA, Prophet, and Neural Networks
- Data Preprocessing and Feature Engineering for Machine Learning
- RLHF and Constitutional AI: Aligning LLMs with Human Preferences
- NLP with Transformers: Text Classification and Named Entity Recognition
- Computer Vision with PyTorch: From Training to Production Deployment
- LLM Evaluation and Benchmarking: Testing AI Models in Production
- AI Image Generation: Stable Diffusion API and ComfyUI Workflows
- OpenAI API Production Patterns: Structured Outputs, Caching, and Cost Optimization
- Regular Expressions: Practical Patterns for Real-World Problems
- Vector Embeddings and Semantic Search: From Theory to Production
- Makefile for Modern Development: Task Automation and Project Management
- MLOps: Building Production ML Pipelines with MLflow and Kubeflow
- API Testing: Postman Collections, k6 Load Testing, and Contract Testing
- Terminal Productivity: tmux, zsh, fzf, and Modern CLI Tools
- Fine-Tuning LLMs with LoRA and QLoRA: Practical Guide
- VS Code Productivity: Essential Extensions and Keyboard Shortcuts
- Kotlin Coroutines and Flow: Async Programming for Android and Backend
- Building LLM Agents: Tool Use, Memory, and Multi-Step Reasoning
- Advanced Bash Scripting: Functions, Error Handling, and Automation
- Monorepo Architecture with Nx and Turborepo: Setup and Best Practices
- Python Async Patterns with FastAPI: Background Tasks, WebSockets, and Streaming
- Docker Development Workflow: Compose, Multi-Stage Builds, and Dev Environments
- Docker Compose for Production: Multi-Service Apps, Health Checks, and Secrets
- Building Production RAG Systems: Retrieval-Augmented Generation Complete Guide
- GraphQL Best Practices: Schema Design, DataLoader, and Performance
- AWS Lambda Advanced Patterns: Cold Starts, Layers, and Power Tuning
- NestJS Microservices: Building Scalable Service Architecture
- Vim and Neovim Mastery: Editing Speed and Plugin Ecosystem
- Go Concurrency Patterns: Goroutines, Channels, and sync Primitives
- Building Kubernetes Operators with Go: Automate Complex Workloads
- Deploying LLMs in Production: Inference, Caching, and Cost Control
- Git Advanced Workflows: Rebase, Cherry-Pick, Bisect, and Stash Mastery
- Advanced TypeScript: Generics, Conditional Types, and Template Literals
- PostgreSQL Advanced Performance Tuning: Indexes and Query Optimization
- SRE Fundamentals: SLOs, Error Budgets, and Reliability Engineering
- GraphQL Federation: Unified Schema Across Microservices
- Bun: The Fast All-in-One JavaScript Runtime and Toolkit
- TypeScript Monorepo with Turborepo: Shared Code and Incremental Builds
- Deno vs Node.js: A Practical Comparison for 2024
- PostgreSQL JSONB and Full-Text Search: Replacing Elasticsearch for Many Use Cases
- gRPC with Node.js and TypeScript: Streaming and Protocol Buffers
- CI/CD Pipeline Best Practices: Fast Feedback and Safe Deployments
- Elasticsearch: Full-Text Search, Aggregations, and Mapping Design
- Kubernetes Networking: Ingress, Services, and Network Policies
- SQL Window Functions: RANK, LAG, LEAD, and Running Totals
- Data Pipelines with Apache Airflow: DAGs, Operators, and Production Tips
- Chaos Engineering: Testing System Resilience with Chaos Monkey
- Feature Flags and Progressive Delivery: LaunchDarkly and Unleash
- Event Sourcing and CQRS: Complete Implementation Guide
- API Gateway Patterns: BFF, Aggregation, and Cross-Cutting Concerns
- Infrastructure as Code with Terraform: Modules, State, and Best Practices
- Message Queues: Kafka vs RabbitMQ - When to Use Which
- Serverless Architecture: Patterns, Pitfalls, and Best Practices
- Node.js Performance Profiling: Finding and Fixing Bottlenecks
- Web Performance: Core Web Vitals Optimization Guide
- Observability: Distributed Tracing with OpenTelemetry and Jaeger
- Load Balancing: Algorithms, Health Checks, and Session Affinity
- CDN and Edge Caching: Strategies for Global Performance
- Database Sharding: Strategies and Implementation Patterns
- Microservices Communication: REST, gRPC, and Message Queues
- System Design: Distributed Rate Limiter
- System Design: Building a URL Shortener at Scale
- Jest Testing in TypeScript: Mocking, Async Tests, and Coverage
- Prisma ORM: Type-Safe Database Access in TypeScript
- AWS Lambda Best Practices: Cold Starts, Layers, and Cost Optimization
- Docker Compose for Development: Multi-Service Local Environment
- Kubernetes Deployments: Rolling Updates, Health Checks, and Resource Management
- GraphQL Schema Design: Best Practices and Real-World Patterns
- OpenAI API Integration: Chat Completions, Streaming, and Function Calling
- WebSockets and Real-Time Features with Node.js and Socket.io
- TypeScript Error Handling: Result Types and Never Pattern
- Agile Engineering Practices: Beyond Scrum Ceremonies
- Managing Technical Debt: Strategies for Sustainable Development
- MongoDB Aggregation Pipeline: Complex Data Processing
- Continuous Delivery: Blue-Green, Canary, and Rolling Deployments
- Software Architecture Patterns: Layered, Hexagonal, and Clean
- Redis Advanced Patterns: Pub/Sub, Streams, Lua Scripts, and Rate Limiting
- Observability: Logs, Metrics, and Traces for Node.js
- PostgreSQL Performance Tuning: Indexes, EXPLAIN, and Query Optimization
- Feature Flags: Implementation and Management at Scale
- Logging and Observability in Node.js: Structured Logs with Pino
- Documentation as Code: ADRs, API Docs, and Living Documentation
- Dependency Injection in TypeScript: Manual and Container-Based
- Trunk-Based Development: Continuous Integration Done Right
- Async Patterns in Node.js: Promises, async/await, and Concurrency
- Monorepo Architecture with Turborepo: Scaling Frontend Projects
- Caching Strategies for Backend Applications: Redis Patterns
- Dependency Injection and IoC Containers in Node.js
- Microservices Patterns: Circuit Breaker, Retry, and Bulkhead
- Event-Driven Architecture with Node.js: Patterns and Implementation
- Event-Driven Architecture: Patterns and Implementation
- API Versioning Strategies: URL, Header, and Content Negotiation
- REST API Design Principles: Building Intuitive APIs
- Refactoring Legacy Code: Safe Strategies and Techniques
- Refactoring Techniques: Improving Code Without Changing Behavior
- Code Review Best Practices: Giving and Receiving Feedback
- Clean Code Principles: Writing Readable and Maintainable Code
- Test-Driven Development: Red-Green-Refactor in Practice
- Domain-Driven Design (DDD) with TypeScript: Practical Implementation
- Domain-Driven Design: Practical Implementation Guide
- Test-Driven Development (TDD): Red-Green-Refactor in Practice
- Gang of Four Design Patterns in TypeScript
- Design Patterns in TypeScript: Factory, Observer, Strategy, and More
- SOLID Principles in TypeScript: Practical Examples
- SOLID Principles in TypeScript: Practical Examples
- Vite Build Tool: Configuration and Performance Optimization
- nvm and Node.js Version Management: Best Practices
- Git Hooks: Automate Code Quality with Pre-commit and Pre-push
- strace, lsof, and ps: Linux Process and System Debugging
- tmux: Terminal Multiplexer Mastery
- jq: JSON Processing in the Command Line
- curl and wget: HTTP Debugging and API Testing from CLI
- pnpm Workspaces: Monorepo Management Guide
Crypto & Security Tools
Converter Tools
Web Developer Tools
Image & Video Tools
Network Tools
Math & Calculator Tools
Measurement Tools
Text Tools
Data Tools