Backend Expert | Bootspring Docs

The Backend Expert agent specializes in server-side development, APIs, and backend architecture.

Expertise Areas#

Node.js/Express - Server setup, middleware, routing
API Design - REST, GraphQL, tRPC, WebSockets
Authentication - JWT, OAuth, sessions, API keys
Database Integration - ORMs, query builders, raw SQL
Caching - Redis, in-memory, CDN strategies
Background Jobs - Queues, workers, scheduled tasks
Error Handling - Logging, monitoring, graceful failures

Usage Examples#

Creating APIs#

Use the backend-expert agent to create a RESTful API for a blog with:
- CRUD operations for posts
- Authentication middleware
- Input validation
- Error handling

Response includes:

Route definitions
Controller logic
Middleware setup
Validation schemas
Error handlers

Authentication Implementation#

Use the backend-expert agent to implement JWT authentication with refresh tokens.

Response includes:

Token generation
Refresh token rotation
Middleware protection
Secure cookie handling

Database Integration#

Use the backend-expert agent to set up Prisma with PostgreSQL including connection pooling.

Response includes:

Prisma configuration
Schema setup
Connection management
Transaction handling

Best Practices Applied#

1. Security#

Input validation and sanitization
SQL injection prevention
Rate limiting
CORS configuration
Secure headers

2. Error Handling#

Centralized error handling
Structured error responses
Logging strategies
Graceful degradation

3. Performance#

Connection pooling
Query optimization
Response compression
Caching strategies

4. Architecture#

Separation of concerns
Dependency injection
Service layer patterns
Repository patterns

Common Patterns#

Express App Structure#

src/
├── controllers/     # Request handlers
├── services/        # Business logic
├── repositories/    # Data access
├── middleware/      # Custom middleware
├── routes/          # Route definitions
├── utils/           # Helpers
├── types/           # TypeScript types
└── app.ts           # App setup

Controller Pattern#

// controllers/users.controller.ts
export class UsersController {
  constructor(private usersService: UsersService) {}

  async getAll(req: Request, res: Response) {
    const users = await this.usersService.findAll();
    res.json({ data: users });
  }

  async getById(req: Request, res: Response) {
    const user = await this.usersService.findById(req.params.id);
    if (!user) {
      throw new NotFoundError('User not found');
    }
    res.json({ data: user });
  }
}

Middleware Chain#

router.post('/posts',
  authenticate,           // Verify JWT
  authorize('admin'),     // Check permissions
  validate(createPostSchema), // Validate input
  rateLimiter,           // Rate limiting
  postsController.create // Handle request
);

Framework Support#

Express.js#

Middleware patterns
Error handling
Route organization
Security middleware

Fastify#

Plugin architecture
Schema validation
Serialization
Hooks system

NestJS#

Modules and providers
Decorators
Guards and interceptors
Dependency injection

Hono#

Edge-first design
Middleware chaining
Multi-runtime support

API Design Patterns#

RESTful Resources#

GET    /api/posts          # List all posts
GET    /api/posts/:id      # Get single post
POST   /api/posts          # Create post
PUT    /api/posts/:id      # Update post
DELETE /api/posts/:id      # Delete post

Response Structure#

{
  "data": { ... },
  "meta": {
    "page": 1,
    "perPage": 20,
    "total": 100
  },
  "links": {
    "self": "/api/posts?page=1",
    "next": "/api/posts?page=2"
  }
}

Error Response#

{
  "error": {
    "code": "VALIDATION_ERROR",
    "message": "Invalid input",
    "details": [
      { "field": "email", "message": "Invalid email format" }
    ]
  }
}

Sample Prompts#

Task	Prompt
API endpoint	"Create a paginated endpoint for fetching orders"
Auth middleware	"Build JWT verification middleware with role checking"
File upload	"Implement secure file upload with S3 storage"
Webhooks	"Create a webhook handler with signature verification"
Rate limiting	"Add rate limiting with Redis backend"

Configuration#

// bootspring.config.js
module.exports = {
  agents: {
    customInstructions: {
      'backend-expert': `
        - Use async/await for all async operations
        - Include comprehensive error handling
        - Follow REST API conventions
        - Add request validation
        - Include logging for debugging
      `,
    },
  },
  skills: {
    preferred: {
      api: 'rest',
      validation: 'zod',
      orm: 'prisma',
    },
  },
};

Database Expert - Database design and optimization
API Expert - API design patterns
Security Expert - Authentication and security