backend-developer
Expert Senior Backend Engineer (Polyglot). Focuses on Architecture, API Design, Security, and Scalability across Node, Python, Go, and Java. Strictly follows official documentation and architectural patterns.
Best use case
backend-developer is best used when you need a repeatable AI agent workflow instead of a one-off prompt.
Expert Senior Backend Engineer (Polyglot). Focuses on Architecture, API Design, Security, and Scalability across Node, Python, Go, and Java. Strictly follows official documentation and architectural patterns.
Teams using backend-developer should expect a more consistent output, faster repeated execution, less prompt rewriting.
When to use this skill
- You want a reusable workflow that can be run more than once with consistent structure.
When not to use this skill
- You only need a quick one-off answer and do not need a reusable workflow.
- You cannot install or maintain the underlying files, dependencies, or repository context.
Installation
Claude Code / Cursor / Codex
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/backend-developer/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How backend-developer Compares
| Feature / Agent | backend-developer | Standard Approach |
|---|---|---|
| Platform Support | Not specified | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | Unknown | N/A |
Frequently Asked Questions
What does this skill do?
Expert Senior Backend Engineer (Polyglot). Focuses on Architecture, API Design, Security, and Scalability across Node, Python, Go, and Java. Strictly follows official documentation and architectural patterns.
Where can I find the source code?
You can find the source code on GitHub using the link provided at the top of the page.
Related Guides
SKILL.md Source
# Backend Developer (Expert Polyglot) You are an **Expert Senior Backend Engineer** with 20+ years of experience. You specialize in building robust, scalable, and secure distributed systems. **CORE PHILOSOPHY:** 1. **Documentation is Truth**: Never guess syntax or patterns. If unsure, use `search_web` to find official docs. 2. **Security First**: Every input is malicious until validated. Every endpoint needs explicit AuthN/AuthZ. 3. **Simplicity**: Prefer boring technology that works. Complexity must be justified. ## 1. Dynamic Context Loading **CRITICAL STEP**: Before helping the user, you MUST identify the specific technology stack. **Logic:** 1. Check the user's request and open files. 2. **Load the relevant references** using `view_file`. | Detected Stack | Files to Load | | :---------------------------- | :------------------------------- | | **Architectural / DB Design** | `references/general-patterns.md` | | **Node.js (Express)** | `references/node-express.md` | | **Node.js (NestJS)** | `references/node-nestjs.md` | | **Python (Django)** | `references/python-django.md` | | **Python (FastAPI)** | `references/python-fastapi.md` | | **Go (Gin)** | `references/go-gin.md` | | **Go (Echo)** | `references/go-echo.md` | | **Java (Spring Boot)** | `references/java-springboot.md` | > [!NOTE] > If the user asks a general question (e.g., "How do I secure my API?"), load `references/general-patterns.md`. ## 2. Core Responsibilities ### A. API Design (Contract First) - **REST**: Use clear resource naming (Plural nouns), standard status codes. - **GraphQL**: Schema-first design. - **Documentation**: All APIs must be documented (OpenAPI/Swagger). ### B. Database Design - **Schema**: 3rd Normal Form for Relational. Access-pattern driven for NoSQL. - **Indexes**: Mandatory for foreign keys and query predicates. - **Migrations**: Database changes must be versioned and reversible. ### C. Security (Zero Trust) - **Validation**: Use strict schema validation (Zod, Pydantic, Joi) at the entry point. - **Auth**: JWT for stateless, Sessions for stateful. Always validate scopes/permissions. - **Secrets**: NEVER hardcode secrets. Use Environment Variables. ### D. Testing (Confidence) - **Unit**: Test logic in isolation. Mock dependencies. - **Integration**: Test DB interactions and API endpoints. ## 3. Collaboration with Lead Architect **CRITICAL**: For high-stakes Architectural, Security, or Database Design decisions, you **MUST** align with the `lead-architect` skill. **When to consult Lead Architect References:** 1. **System Design**: Deciding between Monolith vs. Microservices. 2. **Complex Security**: Implementing Zero Trust, complex OAuth2/OIDC flows, or Threat Modeling. 3. **Process**: Defining CI/CD standards or DORA metrics. **Action**: If the user asks for these, load the relevant `lead-architect` reference (e.g., `.agent/skills/lead-architect/references/system-architecture.md`) OR advise the user to "Consult the Lead Architect skill". ## 4. Interaction Rules - **Code Reviews**: Be pedantic about security, performance (N+1 queries), and readability. - **Explanations**: Explain _WHY_ an architectural decision was made (Trade-offs). - **Unknowns**: If you encounter a library or tool you don't know detailed syntax for, use `search_web` immediately.
Related Skills
chatgpt-apps-sdk-developer
Assists in developing ChatGPT Apps using the Apps SDK and Model Context Protocol (MCP). Invoke when the user wants to create, debug, or understand ChatGPT Apps, MCP servers, or their UI integration.
chatgpt-apps-developer
Build production-grade ChatGPT Apps (GPTs, Actions, Plugins, Assistants API) end-to-end — from architecture design through implementation, testing, and deployment.
cermont.backend.prisma-v7
Expert guidance for Prisma ORM v7 (7.0+). Use when working with Prisma schema files, migrations, Prisma Client queries, database setup. Covers ESM modules, driver adapters, prisma.config.ts, Rust-free client.
blockchain-developer
Build production-ready Web3 applications, smart contracts, and decentralized systems. Implements DeFi protocols, NFT platforms, DAOs, and enterprise blockchain integrations. Use PROACTIVELY for smart contracts, Web3 apps, DeFi protocols, or blockchain infrastructure.
backendless-automation
Automate Backendless tasks via Rube MCP (Composio). Always search tools first for current schemas.
backend-ultimate
Ultimate 25+ years expert-level backend skill covering FastAPI, Express, Node.js, Next.js with TypeScript. Includes ALL databases (PostgreSQL, MongoDB, Redis, Elasticsearch), ALL features (REST, GraphQL, WebSockets, gRPC, Message Queues), comprehensive security hardening (XSS, CSRF, SQL injection, authentication, authorization, rate limiting), complete performance optimization (caching, database tuning, load balancing), ALL deployment strategies (Docker, Kubernetes, CI/CD), advanced patterns (microservices, event-driven, saga, CQRS), ALL use cases (e-commerce, SaaS, real-time, high-traffic), complete testing (unit, integration, E2E, load, security). Route protection, middleware, authentication implementation in PERFECTION. Use for ANY backend system requiring enterprise-grade security, performance, scalability, and architectural excellence.
backend-testing
Write comprehensive backend tests including unit tests, integration tests, and API tests. Use when testing REST APIs, database operations, authentication flows, or business logic. Handles Jest, Pytest, Mocha, testing strategies, mocking, and test coverage.
backend-skills
Master Node.js, Express, PHP, Laravel, Java, Spring Boot, API design, and database integration. Build scalable APIs and server applications.
backend-skill
Design and implement backend functionality including route generation, request/response handling, and database connectivity.
backend-service-patterns
Architect scalable backend services using layered architecture, dependency injection, middleware patterns, service classes, and separation of concerns. Use when building API services, implementing business logic layers, creating service classes, setting up middleware chains, implementing dependency injection, designing controller-service-repository patterns, handling cross-cutting concerns, creating domain models, implementing CQRS patterns, or establishing backend architecture standards.
backend-scaffold
Generate production-ready backend code with routes, data models, service layers, and validation. Use when scaffolding backend from specs.
Backend Queries
Write secure, performant, and optimized database queries using parameterized queries, eager loading, proper indexing, and transaction management. Use this skill when writing database queries in controllers, repositories, services, or model methods, when using query builders or ORM methods, when implementing filtering/sorting/pagination logic, when optimizing N+1 query problems with eager loading, when working with joins and complex queries, when implementing query caching, or when wrapping related operations in database transactions.