backend-dev-guidelines

Provide backend development guidelines for Node.js/Express/TypeScript microservices.

5|3|Updated Nov 4, 2025
One-click install
npx skills add https://github.com/PedroGiudice/Claude-Code-Projetos --skill backend-dev-guidelines-pedrogiudice
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: backend-dev-guidelines
Source: https://github.com/PedroGiudice/Claude-Code-Projetos/tree/main/.claude/skills/backend-dev-guidelines
Command: npx skills add https://github.com/PedroGiudice/Claude-Code-Projetos --skill backend-dev-guidelines-pedrogiudice

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

Developing scalable, maintainable, and error-resilient backend microservices can be challenging due to inconsistent patterns, poor error handling, and lack of clear architecture. This skill provides a definitive guide to modern Node.js/Express/TypeScript development.

Core Features & Use Cases

  • Layered Architecture: Implement a clear Routes → Controllers → Services → Repositories structure for optimal separation of concerns, making your codebase easier to understand and test.
  • Robust Error Handling: Integrate Sentry for comprehensive error tracking and use custom error types with a BaseController pattern to ensure all issues are caught and managed effectively.
  • Type-Safe Development: Leverage Zod for input validation, unifiedConfig for configuration, and Prisma for database access, all with strong TypeScript guarantees, reducing runtime errors.
  • Use Case: When building a new API endpoint, use this skill to get a checklist for defining routes, implementing controllers, services, and repositories, ensuring proper validation, error handling, and adherence to architectural standards.

Quick Start

I need to create a new backend API endpoint for user creation. Provide the core principles for backend development and a quick start checklist for a new feature.

Frequently Asked Questions about backend-dev-guidelines

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I structure a Node.js backend API with proper separation of concerns?

Implement a layered architecture with Routes → Controllers → Services → Repositories, where each layer handles one responsibility. Controllers parse requests and delegate to services, services contain business logic, and repositories manage database access through Prisma, ensuring clean separation and testability.

What's the best way to handle errors in Express microservices with TypeScript?

Use a BaseController pattern combined with Sentry integration to catch and track all errors. Define custom error types, implement centralized error handling middleware, and log exceptions to Sentry so issues are monitored across your microservices in real time.

How do I validate API inputs in a Node.js/Express application?

Use Zod for schema-based input validation in your controller layer before passing data to services. Zod provides type-safe validation with strong TypeScript integration, catching runtime errors at the request boundary and reducing bugs downstream.

Can I use this backend pattern for multiple microservices like auth and notifications?

Yes. The layered architecture with Controllers, Services, and Repositories scales across microservices. Apply consistent patterns for routes, middleware, config via unifiedConfig, and Sentry error handling across services like blog-api, auth-service, and notifications-service.

How do I migrate legacy Node.js code to follow modern microservice patterns?

Refactor incrementally by extracting business logic into services, adding repository layers for data access, introducing Zod validation, and integrating Sentry for error tracking. Use the provided guidelines to modernize routes, middleware, and dependency injection step by step.

What configuration management approach should I use across Express microservices?

Use unifiedConfig to manage environment variables and configuration centrally across your microservices. This ensures consistency, type safety, and simplifies multi-service deployments without duplicating config logic in each service.