When should I choose architecture-paradigm-service-based over microservices?

When you need deployment independence without the complexity of managing numerous microservices; it suits scenarios with shared data or governance constraints where full autonomy isn’t realistic.

How do you handle data with a shared database?

Assign explicit ownership for each schema or table, use views or replication to decouple dependencies, and gate breaking changes through formal reviews.

What tooling supports this paradigm?

Use an API gateway for routing and auth, a service registry for discovery, and schema-management practices to maintain contract accuracy and versioning.

architecture-paradigm-service-based

architectural-pattern

npx machina-cli add skill athola/claude-night-market/architecture-paradigm-service-based --openclaw

Files (1)

SKILL.md

3.2 KB

The Service-Based Architecture Paradigm

When To Use

Multi-team organizations with domain-aligned services
Systems requiring independent deployment of components

When NOT To Use

Single-team projects small enough for a monolith
Latency-sensitive systems where inter-service calls are prohibitive

When to Employ This Paradigm

When teams require a degree of deployment independence but are not yet prepared for the complexity of managing numerous microservices.
When shared databases or large-scale systems (like ERPs) make full service autonomy unrealistic.
When establishing clear service contracts for partner teams or external consumers.

Adoption Steps

Group Capabilities: Bundle related business functions into a small set of well-defined services, each with a designated owner.
Define Service Contracts: Publish formal specifications using standards like OpenAPI or AsyncAPI, including Service Level Agreements (SLAs) and a clear versioning strategy.
Control Database Schemas: Even when services share a database, assign explicit ownership for each schema or table. Gate all breaking changes through a formal review process.
Establish Service Mediation: Use a service registry or an API gateway to handle routing, authentication, and observability.
Plan for Evolution: Identify architectural "hotspots" that are likely candidates for being split into more granular services in the future.

Key Deliverables

An Architecture Decision Record (ADR) that outlines service boundaries, data ownership rules, and coordination mechanisms.
A suite of contract tests and consumer-driven contract tests for each service to validate stability.
Runbooks that describe deployment procedures, rollback plans, and service dependencies.

Risks & Mitigations

Coupling Through a Shared Database:
- Mitigation: Changes to a shared database can have cascading effects across services. Mitigate this by using database views, replication, or a formal schema deprecation schedule to manage change.
Architectural Degradation:
- Mitigation: Without strong governance, this architecture can degrade into a "distributed monolith"—a monolith with the added complexity of network hops. Track coupling metrics closely and enforce strict ownership of services and data to prevent this.

Troubleshooting

Common Issues

Command not found Ensure all dependencies are installed and in PATH

Permission errors Check file permissions and run with appropriate privileges

Unexpected behavior Enable verbose logging with --verbose flag

Source

git clone https://github.com/athola/claude-night-market/blob/master/plugins/archetypes/skills/architecture-paradigm-service-based/SKILL.md

View on GitHub

Overview

This paradigm uses coarse-grained, domain-oriented services to enable deployment independence without the full complexity of microservices. It emphasizes SOA-style boundaries, explicit service contracts, and governance when databases are shared. It’s ideal for teams seeking modularity and clear contracts without overwhelming operational overhead.

How This Skill Works

Group related capabilities into a small set of well-defined services, each with an owner. Define service contracts using OpenAPI or AsyncAPI with SLAs and versioning, and manage data ownership even when a shared database exists. Use a service registry or API gateway to handle routing, authentication, and observability, mediating interactions between services.

When to Use It

Multi-team organizations with domain-aligned services
Systems requiring independent deployment of components
Teams require deployment independence without the complexity of many microservices
Shared-database or ERP-scale environments where full service autonomy is unrealistic
Need clear service contracts for partner teams or external consumers

Quick Start

Step 1: Group Capabilities: Bundle related business functions into a small set of well-defined services with designated owners
Step 2: Define Service Contracts: Publish OpenAPI/AsyncAPI specs, including SLAs and versioning
Step 3: Control Database Schemas: Assign ownership for each schema/table and gate breaking changes through formal reviews

Best Practices

Group related business functions into a small set of well-defined services with designated owners
Publish formal service contracts using OpenAPI or AsyncAPI, including SLAs and a clear versioning strategy
Assign explicit ownership for each database schema or table and gate breaking changes through formal reviews
Establish service mediation using a service registry or an API gateway for routing, authentication, and observability
Plan for evolution by identifying architectural hotspots likely to be split into more granular services in the future

Example Use Cases

ERP-like system where domain services (e.g., HR, Finance, Inventory) share a database but have explicit data ownership and governance
Multi-team e-commerce platform with domain services such as Catalog, Pricing, and Checkout that can be deployed independently
Partner integrations governed by stable OpenAPI/AsyncAPI contracts with versioned SLAs
Monolith refactor to introduce a service-based pattern without moving to full microservices
Large enterprise with centralized governance using an API gateway and service registry to coordinate services

Frequently Asked Questions

Add this skill to your agents

Related Skills

architecture-paradigm-space-based

athola/claude-night-market

'Data-grid architecture for high-traffic stateful workloads with linear

architecture-paradigm-layered

athola/claude-night-market

'Consult this skill when implementing layered patterns or enforcing layer

architecture-paradigm-microkernel

athola/claude-night-market

'Minimal core system with plugin-based feature extensibility for platform

architecture-paradigm-microservices

athola/claude-night-market

'Consult this skill when designing or evolving microservices architectures.

architecture-paradigm-pipeline

athola/claude-night-market

'Consult this skill when designing data pipelines or transformation workflows.

architecture-paradigm-serverless

athola/claude-night-market

'Serverless FaaS for event-driven workloads with minimal infrastructure