backend-dev-guidelines

Extract semantic metadata from backend guideline artifacts for vector embeddings.

1|Updated Nov 9, 2025
One-click install
npx skills add https://github.com/ramunasnognys/workflow-template --skill backend-dev-guidelines-ramunasnognys
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: backend-dev-guidelines
Source: https://github.com/ramunasnognys/workflow-template/tree/main/.claude/skills/backend-dev-guidelines
Command: npx skills add https://github.com/ramunasnognys/workflow-template --skill backend-dev-guidelines-ramunasnognys

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

Developing scalable and maintainable Node.js microservices requires strict adherence to architectural patterns. This Skill provides a comprehensive guide to building robust backend APIs with Node.js, Express, and TypeScript, ensuring consistency, testability, and efficient error handling across your services.

Core Features & Use Cases

  • Layered Architecture: Implement a clear separation of concerns with dedicated layers for routes, controllers, services, and repositories, enhancing maintainability and testability.
  • Type-Safe Validation & Configuration: Utilize Zod for robust input validation and unifiedConfig for type-safe, environment-agnostic configuration, eliminating process.env pitfalls.
  • Sentry Error Tracking & Async Handling: Integrate Sentry for comprehensive error monitoring and apply asyncErrorWrapper for consistent async error handling, preventing unhandled rejections.
  • Use Case: You need to create a new API endpoint for user management. Use this Skill to define the route, implement a controller extending BaseController, write business logic in a service, interact with the database via a repository, and ensure all input is validated with Zod and errors are tracked by Sentry.

Quick Start

Generate a new Express route /api/products with a GET endpoint that lists all products, ensuring it uses a controller, service, and repository pattern, and validates any query parameters with Zod.

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 API with layered architecture?

Layered architecture separates concerns into routes, controllers, services, and repositories. This pattern enhances maintainability by isolating business logic from HTTP handling and database access, making your Node.js APIs testable and scalable across microservices.

What's the best way to handle validation and configuration in Express with TypeScript?

Use Zod for input validation and `unifiedConfig` for type-safe configuration management. This eliminates unsafe `process.env` access and ensures runtime type safety across your Express application without manual validation boilerplate.

How do I prevent unhandled promise rejections in async Express handlers?

Apply `asyncErrorWrapper` to wrap async route handlers and catch errors consistently. Combined with Sentry error tracking, this ensures all async errors are captured and logged, preventing silent failures in production microservices.

Can I use Prisma with Node.js backend guidelines for API development?

Yes. Prisma integrates as your repository layer, providing type-safe database queries within the layered architecture pattern. This Skill guides you to implement Prisma repositories that work seamlessly with controllers and services.

What's the difference between handling errors in Express middleware versus controllers?

Middleware handles cross-cutting concerns like authentication and logging; controllers handle request-specific logic. This Skill teaches you to use Sentry and `asyncErrorWrapper` at the controller level to catch business logic errors while middleware manages application-level concerns.

Do I need microservices experience to follow these Node.js backend guidelines?

No. This Skill teaches single-service layered architecture patterns first, then scales to microservices. The patterns—controllers, services, repositories, and centralized error handling—work for monoliths and distributed systems alike.