architecture-patterns

Index standardized architectural patterns with decision-tree guidance for Next.js, TypeScript, and database choices.

Updated Aug 23, 2026
One-click install
npx skills add https://github.com/Barnhardt-Enterprises-Inc/quetrex-plugin --skill architecture-patterns-barnhardt-enterprises-inc
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: architecture-patterns
Source: https://github.com/Barnhardt-Enterprises-Inc/quetrex-plugin/tree/main/templates/skills/architecture-patterns
Command: npx skills add https://github.com/Barnhardt-Enterprises-Inc/quetrex-plugin --skill architecture-patterns-barnhardt-enterprises-inc

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Developers often struggle to choose the right architectural pattern for a given problem, leading to suboptimal solutions, increased complexity, and inconsistency across the codebase. This Skill provides a comprehensive index and decision guide for Quetrex's approved architectural patterns, saving decision-making time and ensuring consistent, high-quality implementations.

Core Features & Use Cases

  • Pattern Index & Decision Trees: Offers clear guidance on Next.js, TypeScript, Database (Drizzle ORM), State Management, API design, and React 19 patterns.
  • Progressive Disclosure: Provides high-level overviews and decision trees, with links to detailed sub-skills for deep dives into specific implementations.
  • Common Patterns Quick Reference: Delivers immediate code examples for frequent use cases like efficient data fetching, robust form handling, and secure authentication.
  • Use Case: When deciding how to implement data fetching for a new page, activate this Skill. It will guide you through a decision tree to determine whether to use a Server Component, React Query, or Server-Sent Events (SSE) based on your specific requirements, ensuring optimal performance.

Quick Start

I need to implement a new API endpoint. Show me the recommended API patterns and a quick template.

Frequently Asked Questions about architecture-patterns

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

FAQPage Schema
How do I choose the right architecture pattern for my Next.js feature?

Architecture patterns provide decision trees that map your requirements—like data-fetching needs, state complexity, or API design—to standardized Next.js, TypeScript, and database patterns. This Skill guides you through the trade-offs to pick the optimal pattern for your use case.

What are the common patterns for data fetching in Next.js?

Common data-fetching patterns include Server Components, React Query, and Server-Sent Events (SSE), each suited to different scenarios. This Skill provides decision guidance and quick-reference code examples for efficient data fetching based on your performance and real-time requirements.

How do I implement a new API endpoint following best practices?

This Skill provides recommended API patterns and templates for building endpoints consistently. It covers design principles, routing conventions, and integration with your TypeScript and Next.js stack to ensure robust, maintainable endpoints.

Can I use these architecture patterns across my entire Next.js codebase?

Yes. These patterns apply to data fetching, form handling, authentication, state management, and database queries across Next.js applications. Consistent pattern usage across your codebase reduces complexity and speeds up code reviews and feature implementation.

What state-management and database patterns does this cover?

This Skill indexes state-management patterns for React 19 and TypeScript, plus database patterns for Drizzle ORM. Each pattern includes decision guidance to help you pick between approaches based on your data structure, performance needs, and application complexity.

Why should I follow standardized patterns instead of custom solutions?

Standardized patterns reduce decision-making time, prevent suboptimal implementations, and ensure consistency across your team's codebase. They provide proven solutions for common scenarios, making code reviews faster and onboarding new developers easier.