Mobile Lighthouse jumped from 44 to 100. The database shrank from 1 GB to 50 MB. Annual subscription revenue grew by 225%, alongside a 90% boost in conversion and 75% deeper page views. The evilUnion team didn't get these numbers on a synthetic demo. They achieved them on a live paid service for doctors after migrating completely from WordPress to Strapi 5 and Astro. The migration came with one strict condition: move everything without exception. Articles, clinical guidelines, paid PDF guides, multi-section courses, active subscriptions, promo codes, and legacy passwords all had to transfer so that not a single doctor lost access after launch.
Full-stack developer Artem from evilUnion broke down the full migration story in a Habr article published on Alexander Bakharev's blog. It's a rare case study that skips the glossy three-collection demo and shows the whole kitchen: a cached frontend, developer-free editing, hybrid search, background queues, a custom CRM, analytics, and deep excavations inside an old WordPress database.
Why the Old WordPress Setup Hit a Wall
The medical service originally grew on WordPress: standard posts, a stack of plugins for subscriptions, auto-renewals, promo codes, referrals, and a built-in CRM. While the audience and content library were small, that setup limped along. Then the project scaled, and the monolith started cracking in four places at once.
First, mobile performance tanked. A 44 in Lighthouse Performance for a content platform that relies on organic search traffic means directly losing readers. Second, the admin panel itself slowed down. Simply opening and saving an article turned into a test of patience. Third, the old site had already suffered security breaches, which is a classic risk when a single engine carries a dozen third-party plugins. Fourth, and worst for the business, nobody trusted the built-in CRM anymore. Numbers in neighboring tabs didn't match due to internal filters whose logic was nearly impossible to untangle.
After moving to the new stack, the speed bottlenecks vanished. You can see the difference clearly in the load and navigation benchmarks before and after migration.
Load Time (Mobile Lighthouse) and Page Transitions (Yandex Metrica): WordPress vs Strapi 5 + Astro
In practice, you feel this leap immediately. The page stops stalling before the first text appears, and clicks inside the catalog respond almost instantly. This isn't about cosmetic image compression. It's a full architectural shift from a heavy monolith to a decoupled Node.js backend and a lightweight frontend that doesn't ship unnecessary JavaScript to the browser.
Strapi 5 as a Unified Backend: Data Schema and Request Pipeline
When you hear "headless CMS" (a content management system without built-in HTML templates that stores data, provides an admin UI, and serves everything over an API), it's easy to assume it only handles text. You might think you'll need a separate server for subscriptions, payments, and a CRM. The evilUnion team took another route and made Strapi 5 the single backend for the entire project.
Under the hood, Strapi runs standard Node.js on top of the Koa framework. It supports PostgreSQL, MySQL, MariaDB, and SQLite. For this project, the team chose PostgreSQL in Docker behind nginx, fully self-hosted so code and personal data stay on their own servers. The entry barrier is low: you define an entity either visually in the Content-Type Builder or directly in schema.json. Both are just two views of the same config.
{
"kind": "collectionType",
"info": {
"singularName": "article",
"pluralName": "articles"
},
"options": {
"draftAndPublish": true
},
"attributes": {
"title": { "type": "string", "required": true },
"content": { "type": "richtext" },
"category": {
"type": "relation",
"relation": "manyToOne",
"target": "api::category.category"
}
}
}
Once you save this schema, Strapi creates the database table, builds the admin form, and exposes ready-made REST endpoints (GET, POST, PUT, DELETE for /api/articles). Everything is locked down by default: until you explicitly grant find and findOne to the Public role, outsiders can't read anything. External integrations use scoped API tokens, and passwords or internal fields never leak into responses.
Content-Type Builder interface in Strapi 5 for configuring collections, fields, and relations (Source: docs.strapi.io)
Every HTTP request in Strapi 5 follows a clear pipeline: request -> route -> middleware & policies -> controller -> service -> Document Service API -> database. Let's break down each link in plain terms. middleware and policies intercept the request before the main logic runs (for instance, to check permissions or set headers). The controller parses parameters and sends the HTTP response. The service holds reusable business logic that you can call from controllers, cron jobs, or background queues. Finally, the Document Service API (strapi.documents(...)) talks to the database using a stable documentId, which replaced v4's numeric IDs in Strapi 5.
To keep the database from turning into a junk drawer, the team sorted entities into three buckets right away. Standalone items referenced by other records (articles, categories, instructors) went into collections. Blocks that only live inside a specific page (an article accordion, a Q&A block, an instructor card) became components. Course pages were built with dynamic zones, which act like a flexible field builder where editors add and reorder approved components themselves.
Another smart call was how they handled user profiles. Strapi ships with a built-in users-permissions plugin, and it's tempting to pile every subscriber field onto its default user model. The team resisted that urge and moved profiles into a separate api::profile.profile collection, linking it to subscriptions, plans, payments, purchased guides, promo codes, sessions, and favorites. As a result, any single record immediately reveals the full chain: who bought what, under which plan, with which payment, and using which promo code.
Astro Frontend: Static Pages, Cached SSR, and React Islands
For the public storefront, the team picked Astro instead of Next.js or Nuxt. Astro's main superpower is sending pure HTML to the browser with zero client-side JavaScript by default. Interactive widgets attach selectively as "islands" (Astro Islands) written in React, Vue, or Svelte. That way, the browser never has to download and parse an entire app bundle just to render a text article.
Astro Islands architecture showing pure HTML by default with selective interactivity (Source: docs.astro.build)
Rendering is configured per page using on-demand rendering. Sections that rarely change are pre-built into static files once at build time by adding a single line at the top of the file. Articles and catalogs update constantly, so they use server-side rendering (SSR) cached in nginx.
---
// A rarely changing page is built into static HTML at build time
export const prerender = true;
---
A file like this compiles into ready-made HTML during the build and serves straight from disk without touching Node.js. For live articles and catalogs, the team uses SSR paired with a targeted interactive island:
---
// The article fetches data from Strapi on the server (SSR)
const { data } = await fetchApi({
endpoint: 'articles',
query: { filters: { slug } },
});
---
<ArticleHeader title={data.title} />
<ArticleBody content={data.content} />
<!-- The React island loads JS only when the button enters the viewport -->
<FavouriteButton client:visible articleId={data.documentId} />
There's a neat architectural trick here without which shared nginx caching simply wouldn't work. On the server, Astro renders only the public part of the page, which is identical for every visitor and search crawler. That HTML can be cached whole in nginx and served to thousands of users without hitting Strapi at all. Everything personal—paywalled content, account dashboards, favorite status, notifications—loads on the client. Meanwhile, the client:visible directive on <FavouriteButton /> defers loading its React code until the user actually scrolls down to the button.
On top of that, they enabled Astro's built-in prefetch. By default, it quietly starts preloading the next page as soon as you hover over a link, and automatically backs off on slow connections or data-saver mode. Combined with the nginx cache, this creates the feeling of instant navigation across the site. If an editor fixes a typo and doesn't want to wait for cache expiration, they just click a purge button right inside the Strapi admin panel.
Editorial Workflow: CKEditor 5, Live Preview, and the Permissions Trap
The ultimate test of any CMS is whether editors stop pinging developers for every minor tweak. In Strapi 5's Content Manager, all the basics are already there: record tables with filters, sorting, and search, plus a Media Library with folders, cropping, alt text, and automatic image resizing so mobile devices don't download huge originals.
Course pages run on dynamic zones. An editor clicks "Add component" and assembles sections—syllabus, instructors, pricing, reviews, FAQ—reordering them via drag and drop. Instructors are pulled in through relations: update a lecturer's photo in one card, and it updates across every course.
With Strapi's built-in text editors (Markdown and Blocks), however, the team hit a classic reality check. They simply weren't enough for medical articles packed with large tables. Instead, the team integrated CKEditor 5 via the strapi-plugin-ckeditor plugin and wrote four custom plugins on top for the editorial team:
- inserting clinical evidence and recommendation tags (
UDDandUURin Russian clinical documents); - hiding fragments of text and images;
- interactive hotbuttons with tooltip explanations;
- proper
Tabkey handling inside nested lists.
At the same time, they deliberately took away font, size, and color pickers from editors. It sounds strict, but in practice it's a lifesaver. Without that rule, articles inevitably turn into a rainbow newspaper with three mismatched fonts within six months.
Strapi 5 Content Manager edit screen with Draft/Published toggle and right-hand side panel (Source: docs.strapi.io)
The Draft & Publish workflow (where draft and published versions live separately) even came in handy for SEO redirects. When an article's URL changes, editors don't delete the old entry. They unpublish it back to draft and fill in a redirect_url field. The frontend reads it and handles the redirect automatically, so developers don't need to get involved for URL changes.
To let editors see how an article actually looks in production layout, the team enabled Strapi 5's native Preview. It opens the live site inside an iframe right in the admin panel, complete with a toggle between draft and published states.
// config/admin.js — configuring built-in Preview in Strapi 5
preview: {
enabled: true,
config: {
// Allow iframe messaging only from our own domain
allowedOrigins: [env('PREVIEW_URL')],
async handler(uid, { documentId, status }) {
const pathname = getPreviewPathname(uid, documentId);
// Returning null hides the Preview button for internal tables
if (!pathname) return null;
const base = `${env('PREVIEW_URL')}${pathname}`;
return `${base}?token=${env('PREVIEW_SECRET')}&status=${status}`;
},
},
},
The Astro frontend validates PREVIEW_SECRET and renders the entry using the exact same production components, bypassing the nginx cache. In the right-hand sidebar of the entry view, the team added two custom buttons: "Open Page" and "Refresh Cache".
To prevent paid guide forms from turning into endless walls of inputs, they used conditional fields (conditions.visible in schema.json). The price field and trial file only appear in the UI when the isPremium flag is enabled.
"price": {
"type": "decimal",
"conditions": {
"visible": {
"==": [{ "var": "isPremium" }, true]
}
}
}
And right here sits a very quiet Strapi gotcha that's easy to trip over in production. When you add a new field to schema.json, a Super Admin sees it immediately. Custom editor roles, however, don't get permissions for it by default. An editor opens the entry and sees No permissions to see this field instead of the price input. You have to grant permissions for every new field manually, and it's remarkably easy to forget. Toggle the checkbox and switch roles in the interactive mockup below to see how conditional fields and this permissions trap behave in the admin panel.
Interactive Mockup: Conditional Fields and the Permissions Trap in Strapi 5
This simple example shows why you should always check role settings and verify new fields through an editor's eyes after every schema migration, rather than testing only as a Super Admin.
Custom Backend: Koa, Meilisearch Hybrid Search, BullMQ Queues, and Admin Extensions
When basic CRUD isn't enough, Strapi 5 doesn't stop you from writing regular server-side code. In the original article, Artem adds an honest disclaimer: the snippets below are simplified to show how Strapi's tools work, and shouldn't be copied to production without validation, permission checks, and race-condition protection (for example, a live view counter should use an atomic SQL increment instead of a read-then-write cycle).
Here is how you add a custom view-counting endpoint alongside standard article routes using createCoreController, createCoreService, and strapi.documents:
Isometric architectural diagram of a modular Strapi 5 backend with controller pipelines, Meilisearch hybrid search, and BullMQ background queues.
// src/api/article/routes/custom.js
module.exports = {
routes: [
{
method: 'POST',
path: '/articles/:documentId/view',
handler: 'article.view',
},
],
};
// src/api/article/controllers/article.js
module.exports = createCoreController(
'api::article.article',
({ strapi }) => ({
async view(ctx) {
const svc = strapi.service('api::article.article');
await svc.incrementViews(ctx.params.documentId);
ctx.status = 204;
},
})
);
// src/api/article/services/article.js
module.exports = createCoreService(
'api::article.article',
({ strapi }) => ({
async incrementViews(documentId) {
const docs = strapi.documents('api::article.article');
const article = await docs.findOne({ documentId });
await docs.update({
documentId,
data: { views: (article.views ?? 0) + 1 },
});
},
})
);
Three more built-in mechanisms layer cleanly on top of this: Koa middleware, lifecycle hooks (lifecycles), and the built-in cron scheduler from Server Configuration. Middleware plugs in with a single line in config/middlewares.js and can modify responses after await next()—for example, attaching Cache-Control headers to public GET requests for articles. Lifecycles run automatically when a record is created or updated (handy for calculating reading time at 200 words per minute), while the weekly cron job flags the top 10 most popular articles.
// src/middlewares/cache-headers.js — cache headers after response
module.exports = (config, { strapi }) => {
return async (ctx, next) => {
await next();
const isArticles = ctx.url.startsWith('/api/articles');
if (ctx.method === 'GET' && isArticles && ctx.status === 200) {
ctx.set('Cache-Control', 'public, max-age=60');
}
};
};
// src/api/article/content-types/article/lifecycles.js
const getReadingTime = (html = '') => {
const words = html.replace(/<[^>]+>/g, ' ').split(/\s+/).length;
return Math.ceil(words / 200);
};
module.exports = {
beforeCreate(event) {
const { data } = event.params;
data.readingTime = getReadingTime(data.content);
},
beforeUpdate(event) {
const { data } = event.params;
if (data.content) {
data.readingTime = getReadingTime(data.content);
}
},
};
// config/server.js — built-in cron without a separate service
cron: {
enabled: true,
tasks: {
'0 3 * * 1': async ({ strapi }) => {
const svc = strapi.service('api::article.article');
await svc.markPopular({ limit: 10 });
},
},
},
Search was its own challenge. Doctors rarely type exact article titles. They enter different word forms, make typos, or describe symptoms in their own words. To handle that, the team connected Meilisearch using the official strapi-plugin-meilisearch plugin, which updates the index automatically on every edit.
The setup is clever yet clean. Nested accordions are pulled into the index via entriesQuery.populate, HTML is stripped with stripHtml, titles are stemmed via stemText, and a multilingual embedding model—sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2—runs on top. Setting source: 'huggingFace' lets Meilisearch download and run the model locally without paid external APIs.
// config/plugins.js — article indexing and local embedder
meilisearch: {
config: {
host: env('MEILISEARCH_HOST'),
apiKey: env('MEILISEARCH_API_KEY'),
article: {
entriesQuery: {
populate: { content: { populate: { accordion: true } } },
},
transformEntry({ entry }) {
return {
...entry,
contentPlain: stripHtml(entry.content),
stemmedTitle: stemText(entry.title),
};
},
settings: {
embedders: {
default: {
source: 'huggingFace',
model:
'sentence-transformers/' +
'paraphrase-multilingual-MiniLM-L12-v2',
},
},
},
},
},
},
As a result, search runs in a 50/50 hybrid mode (semanticRatio: 0.5): half the weight goes to exact keywords and typo tolerance, and the other half to semantic meaning. The global search bar queries multiple indexes in one request, while section-level search (such as searching only guides) targets a single index.
Next up are background queues powered by BullMQ on top of Redis. The frontend streams events to the server: page views, accordion toggles, guide downloads, banner clicks. Writing all of that synchronously to the analytics database inside an HTTP request would quickly choke the backend under load. With BullMQ, the endpoint drops the job into the queue and frees the user immediately, while a worker processes it in the background with three retries and exponential backoff.
// Endpoint queues the job and responds immediately
const queue = strapi.plugin('bullmq').service('queue').get('analytics');
await queue.add('track', event, {
attempts: 3,
backoff: { type: 'exponential', delay: 2000 },
});
// Background worker writes events to ClickHouse
const workers = strapi.plugin('bullmq').service('worker');
workers.create(queue, async (job) => {
await writeToClickHouse(job.data);
});
Heavy exports, segment recalculations, and canceling stalled payments run through the same queues. Instead of guessing in the console what's stuck or failing, the team mounted the Bull Board web UI on a dedicated Strapi route. They also closed the loop on API documentation: the official OpenAPI/Swagger plugin covered standard routes, and AI agents helped generate schemas for custom endpoints.
Finally, they customized the admin panel itself. Strapi's UI is built with React and exposes the Admin Panel API in src/admin/app.js. Because extensions use Strapi's native design system, they don't look like bolted-on patches. Through addEditViewSidePanel, the team added a right-hand panel with "Open Page" and "Refresh Cache" buttons. Through injectComponent (which moved inside the content-manager plugin in Strapi 5), they added a "Reorder" button for dragging categories—they had to drop a ready-made marketplace plugin because it required per-admin configuration.
// src/admin/app.js — extending the editor and list views
export default {
bootstrap(app) {
const cm = app.getPlugin('content-manager');
cm.apis.addEditViewSidePanel([ActionsPanel]);
cm.injectComponent('listView', 'actions', {
name: 'category-order-sort',
Component: CategoryOrderSort,
});
},
};
That's how one Strapi core brought together the site's API, hybrid search, background jobs, and a tailored editorial panel—without a zoo of separate microservices.
Custom CRM, Segment Builder, and Analytics on the Same API
Remember that old WordPress CRM problem where numbers in neighboring tabs refused to match? In the new architecture, the team fixed it at the root: they built a standalone CRM in React and TypeScript that has no database of its own. It talks to the exact same Strapi REST API as the main website. One source of truth means zero discrepancies.
Everything that's normally painful to build in admin tables—server-side pagination, filtering, sorting, and relation loading via populate—came out of the box from Strapi. Managers customize visible columns and export any filtered view to Excel. Staff login runs on Users & Permissions, while custom roles with a per-section permission matrix live in a regular Strapi collection so new roles can be created right in the UI without touching code.
Here's a neat development detail: the team built the CRM frontend with Claude Code. They documented data types, screens, and Strapi request formats in Markdown upfront, split the work into stages, and had the agent implement them step by step with a changelog. It worked so well because Strapi's API is consistent: they only had to specify the filter and pagination format once, and the agent applied it across every table.
The best part of the CRM is its segment builder. Marketers assemble audiences like "doctors with an active subscription expiring within a week" or "users whose auto-renewal failed." Under the hood are more than 20 rule types (subscription status, specialty, visited pages, analytics events) with arbitrary AND and OR groups, supporting both registered doctors and anonymous visitors.
These rules are stored as a JSON tree in a segments collection. They didn't have to invent a custom query language: a short recursive function walks the tree and translates nearly every condition into Strapi's native $and and $or filters.
// Recursively translate a JSON rule tree into Strapi filters
async function evaluateNode(node) {
if (node.logic) {
const filters = await Promise.all(
node.conditions.map(evaluateNode)
);
return node.logic === 'AND'
? { $and: filters }
: { $or: filters };
}
return evaluators[node.type](node);
}
const filters = await evaluateNode(segment.conditions);
const users = await strapi
.documents('api::profile.profile')
.findMany({ filters });
Try toggling rules and switching AND / OR logic in the mini-builder below. It shows how a UI tree turns into a Strapi filters object and filters matching profiles from a sample set of doctors.
Interactive Mockup: CRM Segment Builder and Strapi Filters
In production, segments recalculate in the background every 30 minutes via BullMQ. When the backend needs to write thousands of recalculation results in bulk, Strapi doesn't force you through single ORM calls. Under the hood, you have direct access to Knex.js (strapi.db.connection) for fast batch inserts. Finished segments sync automatically with mailing lists in Unisender and feed straight into the ad module.
The ad module itself lives as a regular Strapi collection. It supports three formats: a header banner, a popup, and a dashboard banner. Marketers can upload an image, an HTML5 archive, or build a promo in a visual editor (for example, a discount banner with a copy-promo-code button), check it in a responsive preview, and target by segment, page, and per-session impression cap. A single Strapi endpoint evaluates the visitor's segments and returns matching banners, while impressions and clicks go straight to the analytics queue. Marketers launch campaigns in minutes without developers.
All analytics collected in ClickHouse power Yandex DataLens dashboards embedded directly inside the CRM. To avoid exposing private keys in the browser, the Strapi backend generates a signed JWT for private embedding (per DataLens docs, using PS256 signing with a lifetime of up to 10 hours).
WordPress Database Detective Work: Pivoting wp_usermeta and 5 Data Surprises
If you think building a new frontend, queues, and CRM is the hardest part of a migration like this, reality sets in fast. The team spent most of their time not on new code, but on figuring out what lived where in the old WordPress database.
WordPress uses an EAV (Entity-Attribute-Value) model: nearly all content gets dumped into wp_posts split by post_type, while custom fields from dozens of plugins are scattered across wp_postmeta and wp_usermeta as key-value pairs. Just assembling a single user meant pivoting dozens of rows with SQL:
-- Pivot EAV rows from wp_usermeta into a single user record
SELECT
u.ID,
u.user_email,
MAX(CASE WHEN um.meta_key = 'first_name'
THEN um.meta_value END) AS first_name,
MAX(CASE WHEN um.meta_key = 'telefon_lk'
THEN um.meta_value END) AS phone,
MAX(CASE WHEN um.meta_key = 'user_registration_select_1667036325'
THEN um.meta_value END) AS status,
MAX(CASE WHEN um.meta_key = 'user_registration_select_1667037133924'
THEN um.meta_value END) AS specialty
FROM wp_users u
LEFT JOIN wp_usermeta um ON um.user_id = u.ID
GROUP BY u.ID;
Look at those keys in the query. Figuring out that user_registration_select_1667036325 meant user status was only possible by trial and error, matching database values against the live site. Over the years, plugins had been installed and removed, leaving behind orphaned tables with zero documentation. Once that clutter was cleaned out and useful data moved into proper relational Strapi tables, the database shrank 20x—from 1 GB down to 50 MB.
Engineering still life of database normalization: chaotic WordPress EAV cards transforming into a compact Strapi relational model with 1 GB to 50 MB compression.
Before a clean import was possible, the team had to untangle five real-world data anomalies, each requiring its own handler. First, the same JSON field could appear as a proper JSON object, a string with nested JSON, or a double-escaped string. Second, empty dates used 0000-00-00 instead of NULL. Third, some entities had no ID relations at all, so purchased guides and plans had to be matched by text title. Fourth, duplicate user accounts shared the same email. Fifth, passwords were stored in multiple hash formats.
They split the migration into a chain of scripts: users first, then plans, then subscriptions and payments, and finally guides, promo codes, and referral links. At every step, the script saved an old_id -> new_id mapping dictionary, and the legacy WordPress ID was kept on the Strapi profile for external integrations.
Verification didn't rely on murky SQL reports. Support managers simply opened migrated profiles in the new Strapi admin panel. For the first time in years, they saw everything in one card: subscriptions, payments, guides, favorites, promo codes, and sessions. If a doctor reported something missing, support opened the profile and resolved it themselves without filing a ticket for developers.
Pre-Migration Checklist for WordPress Databases
- Map every
meta_keyinwp_usermetaandwp_postmetaand match cryptic plugin keys against live screens. - Scan the database for zero dates (
0000-00-00), duplicate emails, and double-escaped JSON before running the import. - Identify entities without ID relations that must be matched by text title and prepare cleanup rules.
- Save an
old_id -> new_idmapping at every script stage and keep the legacy WordPress ID on profiles for external integrations. - Run spot checks on migrated records together with the support team directly inside the new admin panel.
Once the tables were in place and support confirmed that subscriptions were intact, one sensitive piece remained: letting thousands of doctors log into the new service without a mass password reset.
Custom Auth, Built-In MCP Server, and the Limits of This Stack
For end users, the team also skipped the default users-permissions login and built custom authentication using standard Strapi routes, controllers, and services on top of the profile collection. There were four reasons for this: keeping a profile with dozens of fields and relations in one table; enforcing a per-account device limit so paid subscriptions wouldn't be shared across ten people; supporting VK and Yandex login linked to existing accounts; and most importantly, verifying legacy WordPress password hashes so thousands of doctors could log in without forced resets.
Among newer platform features, the case study highlights Strapi 5's built-in MCP server (Model Context Protocol, an open protocol that lets AI agents like Claude or Cursor connect to external systems). It arrived in Strapi v5.47.0 and takes three lines in config/server.js to enable:
// config/server.js — enabling the built-in Strapi 5 MCP server
module.exports = ({ env }) => ({
mcp: {
enabled: true,
},
});
After a restart and rebuild, Strapi exposes a /mcp endpoint (Streamable HTTP). One key detail from the Strapi 5 docs: connecting an agent requires an Admin API Token (regular Content API tokens are rejected). The agent gets the exact permissions granted to that token, so you can delegate routine tasks like sorting a hundred articles into categories without exposing payments or user records.
Beyond what this project used, Strapi 5 also ships out of the box with i18n for localization, webhooks on record changes, an official GraphQL plugin, Strapi CLI for transferring data and files between production and staging, and providers for offloading media to S3.
Of course, this architecture has a price. Instead of a single familiar WordPress host, the team has to run and maintain a full stack: Node.js for Strapi, SSR Astro behind nginx, PostgreSQL, Redis with BullMQ, Meilisearch, ClickHouse, and DataLens integration. For a small blog, a brochure site, or a team without backend ops experience, this setup is clear overkill. When a subscription business hits a wall of slow admin screens, breaches, and untrusted metrics, however, a unified Strapi 5 backend with a fast Astro frontend easily pays back the setup effort.

![Node.JS [ru]](/api/digests/it_development/daily/20261120/assets/sources/we-use-js.jpg?v=afb257d234cb1d3faf22d5fdd950409b18a24d847efe80a63aa637d06c842b98)

