# Backend Developer

> Use when working on server-side code, REST/GraphQL APIs, database queries, authentication/authorization, background jobs, microservices, or any task involving Node.js, Python (Django/Flask/FastAPI), Go, Java (Spring), Rust, or .NET backend. Trigger phrases: "build API", "server endpoint", "database migration", "backend logic", "service layer", "middleware", "ORM model", "queue worker", "caching strategy".

- Skill: `barastrong/backend-developer` (Agent Skill, multi-file: 5 files)
- Install (CLI): `npx skillmds@latest add barastrong/backend-developer`
- Raw SKILL.md: https://api.skillmd.com/api/skills/barastrong/backend-developer/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: AI & ML
- Author: barastrong (https://skillmd.com/u/barastrong)
- Updated: 2026-09-22
- Page: https://skillmd.com/skills/barastrong/backend-developer

---


# Backend Developer

## Role Summary

A Backend Developer designs, builds, and maintains server-side applications,
APIs, and data pipelines. The role owns everything between the client boundary
and the data store: routing, business logic, persistence, auth, and
integrations with external services.

## Core Responsibilities

- Design and implement RESTful / GraphQL / gRPC APIs
- Write and optimize database queries (SQL & NoSQL)
- Implement authentication & authorization (JWT, OAuth2, RBAC)
- Build background jobs, workers, and event-driven pipelines
- Write unit, integration, and contract tests
- Configure logging, monitoring, and alerting
- Manage schema migrations and data integrity
- Document API contracts (OpenAPI/Swagger)

## Standard Workflow

1. **Requirement Review** — clarify acceptance criteria, data model needs,
   and non-functional requirements (latency, throughput).
2. **Design** — define endpoints, request/response schemas, error codes,
   and sequence diagrams if needed.
3. **Data Layer** — write migration, define models/entities, seed test data.
4. **Business Logic** — implement service/domain layer with validation.
5. **API Layer** — wire controllers/handlers, add middleware (auth, rate
   limiting, CORS).
6. **Testing** — unit tests for logic, integration tests for API, contract
   tests for consumers.
7. **Review & Deploy** — PR review, CI green, deploy to staging, smoke test.

## Technology Stack (common)

| Layer | Tools |
|-------|-------|
| Languages | Node.js/TypeScript, Python, Go, Java, Rust, C# |
| Frameworks | Express/Fastify, Django/FastAPI, Spring Boot, Gin, Actix |
| Databases | PostgreSQL, MySQL, MongoDB, Redis, DynamoDB |
| Messaging | RabbitMQ, Kafka, SQS, NATS |
| Auth | Passport.js, NextAuth, Keycloak, Auth0 |
| Docs | OpenAPI/Swagger, Redoc |
| Testing | Jest, pytest, JUnit, Go testing, Supertest |

## Best Practices

- Keep controllers thin; push logic into service/domain layers.
- Validate all input at trust boundaries (never trust client data).
- Use parameterized queries — never concatenate SQL.
- Return consistent error response shapes (RFC 7807 Problem Details).
- Idempotency keys for non-safe operations.
- Rate-limit public endpoints.
- Log structured JSON; include correlation/request IDs.
- Fail fast: return early on invalid state.
- Database indexes on columns used in WHERE/JOIN/ORDER BY.
- Keep migrations reversible when possible.

## Anti-Patterns to Avoid

- God controllers that mix routing, validation, business logic, and persistence.
- N+1 query problems — use eager loading or dataloaders.
- Swallowing errors silently.
- Storing secrets in code or environment files committed to VCS.
- Over-engineering: no microservice split until monolith proves insufficient.

## References

- `references/api-design-checklist.md` — API design review checklist
- `references/database-optimization.md` — query optimization patterns
- `references/error-handling-guide.md` — standard error handling patterns

## Expected Output Format

When completing backend tasks, deliver:
1. Working code with tests passing
2. Migration files (if schema changed)
3. Updated API documentation (OpenAPI spec or equivalent)
4. Brief note on deployment considerations (env vars, feature flags)