home / skills / pluginagentmarketplace / custom-plugin-typescript / backend

backend skill

/skills/backend

This skill helps you design and implement robust backend APIs across Node.js, Python, Java, and Go with best practices.

npx playbooks add skill pluginagentmarketplace/custom-plugin-typescript --skill backend

Review the files below or copy the command above to add this skill to your agents.

Files (7)
SKILL.md
2.6 KB
---
name: backend-technologies
description: Master backend development with Node.js, Python, Java, Go, Rust, API design, databases, and microservices. Use when building APIs, designing systems, or learning backend frameworks.
sasmp_version: "1.3.0"
bonded_agent: 02-typescript-backend
bond_type: PRIMARY_BOND
---

# Backend Technologies Skill

## Quick Start - Express.js API

```typescript
import express, { Request, Response } from 'express';
import { prisma } from './lib/prisma';

const app = express();
app.use(express.json());

// GET all users
app.get('/users', async (req: Request, res: Response) => {
  try {
    const users = await prisma.user.findMany();
    res.json(users);
  } catch (error) {
    res.status(500).json({ error: 'Failed to fetch users' });
  }
});

// POST new user
app.post('/users', async (req: Request, res: Response) => {
  const { email, name } = req.body;
  try {
    const user = await prisma.user.create({
      data: { email, name }
    });
    res.status(201).json(user);
  } catch (error) {
    res.status(400).json({ error: 'Invalid data' });
  }
});

app.listen(3000, () => console.log('Server running on 3000'));
```

## Core Technologies

### Languages
- **Node.js** - JavaScript runtime
- **Python** - Versatile with many frameworks
- **Java** - Enterprise standard
- **Go** - Concurrent systems
- **Rust** - Systems programming

### Web Frameworks
- Express, Fastify, NestJS (Node.js)
- Django, FastAPI, Flask (Python)
- Spring Boot, Quarkus (Java)
- Gin, Fiber (Go)
- Actix, Axum (Rust)

### Databases
- **SQL**: PostgreSQL, MySQL
- **NoSQL**: MongoDB, DynamoDB
- **Cache**: Redis, Memcached
- **Search**: Elasticsearch

### API & Messaging
- REST APIs with best practices
- GraphQL API design
- gRPC for microservices
- WebSockets for real-time
- Kafka, RabbitMQ for messaging

### ORM/Query Tools
- Prisma, Sequelize (Node.js)
- SQLAlchemy, Tortoise (Python)
- Hibernate, Spring Data (Java)
- GORM (Go)

## Best Practices

1. **API Design** - RESTful or GraphQL standards
2. **Database** - Proper indexing and optimization
3. **Security** - Input validation, parameterized queries
4. **Error Handling** - Meaningful error messages
5. **Testing** - Unit and integration tests
6. **Documentation** - OpenAPI/Swagger docs
7. **Logging** - Structured logging
8. **Performance** - Response time optimization

## Resources

- [Express.js Documentation](https://expressjs.com/)
- [FastAPI Documentation](https://fastapi.tiangolo.com/)
- [Spring Boot Guide](https://spring.io/projects/spring-boot)
- [PostgreSQL Documentation](https://www.postgresql.org/docs/)
- [GraphQL Official](https://graphql.org/)

Overview

This skill provides a practical guide to mastering backend development across Node.js, Python, Java, Go, and Rust, plus API design, databases, and microservices. It focuses on concrete patterns, common frameworks, and production-ready best practices to build reliable APIs and backend systems. Use it to accelerate learning, design systems, or bootstrap services with proven tools.

How this skill works

The skill outlines core languages, web frameworks, database types, messaging patterns, and ORM/query tools to assemble backend stacks. It includes a concise Express.js example to demonstrate API routing, database access, and basic error handling. It also summarizes best practices for API design, security, testing, and observability to guide real-world implementation.

When to use it

  • Bootstrapping a REST or GraphQL API
  • Designing microservices and inter-service communication
  • Choosing language and framework trade-offs for a new project
  • Migrating or scaling database and caching layers
  • Learning backend frameworks and deployment patterns

Best practices

  • Design APIs with consistent RESTful or GraphQL contracts and versioning
  • Optimize databases with proper indexing and query planning
  • Enforce security: input validation, parameterized queries, and auth/authorization
  • Implement structured logging and meaningful error handling
  • Automate tests: unit, integration, and contract tests
  • Document APIs with OpenAPI/Swagger and keep docs up to date

Example use cases

  • Create a CRUD API using Express, Prisma, and PostgreSQL for a small app
  • Build a high-throughput microservice in Go with gRPC and Kafka for event streaming
  • Implement an authenticated GraphQL gateway backed by FastAPI or NestJS
  • Migrate a monolith to services with Spring Boot and a Redis cache layer
  • Prototype a low-latency Rust service for compute-heavy tasks with Actix or Axum

FAQ

Which language should I pick for a new backend service?

Choose based on team skills and requirements: Node.js/Python for rapid development, Java for enterprise ecosystems, Go for concurrency and simplicity, Rust for performance and safety.

How do I pick between SQL and NoSQL?

Use SQL (Postgres, MySQL) for relational data and strong consistency; use NoSQL (MongoDB, DynamoDB) for flexible schemas or massive horizontal scaling. Often a hybrid approach with caching (Redis) is best.