How to retrieve content for a large audience close to real-time without reaching the limits of 6 requests / second?

Hello,

I nave a Nuxt app generating a website for events. In the newarby future the website will host a 50.000 audience within 4 days. Most of the data is populated during nuxtInit, therefore serving a static website with Netlify, fully generated before does not seem to be a problem. However this particular event also needs some special pages with custom design. In order to limit de work needed to accommodate this design and content challenges we decided to extend the the content about our item with Storyblock, meaning each page will have an associated ID from our source.

The content provided by Storyblock should be delived in a manner or real-time or as best as possible. As far as I can read, Storyblock has a limit of 6 requests / second, which obviously will not make it possible for each user to request the content in the client side, therefore some questions appear:

  • is it better to make the requests through AWS API gateway and put a caching layer in from?
  • how does the Storyblock memory work for nuxt on a client side enviroment? is there any caching?
  • should I just put an AWS cron job that delivers the message via graphql subscriptions?
  • should I create a cron job that exports to S3 and have a caching layer on that?

What would be the recommended solution to takle this? even if it’s not listed above?

Thanks

Hello Radu,

how exactly are you planning to deploy your page? Will your page be fully static or will you use SSR or SPA mode for the app?

The 6 requests per second relate to the management API which isn’t being thought to be used for delivering the content but for CRUD actions. For the delivery API the following section of the documentation shows the actual rate limits https://www.storyblok.com/docs/api/content-delivery#topics/rate-limit
In the list you can see the different cases for the rate limit below 1000 which apply for not cached content like the draft version of stories and the draft version of datasources. The 1000 requests per second apply to the cached content which can be reached when you’re using the published content version and the same cv value for the requests.

When you work with Storyblok CMS you can also use the Storyblok Nuxt Module from https://github.com/storyblok/storyblok-nuxt like explained in our article:
https://www.storyblok.com/tp/nuxt-js-multilanguage-website-tutorial

The access client comes with a local cache which can be activated when you initialize the client which is shown in the repository https://github.com/storyblok/storyblok-nuxt#setup and also in the tutorial https://www.storyblok.com/tp/nuxt-js-multilanguage-website-tutorial#connecting-storyblok-with-nuxt-js

When using the local cache of the client you can control the cache using a webhook ( https://www.storyblok.com/docs/Guides/using-storyblok-webhooks#available-webhooks ) for triggering the flushCache() function of the client https://github.com/storyblok/storyblok-js-client#method-storyblokflushcache when publishing new content on Storyblok. This also triggers the generation of a new cv value which invalidates the cache of the CDN and will fetch the new content from Storyblok CMS. This will give you the possibility to serve the content to even more page visitors if you want to use a dynamic page.

In the case that you don’t want to use the access client you can also take a look at the me endpoint which will give you the space object with a timestamp in the version property: https://www.storyblok.com/docs/api/content-delivery#topics/cache-invalidation