https://francl.digital/blog/ Notes from real engagements — websites, connecting systems, AI. Why I built something the way I did and what I would do differently next time. en-US krystof@francl.digital (Kryštof Francl) https://francl.digital/blog/why-this-site/ https://francl.digital/blog/why-this-site/ Mon, 20 Apr 2026 00:00:00 GMT I could have stopped at a LinkedIn profile. Here is why I built my own site on Cloudflare Workers instead. meta astro cloudflare portfolio https://francl.digital/blog/raveo/ https://francl.digital/blog/raveo/ Thu, 12 Mar 2026 00:00:00 GMT Every commissioned website started from zero. So I built myself a foundation — the client manages the content, there is no server to maintain, and the site runs fast worldwide. Cloudflare Astro PayloadCMS Workers edge {}); } return data; } ``` The key detail is the `fire-and-forget` KV write. The response to the user does not wait for the cache write to complete. The write happens in the background. On every request four things are fetched in parallel: ```ts const [navigation, siteSettings, pagesData, postsData] = await Promise.all([ cachedFetch(fetcher, cmsUrl, '/api/globals/navigation?depth=1', cache), cachedFetch(fetcher, cmsUrl, '/api/globals/site-settings?depth=1', cache), cachedFetch(fetcher, cmsUrl, '/api/pages?depth=2&limit=100&where[status][equals]=published', cache), cachedFetch(fetcher, cmsUrl, '/api/posts?depth=2&limit=100&where[status][equals]=published', cache), ]); ``` `Promise.all` matters here — all four calls go in parallel, not in sequence. ## Content revalidation The KV cache has a five-minute TTL. But what if the client saves a change and wants to see it immediately? Every collection in the CMS has an `afterChange` hook. When content is saved, the hook calls the Web Worker and tells it to invalidate the cache: ```ts const revalidate = async () => { if (process.env.NODE_ENV === 'production') { // Service binding: CMS Worker calls Web Worker directly await cfEnv.WEB.fetch( new Request('https://web/api/revalidate', { method: 'POST', headers: { 'x-revalidate-secret': cfEnv.REVALIDATE_SECRET ?? '' }, }), ); } else { await fetch(`${webUrl}/api/revalidate`, { method: 'POST', ... }); } }; export const revalidateAfterChange: CollectionAfterChangeHook = async ({ doc }) => { await revalidate(); return doc; }; ``` After revalidation the KV cache expires and the next request fetches fresh data from the CMS. No rebuild pipeline, no waiting on a deploy. ## Lexical renderer: JSON to HTML without JavaScript `PayloadCMS` stores rich text in `Lexical JSON` format — a tree of nodes. Ready-made libraries handle this through React and client-side JavaScript. But Astro pages are static and I do not want client-side JavaScript for this. So I wrote a custom server-side renderer. The interesting part is text formatting. Lexical stores format as a bitmask — a number where each bit represents a different style: ```ts function renderTextFormat(text: string, format: number): string { let result = escapeHtml(text); if (format & 16) result = `${result}`; // inline code if (format & 1) result = `${result}`; // bold if (format & 2) result = `${result}`; // italic if (format & 8) result = `${result}`; // underline if (format & 4) result = `${result}`; // strikethrough if (format & 32) result = `<sub>${result}</sub>`; // subscript if (format & 64) result = `<sup>${result}</sup>`; // superscript } ``` The bitwise AND (`&`) checks whether a given bit is set. Text can be bold and italic at the same time — both bits are set simultaneously. The renderer walks the full tree recursively: paragraphs, headings, blockquotes, lists, checkboxes, links, images. Output is clean HTML with no client-side JavaScript. ## Rate limiting on KV I did not want to bring in an external service for rate limiting. The `KV` namespace for cache is already there, so I used it for rate limiting too. The implementation is a sliding window: for each IP address it stores a request count and the start of the current time window: ```ts interface RateLimitEntry { count: number; windowStart: number; } ``` Key design decision: the rate limiter **fails open** — if `KV` is unavailable, the request goes through. The alternative would be to reject the request, but a KV outage would then take down the entire site. Fail open is the right call here. POST requests are limited to 10 per minute, API endpoints to 30. Responses include RFC-standard `RateLimit-Remaining` and `Retry-After` headers. ## Where it is now and where it is going I am building the website for my Scout troop Prácheň on Raveo. It will be the first real production deployment of the stack. Down the road I am interested in integrating `Medusa.js` as a transactional backend. That would make Raveo a base for e-commerce builds on commission: `PayloadCMS` for content management, `Medusa` for products and orders, `Astro` for the frontend. All without a traditional server, globally distributed, with content the client manages themselves. The full project is open source at [github.com/raveo-dev/raveo](https://github.com/raveo-dev/raveo).]]> https://francl.digital/blog/esmm-validator/ https://francl.digital/blog/esmm-validator/ Thu, 08 Jan 2026 00:00:00 GMT A typo in a spec surfaces at the tester or in the developer's code, and that means going back and redoing the work. So I built a tool that checks it earlier — an MCP server for the AI assistant in the editor. MCP integration validation AI banking ({ role: "user", content: { type: "text", text: idx === 0 ? block : `# CONTINUATION\n${block}`, }, })); const samplingResponse = await server.createMessage({ messages, systemPrompt, maxTokens: 16000, modelPreferences: { intelligencePriority: 0.9 }, }); ``` Each block is a separate message, the second and later ones have a `# CONTINUATION` header so the AI knows it is getting sequential data. The system prompt defines the exact validation rules. The output is a markdown table: ``` | index | file | sheet | row | column | raw_path | error_code | expected | ``` If the AI returns something unusable or an empty response, the tool discards the result and returns an empty skeleton. Bad results do not propagate further. ## What does not work and what I am fixing It would not be fair to only write about what works. The biggest practical problem is the context window. With a larger number of files or more complex `XSD` structures the context gets exhausted before the AI finishes validating. Sampling breaks off or returns an incomplete result. I handle it by splitting into smaller blocks, but with really large ESMM files it still hits the limit. Second issue: eight sequential steps the user has to trigger manually is inconvenient in practice. I built a simpler three-step workflow that compresses the whole process and the user triggers it once. Same result, much less friction. Third thing, a positive discovery this time: the model matters a lot. `claude-sonnet-4-6` with Thinking mode handles things where other models get stuck. Specifically: when the tool cannot find a file due to a naming inconsistency, the model identifies where the problem is, fills in the missing input and continues into the sampling phase without the user having to step in. That is a difference that saves real time. ## Where it is now Colleagues in the integration department are starting to use it. They run the validation before the ESMM goes to test analysis, and errors that used to surface at the tester or the developer get caught there instead. The project is internal and still evolving. But the principle transfers: take a spreadsheet spec, compare it against the actual files, return what does not match. MCP gives that a clean structure: tools for actions, resources for knowledge, prompts for workflow, sampling for AI. Four building blocks and from them you can put together something that behaves like a proper participant in the development environment, not an isolated script.]]>