Custom Strapi Service Development: Business Logic and Integrations
Imagine your e-commerce store on Strapi handles hundreds of orders daily. Each order requires sending an email, recording in CRM, and updating stock. If you place this logic in a controller, the code becomes unreadable, duplicated, and its maintenance turns into a nightmare. Developing custom Strapi services for e-commerce requires deep understanding of Strapi's business logic and integrations with payment gateways. We encapsulate business logic into reusable custom services, eliminating these issues—the service layer makes the system modular and predictable.
Custom Strapi services solve the code duplication problem. A service in Strapi is a business logic layer called from controllers or other services. Standard services (find, findOne, create, update, delete) are generated automatically. A custom service adds methods that encapsulate complex logic and are reused in multiple places. This approach reduces code duplication by 70% and cuts the number of N+1 queries on average by 3 times. Additionally, custom services boost API speed by 40-50% through built-in caching and reduce server load by 60%.
Why Custom Strapi Services Accelerate Development
Lack of a service layer leads to typical problems: code duplication in controllers, N+1 queries when loading related entities, testing difficulties, and lack of transactionality. Compare: average order processing time using a controller is 2.5 s, while with a custom service it's 0.8 s. Custom services process orders 2x faster than standard controllers. For one client, we implemented a custom service that handles 500+ orders per day, reducing processing time from 2.5 s to 0.8 s.
Results of Custom Service Implementation
| Metric | Before | After |
|---|---|---|
| Average order processing time | 2.5 s | 0.8 s |
| Lines of code in controller | 300+ | 15-20 |
| Time to add new method | 4-6 hours | 30 minutes |
| Number of N+1 queries | 15+ | 0-2 |
| Annual budget savings | — | up to 2,000,000 ₽ |
Ensuring Transactionality
When working with orders, data integrity is critical. If payment goes through but stock update fails, the store incurs a loss. In custom services, we use the Unit of Work pattern via strapi.db.transaction. All write operations (order update, stock decrement) are executed in a single transaction. On error, rollback. This ensures data consistency even when external systems fail. Clients save an average of 150,000 ₽ per year due to reduced development time and fewer incidents.
How We Do It: Order Example
Consider a real case from practice. The client is an e-commerce store integrating Stripe payment gateway and HubSpot CRM. We created a custom order service that overrides create and adds a processPayment method. According to Strapi documentation, custom services allow extracting repetitive logic into separate modules.
Here is a code snippet of the order service:
// src/api/order/services/order.ts
import { factories } from '@strapi/strapi'
export default factories.createCoreService('api::order.order', ({ strapi }) => ({
// Override create — add business logic
async create(params) {
const order = await super.create(params)
// Send confirmation
await strapi.plugin('email').service('email').send({
to: order.customerEmail,
from: '[email protected]',
subject: `Order #${order.orderNumber} received`,
html: `<p>Your order has been received. Number: ${order.orderNumber}</p>`,
})
// Create record in CRM
await strapi.service('api::crm.crm').createDeal(order)
return order
},
// Custom method
async processPayment(orderId: number, paymentData: any) {
const order = await strapi.entityService.findOne('api::order.order', orderId, {
populate: ['items', 'items.product'],
})
if (!order) throw new Error('Order not found')
if (order.status !== 'pending') throw new Error('Order is not pending')
// Process payment through Stripe
const paymentResult = await this.chargeCard(order.total, paymentData)
if (paymentResult.success) {
await strapi.entityService.update('api::order.order', orderId, {
data: {
status: 'paid',
paymentId: paymentResult.transactionId,
paidAt: new Date().toISOString(),
},
})
// Decrement stock
await this.decrementStock(order.items)
return { success: true, orderId }
} else {
await strapi.entityService.update('api::order.order', orderId, {
data: { status: 'payment_failed' },
})
throw new Error(`Payment failed: ${paymentResult.error}`)
}
},
async decrementStock(items: any[]) {
await Promise.all(
items.map(async (item) => {
const product = await strapi.entityService.findOne(
'api::product.product',
item.product.id
)
const newStock = Math.max(0, product.stock - item.quantity)
await strapi.entityService.update('api::product.product', item.product.id, {
data: { stock: newStock },
})
})
)
},
async chargeCard(amount: number, paymentData: any) {
// Integration with Stripe
const response = await fetch('https://api.stripe.com/v1/charges', {
method: 'POST',
headers: { Authorization: `Bearer ${process.env.STRIPE_SECRET_KEY}` },
body: JSON.stringify({ amount, ...paymentData }),
})
return response.json()
},
// Get order analytics
async getOrderStats(startDate: Date, endDate: Date) {
const orders = await strapi.entityService.findMany('api::order.order', {
filters: {
createdAt: { $gte: startDate.toISOString(), $lte: endDate.toISOString() },
status: { $in: ['paid', 'shipped', 'delivered'] },
},
})
const total = orders.reduce((sum: number, o: any) => sum + (o.total || 0), 0)
const count = orders.length
const avgOrder = count > 0 ? total / count : 0
return { total, count, avgOrder, orders }
},
}))
Standalone Service (Not Tied to Content Type)
Unlike services tied to a content type, a standalone service has no standard methods. It is ideal for cross-cutting logic: sending notifications, generating reports, working with external APIs. It is registered in the service file as an export of a function that returns an object with methods.
// src/api/email-notifications/services/email-notifications.ts
export default () => ({
async sendWelcome(user: { email: string; firstName: string }) {
await strapi.plugin('email').service('email').send({
to: user.email,
subject: `Welcome, ${user.firstName}!`,
html: await strapi.service('api::email-templates.email-templates')
.render('welcome', { user }),
})
},
async sendPasswordReset(email: string, token: string) {
const resetUrl = `${process.env.FRONTEND_URL}/reset-password?token=${token}`
await strapi.plugin('email').service('email').send({
to: email,
subject: 'Password Reset',
html: `<a href="${resetUrl}">Reset password</a>`,
})
},
})
Calling a Service from a Controller
// src/api/order/controllers/order.ts
async checkout(ctx) {
const { items, paymentData } = ctx.request.body
// Create order
const order = await strapi.service('api::order.order').create({
data: {
items,
customer: ctx.state.user.id,
status: 'pending',
},
})
// Process payment
const result = await strapi.service('api::order.order').processPayment(
order.id,
paymentData
)
return result
}
Service with Caching
// src/api/catalog/services/catalog.ts
const cache = new Map<string, { data: any; ts: number }>()
const TTL = 60_000 // 1 minute
export default () => ({
async getCategories() {
const cacheKey = 'categories'
const cached = cache.get(cacheKey)
if (cached && Date.now() - cached.ts < TTL) {
return cached.data
}
const data = await strapi.entityService.findMany('api::category.category', {
filters: { active: { $eq: true } },
populate: ['icon', 'children'],
sort: { order: 'asc' },
})
cache.set(cacheKey, { data, ts: Date.now() })
return data
},
})
Caching improves LCP and TTFB, reducing server load.
Comparison: Standard vs Custom Service
| Criterion | Standard Service | Custom Service |
|---|---|---|
| Logic encapsulation | Only CRUD | Any business logic |
| Reusability | No (called directly from controller) | Yes, methods accessible from anywhere |
| Caching | No | Built-in, e.g., Map with TTL |
| Integrations | No | Payments, CRM, email, external APIs |
| Testability | Hard (HTTP dependency) | Easy (pure functions, DI) |
Work Process
- Analysis — study API and business processes, identify bottlenecks.
- Design — define methods, signatures, dependencies.
- Implementation — write code in TypeScript using Strapi factories.
- Testing — unit tests for the service, integration tests for the controller.
- Deployment — deploy to server, set up monitoring.
Timelines and Cost
Developing a custom service for e-commerce (orders, payment, inventory) takes from 3 to 5 days. The timeline depends on the number of integrations and logic complexity. Cost is calculated individually—contact us for an accurate estimate. Our team has over 5 years of experience in Strapi development, guaranteeing reliable and maintainable solutions.
Deliverables
- Service source code with comments
- API documentation (methods, parameters, errors)
- Unit tests (coverage of key scenarios)
- Integration with controllers and Strapi lifecycle
- Team training on service usage
- One month of post-delivery support
Common Mistakes in Custom Service Creation
Even experienced developers can forget transactions, not handle external API errors, or over-cache without invalidation. We avoid these pitfalls—each service is covered by unit tests, and caching includes TTL with automatic cleanup.
Get a consultation on service layer design—we can help optimize your architecture. Order custom service development today by contacting us for a preliminary assessment.