backend-development
mrgoonie/claudekit-skills
Build production-ready backend systems with modern technologies, security best practices, and proven scalability patterns.
What is backend-development?
Comprehensive backend development skill covering API design, authentication, database optimization, security (OWASP Top 10), testing strategies, and DevOps practices. Use when designing APIs, implementing authentication systems, optimizing databases, setting up CI/CD pipelines, building microservices, or developing production-ready backend infrastructure.
- Design and implement REST, GraphQL, and gRPC APIs with proper validation and error handling
- Build secure authentication and authorization systems using OAuth 2.1, JWT, and RBAC patterns
- Optimize database queries, schemas, and implement caching strategies (Redis) for performance
- Implement OWASP Top 10 security mitigations including parameterized queries and rate limiting
- Design scalable microservices architectures with event-driven and CQRS patterns
- Set up CI/CD pipelines, Docker containerization, and Kubernetes deployments with monitoring
How to install backend-development
npx skills add https://github.com/mrgoonie/claudekit-skills --skill backend-developmentHow to use backend-development
- 1.Select appropriate technology stack (language, framework, database) using the decision matrix based on your requirements
- 2.Design your API schema and authentication strategy using REST, GraphQL, or gRPC patterns from backend-api-design.md
- 3.Implement security controls: parameterized queries, OAuth 2.1 + PKCE, rate limiting, and security headers
- 4.Set up database with proper indexing, connection pooling, and migration strategy
- 5.Implement caching layer (Redis) and query optimization following performance guidelines
- 6.Write tests following 70-20-10 pyramid (unit-integration-E2E) with contract testing for microservices
- 7.Configure CI/CD pipeline with Docker, automated testing, and deployment strategy (blue-green/canary)
- 8.Set up monitoring with Prometheus/Grafana and OpenTelemetry tracing for production observability
Use cases
- Designing a RESTful API with authentication, rate limiting, and comprehensive error handling
- Optimizing slow database queries and implementing Redis caching to reduce load by 90%
- Building a microservices architecture with gRPC for internal communication and GraphQL for public APIs
- Implementing OAuth 2.1 + JWT authentication with MFA and session management
- Setting up blue-green or canary deployments with feature flags and Prometheus/Grafana monitoring
- Backend engineers building APIs and server-side systems
- Full-stack developers implementing authentication and database layers
- DevOps engineers designing deployment pipelines and infrastructure
- Architects planning microservices and scalable system design
- Security-focused developers implementing OWASP best practices
backend-development FAQ
Use Node.js + NestJS for fast development, Python + FastAPI for data/ML integration, Go + Gin for high concurrency, or Rust + Axum for maximum performance. PostgreSQL for ACID transactions, MongoDB for flexible schemas, Redis for caching.
Implement Redis caching (90% load reduction), add database indexing (30% I/O reduction), use connection pooling, optimize queries, and implement CDN for static content (50%+ latency reduction).
Follow the 70-20-10 pyramid: 70% unit tests, 20% integration tests, 10% E2E tests. Add load tests, migration tests, and contract tests for microservices. Use Vitest for 50% faster testing than Jest.
Use parameterized queries (98% SQL injection reduction), Argon2id for passwords, OAuth 2.1 + PKCE for authentication, rate limiting, security headers, input validation, and regular security audits.
Use Docker containerization with CI/CD pipelines, blue-green or canary deployments, feature flags (90% fewer failures), Kubernetes orchestration, and Prometheus/Grafana monitoring with OpenTelemetry tracing.
Full instructions (SKILL.md)
Source of truth, from mrgoonie/claudekit-skills.
name: backend-development description: Build robust backend systems with modern technologies (Node.js, Python, Go, Rust), frameworks (NestJS, FastAPI, Django), databases (PostgreSQL, MongoDB, Redis), APIs (REST, GraphQL, gRPC), authentication (OAuth 2.1, JWT), testing strategies, security best practices (OWASP Top 10), performance optimization, scalability patterns (microservices, caching, sharding), DevOps practices (Docker, Kubernetes, CI/CD), and monitoring. Use when designing APIs, implementing authentication, optimizing database queries, setting up CI/CD pipelines, handling security vulnerabilities, building microservices, or developing production-ready backend systems. license: MIT version: 1.0.0
Backend Development Skill
Production-ready backend development with modern technologies, best practices, and proven patterns.
When to Use
- Designing RESTful, GraphQL, or gRPC APIs
- Building authentication/authorization systems
- Optimizing database queries and schemas
- Implementing caching and performance optimization
- OWASP Top 10 security mitigation
- Designing scalable microservices
- Testing strategies (unit, integration, E2E)
- CI/CD pipelines and deployment
- Monitoring and debugging production systems
Technology Selection Guide
Languages: Node.js/TypeScript (full-stack), Python (data/ML), Go (concurrency), Rust (performance) Frameworks: NestJS, FastAPI, Django, Express, Gin Databases: PostgreSQL (ACID), MongoDB (flexible schema), Redis (caching) APIs: REST (simple), GraphQL (flexible), gRPC (performance)
See: references/backend-technologies.md for detailed comparisons
Reference Navigation
Core Technologies:
backend-technologies.md- Languages, frameworks, databases, message queues, ORMsbackend-api-design.md- REST, GraphQL, gRPC patterns and best practices
Security & Authentication:
backend-security.md- OWASP Top 10 2025, security best practices, input validationbackend-authentication.md- OAuth 2.1, JWT, RBAC, MFA, session management
Performance & Architecture:
backend-performance.md- Caching, query optimization, load balancing, scalingbackend-architecture.md- Microservices, event-driven, CQRS, saga patterns
Quality & Operations:
backend-testing.md- Testing strategies, frameworks, tools, CI/CD testingbackend-code-quality.md- SOLID principles, design patterns, clean codebackend-devops.md- Docker, Kubernetes, deployment strategies, monitoringbackend-debugging.md- Debugging strategies, profiling, logging, production debuggingbackend-mindset.md- Problem-solving, architectural thinking, collaboration
Key Best Practices (2025)
Security: Argon2id passwords, parameterized queries (98% SQL injection reduction), OAuth 2.1 + PKCE, rate limiting, security headers
Performance: Redis caching (90% DB load reduction), database indexing (30% I/O reduction), CDN (50%+ latency cut), connection pooling
Testing: 70-20-10 pyramid (unit-integration-E2E), Vitest 50% faster than Jest, contract testing for microservices, 83% migrations fail without tests
DevOps: Blue-green/canary deployments, feature flags (90% fewer failures), Kubernetes 84% adoption, Prometheus/Grafana monitoring, OpenTelemetry tracing
Quick Decision Matrix
| Need | Choose |
|---|---|
| Fast development | Node.js + NestJS |
| Data/ML integration | Python + FastAPI |
| High concurrency | Go + Gin |
| Max performance | Rust + Axum |
| ACID transactions | PostgreSQL |
| Flexible schema | MongoDB |
| Caching | Redis |
| Internal services | gRPC |
| Public APIs | GraphQL/REST |
| Real-time events | Kafka |
Implementation Checklist
API: Choose style → Design schema → Validate input → Add auth → Rate limiting → Documentation → Error handling
Database: Choose DB → Design schema → Create indexes → Connection pooling → Migration strategy → Backup/restore → Test performance
Security: OWASP Top 10 → Parameterized queries → OAuth 2.1 + JWT → Security headers → Rate limiting → Input validation → Argon2id passwords
Testing: Unit 70% → Integration 20% → E2E 10% → Load tests → Migration tests → Contract tests (microservices)
Deployment: Docker → CI/CD → Blue-green/canary → Feature flags → Monitoring → Logging → Health checks
Resources
- OWASP Top 10: https://owasp.org/www-project-top-ten/
- OAuth 2.1: https://oauth.net/2.1/
- OpenTelemetry: https://opentelemetry.io/
Related skills
More from mrgoonie/claudekit-skills and the wider catalog.
chrome-devtools
Browser automation, debugging, and performance analysis using Puppeteer CLI scripts. Use for automating browsers, taking screenshots, analyzing performance, monitoring network traffic, web scraping, form automation, and JavaScript debugging.
devops
Deploy to Cloudflare (Workers, R2, D1), Docker, GCP (Cloud Run, GKE), Kubernetes (kubectl, Helm). Use for serverless, containers, CI/CD, GitOps, security audit.
sequential-thinking
Structured step-by-step reasoning with revision and branching for complex multi-stage problems.
threejs
Build 3D web apps with Three.js (WebGL/WebGPU). Use for 3D scenes, animations, custom shaders, PBR materials, VR/XR experiences, games, data visualizations, product configurators.
opentui
Build terminal user interfaces with OpenTUI's core, React, or Solid frameworks.
msw-avatar
Manage avatar costumes (17 equip slots) and animation state mapping for any entity.