Database

Vitest: unit/integration testing, Vite-native, mocking (vi.mock/vi.fn), snapshots, coverage, workspace, in-source testing, benchmark

Better Stack (Logtail) logging — structured log ingestion, live tail, SQL-based querying, alerting, and uptime monitoring

Datadog log management — agent setup, library integration, log pipelines, facets, monitors, and APM correlation

Fluentd unified logging — input/output plugins, routing with tags, buffering, Kubernetes DaemonSet, and Fluent Bit

ELK Stack logging — Logstash pipelines, Elasticsearch indexing, Kibana dashboards, and Filebeat shippers

Papertrail cloud logging — syslog forwarding, live tail, search, alerts, and integration with app frameworks

Pino: fast JSON logger for Node.js — child loggers, serializers, transports (pino-pretty, pino-http), redaction, Next.js integration, and log levels

Structured logging patterns for TypeScript — correlation IDs, request context, log levels, error serialization, sensitive data redaction, and observability best practices

Winston: versatile Node.js logger — transports (Console, File, HTTP), formats, custom levels, metadata, daily rotate file, and error handling

Integrate Apple Push Notification service (APNs) for iOS, macOS, and Safari push delivery. Covers token-based authentication with JWT, payload construction, silent notifications, and HTTP/2 provider API usage.

Integrate Courier notification orchestration for multi-channel message routing. Covers template design, routing rules, provider configuration, user preferences, and the send API across email, push, SMS, chat, and in-app channels.

Engagespot is a multi-channel notification API and in-app feed service. It helps developers send real-time notifications across web, mobile, email, and SMS, simplifying user communication and preference management with a unified API.

Build with Expo Notifications for React Native push notification delivery. Covers device token registration, local and remote notifications, notification handlers, and the Expo Push API for server-side sending.

Integrate Firebase Cloud Messaging (FCM) for cross-platform push notifications. Covers token management, topic subscriptions, data vs notification messages, and server-side sending via the Admin SDK.

Implement Knock notification infrastructure for multi-channel delivery. Covers workflow orchestration, in-app feeds, email, push, SMS, and Slack channels with preference management and batching.

Build with MagicBell for embeddable notification inboxes and multi-channel delivery. Covers the notification inbox UI component, real-time WebSocket updates, server-side sending, user preferences, and category management.

Integrate Notifee for robust local notification management within your React Native applications. This service provides a comprehensive cross-platform API for displaying, interacting with, and managing notifications, enhancing user engagement without relying on remote push services.

Implement ntfy.sh for simple HTTP-based pub/sub push notifications. Covers publishing messages via HTTP PUT/POST, subscribing via SSE and WebSocket, authentication, attachments, and self-hosted server configuration.

Integrate Pushbullet to send real-time notifications, links, and files across all your devices and to other Pushbullet users. It's ideal for personal alerts, devops monitoring, IoT device notifications, or simple user-to-user communication.

Pushover provides a simple, reliable API for sending real-time notifications to your devices. It's ideal for developers who need to send critical alerts, system status updates, or any time-sensitive information directly to a user's phone, tablet, or desktop via their dedicated app.

Integrate Roost for real-time web push notifications directly from your web application. This service simplifies subscriber management, permission handling, and message delivery, allowing you to re-engage users without requiring a native app.

Implement Web Push API with service workers for browser push notifications. Covers VAPID key generation, PushSubscription management, service worker registration, and server-side message encryption with the web-push library.

Integrate Apache Ignite, a high-performance, fault-tolerant distributed in-memory data grid. Leverage its capabilities for caching, database, and processing to achieve extreme scalability and low-latency data access in demanding web applications, making it ideal for real-time analytics, transactional systems, and compute-intensive tasks.

Integrate Cloudflare Workers KV for globally distributed edge key-value storage. Implement eventually consistent caching, static asset serving, and configuration management in Cloudflare Workers and Pages Functions.

Integrate Dragonfly, a high-performance, in-memory data store compatible with Redis and Memcached APIs. Leverage its efficiency for caching, real-time data, and session management, reducing resource consumption and improving throughput for demanding web applications.

Integrate Garnet, Microsoft's high-performance, open-source remote cache and storage system. Leverage its Redis-compatible API for extreme throughput and low-latency data access in demanding web applications, making it ideal for caching, session management, and real-time data needs.

Hazelcast is an open-source in-memory data grid (IMDG) that provides distributed caching, data partitioning, and stream processing capabilities. It's ideal for high-performance, low-latency applications requiring scalable data storage and processing across a cluster, offering both client-server and embedded deployment options.

Integrate KeyDB, a high-performance, multi-threaded in-memory data store compatible with the Redis API. Leverage its architecture for enhanced vertical scalability, caching, and real-time data processing in demanding web applications, making optimal use of modern multi-core CPUs.

Integrate Memcached for high-performance, distributed in-memory caching. Configure connection pooling, consistent hashing, and expiration policies for reducing database load in read-heavy applications.

Implement Next.js built-in caching strategies including ISR, data cache, full route cache, revalidation, and cache tags. Optimize performance using the App Router's caching layers without external services.

Implement TanStack React Query for client-side caching and server state management. Configure stale times, cache invalidation, optimistic updates, and prefetching for responsive data-driven React applications.

Integrate Redis caching into Node.js/TypeScript applications using ioredis. Apply cache-aside patterns, TTL strategies, pub/sub messaging, and connection pooling for high-performance data access layers.

Implement SWR (stale-while-revalidate) for lightweight client-side data fetching and caching in React applications. Configure revalidation strategies, mutations, and global settings for responsive UIs with minimal boilerplate.

Integrate Upstash serverless Redis for edge and serverless applications. Use the HTTP-based REST API for Vercel Edge Functions, Cloudflare Workers, and other environments without persistent TCP connections.

Integrate Valkey, a high-performance, open-source in-memory data structure store. Leverage its versatile data structures and Redis-compatible API for lightning-fast caching, real-time analytics, session management, and message brokering in demanding web applications.

Integrate Vercel KV (Redis-based) for caching and data storage in Next.js applications. Use the built-in SDK for edge-compatible key-value operations, rate limiting, and session management on Vercel's platform.

Integrate AWS SQS for scalable message queuing with FIFO ordering, dead-letter queues, and batch processing. Configure visibility timeouts, long polling, and message deduplication using the AWS SDK v3.

Integrate Celery distributed task queue for Python-based async job processing with Node.js interop patterns. Configure workers, task routing, result backends, retries, and cross-language task invocation via broker protocols.

Integrate Inngest event-driven functions for durable step execution with automatic retries, cron scheduling, fan-out, and concurrency control. Build reliable background workflows in serverless TypeScript applications.

Integrate Apache Kafka event streaming using KafkaJS for high-throughput event pipelines. Configure producers, consumers, consumer groups, and topic partitioning for scalable real-time data processing.

Integrate pg-boss for PostgreSQL-backed job queuing with delayed jobs, retry policies, cron scheduling, and job completion callbacks. Build reliable background processing without external message brokers.

Integrate RabbitMQ message broker using amqplib for reliable async messaging. Configure exchanges, queues, bindings, and routing keys for pub/sub and work queue patterns in TypeScript applications.

Integrate Temporal workflow engine for durable execution of long-running business processes. Configure workflows, activities, signals, queries, and retry policies using the TypeScript SDK for fault-tolerant orchestration.

Integrate Trigger.dev for reliable background jobs in serverless TypeScript applications. Configure long-running tasks, scheduled triggers, webhook handlers, and integrations with built-in retry and observability.

Apache APISIX is a dynamic, real-time, high-performance API Gateway built on Nginx and LuaJIT, designed for managing microservices, securing APIs, and handling traffic routing. Use it to centralize API management, enforce policies, and provide a performant entry point for all your backend services.

Build and manage APIs with AWS API Gateway including REST, HTTP, and WebSocket APIs. Configure Lambda integrations, authorizers, stages, and usage plans with CDK and CloudFormation infrastructure-as-code patterns.

Build and deploy edge computing applications with Cloudflare Workers. Integrate with D1 databases, KV storage, Durable Objects, and R2 object storage using Hono or native Workers APIs for globally distributed low-latency services.

Express Gateway is an API Gateway built on Express.js, offering powerful features for proxying, authentication, rate limiting, and analytics. Use it to centralize API management, enforce security policies, and simplify access to microservices and backend APIs.

Fastify is a highly performant, low-overhead web framework for Node.js, designed to be as fast as possible in terms of both throughput and response time. It emphasizes developer experience, a powerful plugin architecture, and schema-based validation for building scalable and robust API gateways and microservices.

Unify multiple API sources into a single GraphQL endpoint with GraphQL Mesh. Configure handlers for REST, gRPC, OpenAPI, and database sources with transforms, caching, and type merging for federated data access.

Gravitee is an open-source, flexible, and high-performance API Management platform that helps you secure, publish, and analyze your APIs. Use it to centralize API lifecycle management, enforce security policies, manage traffic, and provide a developer portal for API consumers.

Build ultra-fast web APIs with Hono for edge and serverless runtimes. Configure middleware, routing, validators, and RPC mode for type-safe clients across Cloudflare Workers, Deno, Bun, and Node.js environments.

Configure and manage Kong API Gateway for production API infrastructure. Handle plugin configuration, rate limiting, authentication, and service routing with declarative configuration and Admin API patterns.

Build with KrakenD for ultra-high performance API gateways. Use this skill when the project needs to aggregate microservices, transform API responses, apply rate limiting, or create backend-for-frontend patterns with minimal latency.

Configure NGINX as a reverse proxy, load balancer, and API gateway. Manage upstream routing, SSL termination, rate limiting, caching, and security headers with production-hardened configuration patterns.

Deploy and configure Traefik as a reverse proxy with automatic service discovery. Integrate Docker labels, middleware chains, Let's Encrypt TLS, and dynamic configuration for containerized microservice architectures.

Build end-to-end type-safe APIs with tRPC for TypeScript full-stack applications. Define routers, procedures, and middleware with automatic type inference, Zod validation, and seamless React/Next.js client integration.

Design and optimize CircleCI pipelines using orbs, workflows, caching, and Docker layer caching. Covers config.yml structure, executor types, parallelism, and resource class selection for fast builds.

Build and optimize Docker containers with multi-stage builds, Compose configurations, and production best practices. Covers Dockerfile patterns, image security, layer caching, and orchestration with docker-compose.

Configure and optimize GitHub Actions CI/CD workflows. Covers workflow syntax, matrix builds, reusable actions, secrets management, and caching strategies for reliable automated pipelines.