<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>DEV Community: Flude team</title>
    <description>The latest articles on DEV Community by Flude team (@flude_team).</description>
    <link>https://dev.to/flude_team</link>
    <image>
      <url>https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https:%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Fuser%2Fprofile_image%2F4043834%2F57eca9f0-8b66-4e9d-b493-6c13ecd57dfd.png</url>
      <title>DEV Community: Flude team</title>
      <link>https://dev.to/flude_team</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/flude_team"/>
    <language>en</language>
    <item>
      <title>The Invisible Type: Three Escapes of size_t from Linux CI</title>
      <dc:creator>Flude team</dc:creator>
      <pubDate>Fri, 20 Nov 2026 05:06:14 +0000</pubDate>
      <link>https://dev.to/flude_team/the-invisible-type-three-escapes-of-sizet-from-linux-ci-2o18</link>
      <guid>https://dev.to/flude_team/the-invisible-type-three-escapes-of-sizet-from-linux-ci-2o18</guid>
      <description>&lt;p&gt;Unlike &lt;code&gt;int&lt;/code&gt; or &lt;code&gt;float&lt;/code&gt;, in C++ the &lt;code&gt;size_t&lt;/code&gt; type is not a built-in language keyword. It is a regular &lt;code&gt;typedef&lt;/code&gt; that lives in system header files (for example, &lt;code&gt;&amp;lt;cstddef&amp;gt;&lt;/code&gt;). However, in real projects, developers often use &lt;code&gt;size_t&lt;/code&gt; "naked," without an explicit &lt;code&gt;#include&lt;/code&gt;, relying on transitive inclusion from other files.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fexmlyehf95kcs6vmximx.jpg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fexmlyehf95kcs6vmximx.jpg" alt="Invisible Type Size T Linux Ci" width="800" height="800"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;The old Doxygen parser we were stuck on before didn't care about this—it worked like a regular expression and simply read text. But when we switched to a true AST parser (via &lt;code&gt;libclang&lt;/code&gt;), the compiler demanded strictness. And so began one of the most ridiculous quests in the history of our CI.&lt;/p&gt;

&lt;h2&gt;
  
  
  Escape One: Silent Annihilation
&lt;/h2&gt;

&lt;p&gt;We wrote tests for the new parser, ran them locally on Windows—everything was green. Over 1200 tests passed successfully, the &lt;code&gt;operator size_t()&lt;/code&gt; method parsed perfectly. We pushed the code to GitHub Actions.&lt;/p&gt;

&lt;p&gt;The build on the Linux runner failed.&lt;/p&gt;

&lt;p&gt;It turned out that on Windows, the &lt;code&gt;libclang&lt;/code&gt; library uses the auto-discovery "magic" of the built-in MSVC toolchain—it implicitly pulls in environment definitions, so &lt;code&gt;size_t&lt;/code&gt; always exists there, even in a completely empty file.&lt;/p&gt;

&lt;p&gt;But on Linux, &lt;code&gt;libclang&lt;/code&gt; is brutally honest: didn't find an &lt;code&gt;#include&lt;/code&gt; — means the type doesn't exist. Encountering the unknown &lt;code&gt;size_t&lt;/code&gt; type, the parser panicked, went into error-recovery mode, and simply &lt;strong&gt;silently deleted the entire method&lt;/strong&gt; from the final Abstract Syntax Tree (AST). A whole chunk of the API literally dissolved into thin air.&lt;/p&gt;

&lt;h2&gt;
  
  
  Escape Two: The Empty Container Trap
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fmfo8e6sxtmm8ijzoe1r5.jpg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fmfo8e6sxtmm8ijzoe1r5.jpg" alt="Invisible Type Size T Linux Ci Part 3" width="800" height="800"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fmj2b03szoork89qbribd.jpg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fmj2b03szoork89qbribd.jpg" alt="Invisible Type Size T Linux Ci Part 2" width="800" height="800"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;The solution seemed obvious: we needed to force the parser to include the header file! We added the &lt;code&gt;-include stddef.h&lt;/code&gt; compiler flag to all the files we parse.&lt;/p&gt;

&lt;p&gt;Local tests passed. The documentation generation job in CI also went green. But the baseline CI job with unit tests blew up with a fatal error: &lt;code&gt;'stddef.h' file not found&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;The answer lay in the infrastructure. The unit tests ran in a lightweight, minimalist Docker image. It had Python, it had the old Doxygen, but &lt;strong&gt;it did not have the GCC compiler and the build-essential package&lt;/strong&gt;. The &lt;code&gt;stddef.h&lt;/code&gt; file physically did not exist on the disk.&lt;/p&gt;

&lt;p&gt;Our "fix" broke the parsing of absolutely all files in the project, even those where the &lt;code&gt;size_t&lt;/code&gt; type had never existed.&lt;/p&gt;

&lt;h2&gt;
  
  
  Escape Three: A Stab in the Back from Mypy
&lt;/h2&gt;

&lt;p&gt;We needed a solution that completely bypasses the need for an installed compiler in the operating system. And we found an elegant hack.&lt;/p&gt;

&lt;p&gt;We forced Python to dynamically create a fake header file in the temporary directory (&lt;code&gt;/tmp&lt;/code&gt;) with the following code:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight cpp"&gt;&lt;code&gt;&lt;span class="k"&gt;typedef&lt;/span&gt; &lt;span class="n"&gt;__SIZE_TYPE__&lt;/span&gt; &lt;span class="kt"&gt;size_t&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The secret is that &lt;code&gt;__SIZE_TYPE__&lt;/code&gt; is an internal built-in macro of Clang/GCC that always exists in the compiler's memory, regardless of headers. We fed this temporary file to &lt;code&gt;libclang&lt;/code&gt; via the same &lt;code&gt;-include&lt;/code&gt; flag.&lt;/p&gt;

&lt;p&gt;We push the commit to CI. And it... fails again!&lt;/p&gt;

&lt;p&gt;This time, it wasn't C++ that broke, but the Python static analyzer—&lt;code&gt;mypy&lt;/code&gt;. The developer's local machine had a fresh Python version that inferred types correctly. But the CI had a slightly stricter version that tripped over a triviality: we declared a variable for the temporary file path as &lt;code&gt;None&lt;/code&gt;, and then tried to put a string into it. The analyzer threw an &lt;code&gt;Incompatible types in assignment&lt;/code&gt; error.&lt;/p&gt;

&lt;h2&gt;
  
  
  Caught
&lt;/h2&gt;

&lt;p&gt;We had to make a third commit: appease &lt;code&gt;mypy&lt;/code&gt; by explicitly writing the annotation &lt;code&gt;Optional[str] = None&lt;/code&gt; in the Python code.&lt;/p&gt;

&lt;p&gt;And only then, on the third try, did the pipeline finally turn green.&lt;/p&gt;

&lt;p&gt;We spent an entire day teaching a C++ AST parser to understand the most basic data type on an operating system that doesn't have a compiler. Developing cross-platform toolchains is when Windows hides your own bugs from you, Linux slaps your hands for system dependencies, and a strict linter from a completely different language finishes you off.&lt;/p&gt;

&lt;p&gt;However, the conflicts with C++ didn't end there. When a real compiler encounters legacy Doxygen virtual grouping tags (like &lt;code&gt;@addtogroup&lt;/code&gt;), a war breaks out between real C++ namespaces and the virtual documentation structure. How we reconciled these two worlds in the AST—read about it in the next episode.&lt;/p&gt;




&lt;p&gt;&lt;em&gt;Originally published on our blog: &lt;a href="https://blog.flude.guide/blog/invisible-type-size-t-linux-ci" rel="noopener noreferrer"&gt;https://blog.flude.guide/blog/invisible-type-size-t-linux-ci&lt;/a&gt;&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Also read us:&lt;/strong&gt;&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href="https://t.me/ude_blog_en" rel="noopener noreferrer"&gt;Telegram channel&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://blog.flude.guide/rss-en.xml" rel="noopener noreferrer"&gt;RSS feed&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

</description>
      <category>cpp</category>
      <category>libclang</category>
      <category>ci</category>
      <category>linux</category>
    </item>
    <item>
      <title>The Watchdog Needs a Watchdog: How a Rescue Script Hung Inside Itself</title>
      <dc:creator>Flude team</dc:creator>
      <pubDate>Tue, 17 Nov 2026 04:28:16 +0000</pubDate>
      <link>https://dev.to/flude_team/the-watchdog-needs-a-watchdog-how-a-rescue-script-hung-inside-itself-3dac</link>
      <guid>https://dev.to/flude_team/the-watchdog-needs-a-watchdog-how-a-rescue-script-hung-inside-itself-3dac</guid>
      <description>&lt;p&gt;After colliding with network ghosts on our self-hosted runners, we learned one rule: networks and virtual machines are extremely unreliable entities.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fitizu6j9tddljubxb6u2.jpg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fitizu6j9tddljubxb6u2.jpg" alt="The Watchdog Needs A Watchdog" width="800" height="800"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;To avoid running to the server every time the pipeline "stuck fast," we wrote a Supervisor script (to manage the process) and a completely independent Watchdog script. Its logic was primitive and reliable: if the Supervisor doesn't respond, kill it, send us a nice Telegram alert, and restart the process.&lt;/p&gt;

&lt;p&gt;This was a perfect, self-healing system. Or so we thought.&lt;/p&gt;

&lt;h2&gt;
  
  
  First Blood: Telegram's Betrayal
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F0cx529bt44t0dr60v5rm.jpg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F0cx529bt44t0dr60v5rm.jpg" alt="Frozen Telegram connection" width="800" height="800"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;One day, the Watchdog correctly caught a Supervisor hang and initiated the rescue procedure. As a first step, it attempted to execute the &lt;code&gt;Alert()&lt;/code&gt; function to send us a Telegram message via standard &lt;code&gt;Invoke-RestMethod&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;And then the system froze forever.&lt;/p&gt;

&lt;p&gt;It turned out that after the host woke from sleep mode, the TCP connection to the Telegram API had "frozen" at the operating system level. At the same time, the built-in PowerShell timeout was completely ignored by the underlying platform.&lt;/p&gt;

&lt;p&gt;The Watchdog hung dead trying to send a message about a hang, never reaching the life-saving restart function.&lt;/p&gt;

&lt;p&gt;We learned our first lesson: &lt;strong&gt;never block recovery with a network call&lt;/strong&gt;. We moved the alert dispatch into an isolated background process (&lt;code&gt;Start-Job&lt;/code&gt;) with a brutal 20-second timeout. If the network was silent—we simply dropped the alert and proceeded to recovery.&lt;/p&gt;

&lt;h2&gt;
  
  
  Trench Warfare
&lt;/h2&gt;

&lt;p&gt;We thought that after the Telegram patch, we were safe. But the infrastructure began striking from all sides. Over the following weeks, we methodically closed new holes, taking hit after hit:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;The Supervisor crashed, leaving behind a locked system mutex, preventing its own restart. We had to write logic to intercept abandoned mutexes.&lt;/li&gt;
&lt;li&gt;The GitHub API periodically lagged, and the script lost its retry logic. We had to patch the state machine.&lt;/li&gt;
&lt;li&gt;The virtual machine started throwing new, previously unseen connection drop signatures (&lt;code&gt;VERR_TIMEOUT&lt;/code&gt;). We populated our crash dictionaries.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;We surrounded the code with so many checks and &lt;code&gt;try/catch&lt;/code&gt; layers that the script looked bulletproof. The system was supposed to silently and efficiently heal itself under any circumstances.&lt;/p&gt;

&lt;h2&gt;
  
  
  Deep Windows Coma (The Final Boss)
&lt;/h2&gt;

&lt;p&gt;Two more weeks passed. The system worked stably, until the CI suddenly stuck fast again.&lt;/p&gt;

&lt;p&gt;We logged into the server and opened the Watchdog logs. The last entry read: &lt;code&gt;"Hang confirmation 1/2"&lt;/code&gt;. After this line in the logs, there was a yawning void &lt;strong&gt;14 hours long&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;There were no exceptions, no script crashes, no records of killed processes in the operating system's Event Logs. An absolute freeze.&lt;/p&gt;

&lt;p&gt;We started disassembling the Watchdog code line by line. Right after the log entry came the only call without our own custom timeout: a local system query &lt;code&gt;Get-CimInstance Win32_Process&lt;/code&gt;. With this query, the Watchdog was asking Windows itself: "Is the Supervisor process alive?".&lt;/p&gt;

&lt;p&gt;The truth turned out to be terrifying. Due to a failure deep in the bowels of the OS, the WMI (Windows Management Instrumentation) service had also gone into a coma. The Watchdog asked the system a question, and the operating system simply never answered it, freezing the rescue script forever. The very tool we used to check for hangs had hung itself.&lt;/p&gt;

&lt;h2&gt;
  
  
  Conclusion: Recursive Paranoia
&lt;/h2&gt;

&lt;p&gt;The Watchdog needed its own timer even for trivial built-in OS commands. We had to wrap the basic local &lt;code&gt;Get-CimInstance&lt;/code&gt; call in the same strict background process with a timeout as the network requests.&lt;/p&gt;

&lt;p&gt;This became our main lesson in self-hosted infrastructure: &lt;strong&gt;you cannot trust anything&lt;/strong&gt;. Not the network, not someone else's API, not the built-in timeouts of the programming language, not even the local system APIs of your own OS. If you write code that must save a system from hanging, every single line of it must have external, paranoid time control. &lt;em&gt;Quis custodiet ipsos custodes?&lt;/em&gt; (Who will watch the watchmen?).&lt;/p&gt;

&lt;p&gt;But infrastructure calls are only half the problems of a complex project. Sometimes the programming language itself starts hiding basic things from us. How the classic &lt;code&gt;size_t&lt;/code&gt; type managed to escape our C++ parser on Linux three times, breaking Continuous Integration—read about it in the next episode.&lt;/p&gt;




&lt;p&gt;&lt;em&gt;Originally published on our blog: &lt;a href="https://blog.flude.guide/blog/the-watchdog-needs-a-watchdog" rel="noopener noreferrer"&gt;https://blog.flude.guide/blog/the-watchdog-needs-a-watchdog&lt;/a&gt;&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Also read us:&lt;/strong&gt;&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href="https://t.me/ude_blog_en" rel="noopener noreferrer"&gt;Telegram channel&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://blog.flude.guide/rss-en.xml" rel="noopener noreferrer"&gt;RSS feed&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

</description>
      <category>powershell</category>
      <category>devops</category>
      <category>watchdog</category>
      <category>ci</category>
    </item>
    <item>
      <title>Beyond GitHub: Universal Clients, Code Quality, and Bitbucket Traps</title>
      <dc:creator>Flude team</dc:creator>
      <pubDate>Fri, 13 Nov 2026 04:06:00 +0000</pubDate>
      <link>https://dev.to/flude_team/beyond-github-universal-clients-code-quality-and-bitbucket-traps-285j</link>
      <guid>https://dev.to/flude_team/beyond-github-universal-clients-code-quality-and-bitbucket-traps-285j</guid>
      <description>&lt;p&gt;Our core was working perfectly, and the SaaS cloud was ready to accept requests. But for third-party developers to easily start using Flude, they needed convenient entry points—integrations with their CI/CD pipelines.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Flhg291cw6ns5edk0tax3.jpg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Flhg291cw6ns5edk0tax3.jpg" alt="CI Thin Clients" width="800" height="800"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Initially, we wrote a plugin exclusively for GitHub Actions. However, a huge number of projects and commercial teams prefer GitLab and Bitbucket. It became obvious that we needed to extract the logic into a universal "thin client" that would work equally well on the "big three" platforms.&lt;/p&gt;

&lt;h2&gt;
  
  
  The Thin Client Philosophy
&lt;/h2&gt;

&lt;p&gt;We moved all the base logic into clean, independent JavaScript files (&lt;code&gt;control-plane-client.js&lt;/code&gt;, &lt;code&gt;poll.js&lt;/code&gt;, &lt;code&gt;download.js&lt;/code&gt;). No heavy builds or &lt;code&gt;node_modules&lt;/code&gt; folders.&lt;/p&gt;

&lt;p&gt;Our CI client became as dumb as possible: it simply zips the source code, sends it via API to our SaaS cloud, pings the task status at a set interval, and downloads the final ZIP archive with the generated documentation. All the computational magic, parsing, and rendering happen exclusively on the backend.&lt;/p&gt;

&lt;h2&gt;
  
  
  GitLab and Reporting Architecture (Code Quality)
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Foee5et7sukpi1izt4pcr.jpg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Foee5et7sukpi1izt4pcr.jpg" alt="Ci Thin Clients Gitlab Bitbucket Part 2" width="800" height="800"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Integrating with GitLab brought an interesting architectural challenge.&lt;/p&gt;

&lt;p&gt;In GitHub Actions, parser warnings (e.g., about undocumented methods) are easily output to the UI via &lt;code&gt;GITHUB_STEP_SUMMARY&lt;/code&gt; and magic strings like &lt;code&gt;::notice::&lt;/code&gt;. GitLab doesn't understand this—it requires providing a special JSON artifact in the CodeClimate format.&lt;/p&gt;

&lt;p&gt;An important architectural point: we fundamentally decided not to overload our lightweight client with format conversion logic. All this work is baked into the very heart of the core (&lt;code&gt;engine/ude/reporting.py&lt;/code&gt;).&lt;/p&gt;

&lt;p&gt;During the build, the engine collects all errors into a unified internal representation (&lt;code&gt;Finding&lt;/code&gt;), and then translates it itself into all the necessary external formats: both SARIF (for GitHub) and CodeClimate (for GitLab). The client script in GitLab only has to extract the already generated &lt;code&gt;codequality.json&lt;/code&gt; from the downloaded archive and hand it to the runner. Thanks to this, a native, convenient widget "Code Quality scans found N new findings" appears in the Merge Request.&lt;/p&gt;

&lt;h2&gt;
  
  
  Bitbucket Pipe and the Docker Trap
&lt;/h2&gt;

&lt;p&gt;Integrations in the Bitbucket ecosystem work via so-called "Pipes," which are executed strictly inside isolated Docker containers. To support this platform, we wrapped our JS scripts in a &lt;code&gt;Dockerfile&lt;/code&gt; and added a &lt;code&gt;pipe.yml&lt;/code&gt; manifest.&lt;/p&gt;

&lt;p&gt;And this is exactly where we fell into a classic networking trap. When writing E2E tests locally, our containerized client naturally tried to reach the local mock server at &lt;code&gt;localhost:29418&lt;/code&gt;. But we forgot the basics: inside Docker, &lt;code&gt;localhost&lt;/code&gt; is the container itself, not the host machine! The requests went into the void, and the tests failed on timeout.&lt;/p&gt;

&lt;p&gt;We had to tinker quite a bit with Docker's bridge network settings and port forwarding to make the Pipe see the host machine and successfully pass local testing.&lt;/p&gt;

&lt;h2&gt;
  
  
  Conclusion
&lt;/h2&gt;

&lt;p&gt;We successfully covered the "big three" CI/CD platforms. The ecosystem closed the loop: C++ code flies from any popular CI runner to our cloud and returns as gold-standard documentation and quality reports.&lt;/p&gt;

&lt;p&gt;But having opened the gates to the SaaS for everyone, we faced a new threat. Hung Doxygen and &lt;code&gt;git clone&lt;/code&gt; processes began to uncontrollably devour cloud resources. How we built a system of watchdog timers and why the Watchdog itself needed a Watchdog—read about it in the next episode.&lt;/p&gt;




&lt;p&gt;&lt;em&gt;Originally published on our blog: &lt;a href="https://blog.flude.guide/blog/ci-thin-clients-gitlab-bitbucket" rel="noopener noreferrer"&gt;https://blog.flude.guide/blog/ci-thin-clients-gitlab-bitbucket&lt;/a&gt;&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Also read us:&lt;/strong&gt;&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href="https://t.me/ude_blog_en" rel="noopener noreferrer"&gt;Telegram channel&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://blog.flude.guide/rss-en.xml" rel="noopener noreferrer"&gt;RSS feed&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

</description>
      <category>ci</category>
      <category>gitlab</category>
      <category>bitbucket</category>
      <category>flude</category>
    </item>
    <item>
      <title>Legacy in Pictures: How We Drew PNG Diagrams on the Backend</title>
      <dc:creator>Flude team</dc:creator>
      <pubDate>Wed, 11 Nov 2026 14:54:23 +0000</pubDate>
      <link>https://dev.to/flude_team/legacy-in-pictures-how-we-drew-png-diagrams-on-the-backend-2j0f</link>
      <guid>https://dev.to/flude_team/legacy-in-pictures-how-we-drew-png-diagrams-on-the-backend-2j0f</guid>
      <description>&lt;p&gt;Configuring the file structure via &lt;code&gt;sidebar.toml&lt;/code&gt; was only half the battle. The second strict requirement for a successful migration at work was the presence of visual Class Hierarchy diagrams.&lt;/p&gt;

&lt;p&gt;The problem was that the old generator output these diagrams not as a trendy interactive web component, but as ordinary, static PNG images embedded directly into the HTML code.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why Not Modern JS?
&lt;/h2&gt;

&lt;p&gt;In the modern world, the logical solution would be to pass a JSON tree structure to the frontend and render a beautiful interactive graph using Mermaid.js or React Flow.&lt;/p&gt;

&lt;p&gt;But we had strict limitations. The generated documentation had to be able to work offline, load instantly without heavy JS bundles, and most importantly, visually match the old corporate style. There was only one solution left: draw real PNG files right during the build process on the backend.&lt;/p&gt;

&lt;h2&gt;
  
  
  Pixel Art with Pillow
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fsuehhyp7ipmroebxmmpy.jpg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fsuehhyp7ipmroebxmmpy.jpg" alt="Legacy PNG Diagrams Pillow" width="800" height="800"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;We brought the &lt;code&gt;Pillow&lt;/code&gt; library into the pipeline.&lt;/p&gt;

&lt;p&gt;Generating graphics on the server side is quite a quest. We had to write AST traversal logic that took a class's list of ancestors and programmatically drew them on a virtual canvas. We manually calculated font sizes, the coordinates of each rectangle, margins, and drew connecting lines with arrows. It was painstaking work with graphic primitives inside a harsh documentation generation engine.&lt;/p&gt;

&lt;h2&gt;
  
  
  Regression Testing Hell
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F3z1mhe44y57phhgiwh8p.jpg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F3z1mhe44y57phhgiwh8p.jpg" alt="Legacy Png Diagrams Pillow Part 2" width="800" height="800"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;The real fun began when we covered this functionality with regression tests. In our CI pipeline, the image tests started failing unpredictably.&lt;/p&gt;

&lt;p&gt;Initially, we compared the generated PNG files with reference images byte-for-byte (&lt;code&gt;raw bytes&lt;/code&gt;). But an unpleasant detail emerged: the PNG compression byte stream differed slightly depending on the operating system (Windows on a local machine vs Linux in CI). Different versions of the system &lt;code&gt;zlib&lt;/code&gt; library compressed the exact same pixels into different binary code.&lt;/p&gt;

&lt;p&gt;Visually, the images were absolutely identical, but the file hashes diverged. We had to completely rewrite the tests: now we loaded both the reference and the result through Pillow, decoded them, and compared the RGBA matrices in memory pixel by pixel. Only then did the tests turn green.&lt;/p&gt;

&lt;h2&gt;
  
  
  Moving to the Core
&lt;/h2&gt;

&lt;p&gt;Just like with &lt;code&gt;sidebar.toml&lt;/code&gt;, we initially wrote the image generation exclusively as a crutch for the working plugin.&lt;/p&gt;

&lt;p&gt;But when the algorithm was debugged, we realized we had built a cool feature. Lightweight, static inheritance diagrams without JS dependencies are an objective plus for any project. Following the established pattern, we pulled the graphics rendering logic out of the closed plugin and moved it into the main Flude core.&lt;/p&gt;

&lt;h2&gt;
  
  
  Conclusion
&lt;/h2&gt;

&lt;p&gt;All work requirements were met: both for links and for images. The core proved its flexibility and readiness to operate in harsh Enterprise conditions.&lt;/p&gt;

&lt;p&gt;Ahead of us lay stepping outside our cozy local environment. It was time to integrate our CLI clients with popular CI/CD platforms. How we lost environment variables in GitLab and battled proxies in Bitbucket—read about it in the next episode.&lt;/p&gt;




&lt;p&gt;&lt;em&gt;Originally published on our blog: &lt;a href="https://blog.flude.guide/blog/legacy-png-diagrams-pillow" rel="noopener noreferrer"&gt;https://blog.flude.guide/blog/legacy-png-diagrams-pillow&lt;/a&gt;&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Also read us:&lt;/strong&gt;&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href="https://t.me/ude_blog_en" rel="noopener noreferrer"&gt;Telegram channel&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://blog.flude.guide/rss-en.xml" rel="noopener noreferrer"&gt;RSS feed&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

</description>
      <category>python</category>
      <category>graphics</category>
      <category>architecture</category>
      <category>testing</category>
    </item>
    <item>
      <title>The Battle with the Gold Standard: How sidebar.toml Saved Us from Hardcoded Structure</title>
      <dc:creator>Flude team</dc:creator>
      <pubDate>Fri, 06 Nov 2026 03:52:39 +0000</pubDate>
      <link>https://dev.to/flude_team/the-battle-with-the-gold-standard-how-sidebartoml-saved-us-from-hardcoded-structure-30j3</link>
      <guid>https://dev.to/flude_team/the-battle-with-the-gold-standard-how-sidebartoml-saved-us-from-hardcoded-structure-30j3</guid>
      <description>&lt;p&gt;While we were designing future native parsers, nobody canceled the task of migrating to Flude at work. And that had its own corporate challenges.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fned9r96pdm3kxmni6lyo.jpg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fned9r96pdm3kxmni6lyo.jpg" alt="Sidebar Toml Legacy Routing" width="800" height="800"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;The business had one ironclad condition: the migration to Flude had to be absolutely transparent. Our output (still running on Doxygen at the time) had to match the output of the old documentation generator one-to-one, both in completeness and in page structure, including the exact names of the generated HTML files.&lt;/p&gt;

&lt;h2&gt;
  
  
  A Different Philosophy of Structure
&lt;/h2&gt;

&lt;p&gt;The problem lay in the fundamental difference in renderer philosophies. The modern approach to documentation generation implies that an entire class (with all its properties and methods) is rendered on a single, continuous page. Navigation within the class happens via standard HTML anchors (e.g., &lt;code&gt;class.html#MethodName&lt;/code&gt;).&lt;/p&gt;

&lt;p&gt;The old generator worked completely differently: for every single method, property, and class member, it created its own tiny, separate HTML page.&lt;/p&gt;

&lt;p&gt;If we had applied the modern approach, we would have instantly broken a ton of old links, bookmarks, and internal integrations that the company's engineers had grown accustomed to over the years. We had to emulate this legacy structure at all costs.&lt;/p&gt;

&lt;h2&gt;
  
  
  Declarative sidebar.toml
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fmisct9kyzwszkk0632do.jpg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fmisct9kyzwszkk0632do.jpg" alt="Sidebar Toml Legacy Routing Part 2" width="800" height="800"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;For the company's specific needs, we had a dedicated private plugin. But I categorically did not want to hardcode the "page splitting" logic even there. The initial plan was: move the logic into flexible settings, and if it works well—transfer the feature to the main core.&lt;/p&gt;

&lt;p&gt;The solution was a configuration file: &lt;code&gt;sidebar.toml&lt;/code&gt;. It allowed us to manually configure the rules for forming the navigation menu and flexibly control how the logical structure of the code would map onto the physical file system and the structure of the documentation itself. This manifest allowed us not to hardcode the output, but to keep it entirely in the configuration.&lt;/p&gt;

&lt;h2&gt;
  
  
  Moving to the Main Core
&lt;/h2&gt;

&lt;p&gt;The experiment turned out to be incredibly successful. Untying the physical output structure from the parser's internal architecture is a very powerful pattern.&lt;/p&gt;

&lt;p&gt;As planned, we moved the &lt;code&gt;sidebar.toml&lt;/code&gt; mechanics from the working plugin into the main Flude core, making it the absolute standard for generating any projects.&lt;/p&gt;

&lt;h2&gt;
  
  
  SaaS Limitations
&lt;/h2&gt;

&lt;p&gt;True, there is one nuance. Even though the core now supports generating any custom structure via &lt;code&gt;sidebar.toml&lt;/code&gt;, we do not yet give users this freedom in our cloud SaaS version.&lt;/p&gt;

&lt;p&gt;Our cloud workers use a static &lt;code&gt;sidebar.toml&lt;/code&gt; file that we place on the server ourselves. The user simply has no access to it and cannot pass their config from the outside. In the current SaaS version, the ability to change the structural configuration is locked. But the main thing is that the architectural foundation for it is already reliably laid in the core.&lt;/p&gt;

&lt;h2&gt;
  
  
  Conclusion
&lt;/h2&gt;

&lt;p&gt;With the help of configuration, we successfully untied the output structure from the parser structure and completely satisfied the work requirements for links.&lt;/p&gt;

&lt;p&gt;But to successfully deliver the project, one more visual problem remained. The old generator knew how to draw class inheritance diagrams in PNG format, and we needed to replicate this functionality. How we implemented image generation and why this feature also moved to the core—read about it in the next episode.&lt;/p&gt;




&lt;p&gt;&lt;em&gt;Originally published on our blog: &lt;a href="https://blog.flude.guide/blog/sidebar-toml-legacy-routing" rel="noopener noreferrer"&gt;https://blog.flude.guide/blog/sidebar-toml-legacy-routing&lt;/a&gt;&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Also read us:&lt;/strong&gt;&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href="https://t.me/ude_blog_en" rel="noopener noreferrer"&gt;Telegram channel&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://blog.flude.guide/rss-en.xml" rel="noopener noreferrer"&gt;RSS feed&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

</description>
      <category>architecture</category>
      <category>routing</category>
      <category>flude</category>
      <category>rendering</category>
    </item>
    <item>
      <title>AST Reconstruction: How We Manually Stitched Out-Of-Line Methods in libclang</title>
      <dc:creator>Flude team</dc:creator>
      <pubDate>Tue, 03 Nov 2026 04:44:00 +0000</pubDate>
      <link>https://dev.to/flude_team/ast-reconstruction-how-we-manually-stitched-out-of-line-methods-in-libclang-pn2</link>
      <guid>https://dev.to/flude_team/ast-reconstruction-how-we-manually-stitched-out-of-line-methods-in-libclang-pn2</guid>
      <description>&lt;p&gt;In the previous episode, we taught our native parser based on &lt;code&gt;libclang&lt;/code&gt; to find system headers. It stopped panicking and finally read all the code without errors.&lt;/p&gt;

&lt;p&gt;But when we ran the documentation generation and started verifying completeness metrics, we discovered a disaster. Hundreds of methods were missing from our generated classes. The parser had simply "lost" them along the way.&lt;/p&gt;

&lt;h2&gt;
  
  
  The Core Problem: Out-Of-Line Methods
&lt;/h2&gt;

&lt;p&gt;In C++, it is considered good practice to move the implementation of methods outside the class declaration. Usually, the implementation goes into separate &lt;code&gt;.cpp&lt;/code&gt; files, and in the case of template classes, it remains in the header file but is written below the class itself. Both variants are called &lt;em&gt;Out-Of-Line&lt;/em&gt; definitions:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight cpp"&gt;&lt;code&gt;&lt;span class="k"&gt;template&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;T&lt;/span&gt;&lt;span class="p"&gt;&amp;gt;&lt;/span&gt; &lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;MyClass&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="kt"&gt;void&lt;/span&gt; &lt;span class="n"&gt;foo&lt;/span&gt;&lt;span class="p"&gt;();&lt;/span&gt;
&lt;span class="p"&gt;};&lt;/span&gt;

&lt;span class="k"&gt;template&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;T&lt;/span&gt;&lt;span class="p"&gt;&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;void&lt;/span&gt; &lt;span class="n"&gt;MyClass&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;T&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;::&lt;/span&gt;&lt;span class="n"&gt;foo&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="p"&gt;...&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Good old Doxygen forgave such things: it parsed the code as text and, by the &lt;code&gt;MyClass::&lt;/code&gt; prefix, easily guessed where to put the method.&lt;/p&gt;

&lt;h2&gt;
  
  
  How libclang "Loses" Children
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F0t0mjx0e3qovsgyq58t8.jpg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F0t0mjx0e3qovsgyq58t8.jpg" alt="Libclang Ast Reconstruction Out Of Line Part 2" width="800" height="800"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;But &lt;code&gt;libclang&lt;/code&gt; builds a strict semantic Abstract Syntax Tree (AST). In its architecture, a class declaration is a single node. And an Out-Of-Line method is a completely independent top-level node (Top-level declaration), hanging somewhere in the global scope of the translation unit.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fwrw7f63w6jbkqbleu0wh.jpg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fwrw7f63w6jbkqbleu0wh.jpg" alt="Libclang AST Reconstruction" width="800" height="800"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;code&gt;libclang&lt;/code&gt; fundamentally does not nest this method inside the class cursor during tree traversal. As a result, our AST traversal script saw the class, saw that there were no method nodes inside it, and happily generated an empty documentation page.&lt;/p&gt;

&lt;h2&gt;
  
  
  Surgical Splicing
&lt;/h2&gt;

&lt;p&gt;To restore justice, we had to write our own tree reconstruction algorithm.&lt;/p&gt;

&lt;p&gt;We introduced a separate parser pass: we traversed all "free-hanging" functions in the global scope and asked Clang for their semantic parent (&lt;code&gt;semantic_parent&lt;/code&gt;). If it turned out that a function semantically belonged to some class, we took that node and "manually" stitched it inside the appropriate class in our Intermediate Representation (&lt;code&gt;ProjectCatalog&lt;/code&gt;).&lt;/p&gt;

&lt;p&gt;We literally assembled the fragmented code like a puzzle.&lt;/p&gt;

&lt;h2&gt;
  
  
  Nameless Conversions
&lt;/h2&gt;

&lt;p&gt;But the surprises didn't end there. The second pain point was type casting operators for dependent templates (for example, &lt;code&gt;cv::Ptr&amp;lt;T&amp;gt;::operator T*()&lt;/code&gt;).&lt;/p&gt;

&lt;p&gt;We discovered that for such nodes (with the &lt;code&gt;CONVERSION_FUNCTION&lt;/code&gt; type), &lt;code&gt;libclang&lt;/code&gt; outputs an empty string as a name—&lt;code&gt;cursor.spelling&lt;/code&gt; returned &lt;code&gt;""&lt;/code&gt;. Meaning the method is there, but it has no name!&lt;/p&gt;

&lt;p&gt;We had to write a dirty but working hack: we parsed the node's return type and manually synthesized the string name of the operator from it so that the documentation would look adequate.&lt;/p&gt;

&lt;h2&gt;
  
  
  Conclusion
&lt;/h2&gt;

&lt;p&gt;This "garbage collection" and manual AST tree splicing restored our method completeness (Recall) to 97.4%.&lt;/p&gt;

&lt;p&gt;We achieved almost perfect data extraction. It was time to apply this parser in real combat for a large corporate client. From the very beginning, we knew about the business's main strict requirement: the output of our modern parser had to completely match their old documentation generator. Now it was time to put this into practice. How we aligned the file structure and routing—read about it in the next episode.&lt;/p&gt;




&lt;p&gt;&lt;em&gt;Originally published on our blog: &lt;a href="https://blog.flude.guide/blog/libclang-ast-reconstruction-out-of-line" rel="noopener noreferrer"&gt;https://blog.flude.guide/blog/libclang-ast-reconstruction-out-of-line&lt;/a&gt;&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Also read us:&lt;/strong&gt;&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href="https://t.me/ude_blog_en" rel="noopener noreferrer"&gt;Telegram channel&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://blog.flude.guide/rss-en.xml" rel="noopener noreferrer"&gt;RSS feed&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

</description>
      <category>cpp</category>
      <category>libclang</category>
      <category>ast</category>
      <category>flude</category>
    </item>
    <item>
      <title>System Header Hell: Teaching libclang to Understand GCC and Survive MSVC</title>
      <dc:creator>Flude team</dc:creator>
      <pubDate>Fri, 30 Oct 2026 03:48:01 +0000</pubDate>
      <link>https://dev.to/flude_team/system-header-hell-teaching-libclang-to-understand-gcc-and-survive-msvc-3d18</link>
      <guid>https://dev.to/flude_team/system-header-hell-teaching-libclang-to-understand-gcc-and-survive-msvc-3d18</guid>
      <description>&lt;p&gt;After migrating the C++ parser to &lt;code&gt;libclang&lt;/code&gt;, we expected to see a perfectly accurate Abstract Syntax Tree (AST). But when we unleashed it on our first real project, instead of a beautiful hierarchy of classes, we got a tree consisting entirely of &lt;code&gt;CXCursor_UnexposedDecl&lt;/code&gt; and fatal syntax errors.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F06wd1esyr5jwr8r7q7c2.jpg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F06wd1esyr5jwr8r7q7c2.jpg" alt="Libclang System Headers Gcc Msvc" width="800" height="800"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;The parser stumbled on the very first line: &lt;code&gt;#include &amp;lt;vector&amp;gt;&lt;/code&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  A Deaf Compiler
&lt;/h2&gt;

&lt;p&gt;It turned out that &lt;code&gt;libclang&lt;/code&gt; (being merely a linkable library, not a full CLI compiler) by default has no idea where standard header files are located in the operating system.&lt;/p&gt;

&lt;p&gt;If the parser doesn't see system headers, it doesn't understand what &lt;code&gt;std::string&lt;/code&gt; or &lt;code&gt;std::vector&lt;/code&gt; is. And since everything in modern C++ relies on standard library templates, parsing fails in a cascade.&lt;/p&gt;

&lt;p&gt;In the Enterprise world, developers usually pass giant strings of &lt;code&gt;-I/usr/include/...&lt;/code&gt; flags to the parsers themselves. But we were building a SaaS and a user-friendly CLI utility. We couldn't force users to manually search for compiler paths on their machines. The parser had to become smart.&lt;/p&gt;

&lt;h2&gt;
  
  
  The GCC Discovery Quest
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fve6fke6nvfwykah29hc5.jpg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fve6fke6nvfwykah29hc5.jpg" alt="Libclang System Headers Gcc Msvc Part 2" width="800" height="800"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;On Linux systems, we had to write our own Auto-Discovery mechanism.&lt;/p&gt;

&lt;p&gt;We implemented a heuristic that ran the system compiler in the background with clever flags: &lt;code&gt;gcc -print-file-name=include&lt;/code&gt; (falling back to &lt;code&gt;cc&lt;/code&gt;). This trick forces GCC (or the system Clang) to spit out the path to the internal directory it uses to search for system headers by default into the console.&lt;/p&gt;

&lt;p&gt;Our Python code intercepted this output, parsed it, filtered out non-existent directories, and dynamically converted it into an array of &lt;code&gt;-I&lt;/code&gt; flags, which were then fed into &lt;code&gt;libclang&lt;/code&gt;. The parser gained its "sight"—it began to perfectly understand Linux projects.&lt;/p&gt;

&lt;h2&gt;
  
  
  The MSVC-STL Nightmare on Windows
&lt;/h2&gt;

&lt;p&gt;But if Linux was solved with an elegant hack, a real hell awaited us on Windows.&lt;/p&gt;

&lt;p&gt;Windows developers use the Microsoft Visual C++ (MSVC) compiler and its proprietary standard library implementation—MSVC-STL. Integrating Clang with the intricacies of Windows code (including the monstrous &lt;code&gt;windows.h&lt;/code&gt;) is pure pain.&lt;/p&gt;

&lt;p&gt;MSVC historically forgives many syntax liberties and uses specific macros, pragmas, and extensions. Strict &lt;code&gt;libclang&lt;/code&gt; looked at MSVC-STL code and simply refused to parse it, generating hundreds of errors.&lt;/p&gt;

&lt;p&gt;To reconcile them, we had to dig deep into the LLVM documentation. We selected a specific set of compatibility flags (&lt;code&gt;-fms-compatibility&lt;/code&gt;, &lt;code&gt;-fms-extensions&lt;/code&gt;, and also spoofing macros like &lt;code&gt;-U__clang_major__ -D__clang_major__=19&lt;/code&gt; to bypass version checks in the MSVC STL) that forced &lt;code&gt;libclang&lt;/code&gt; to pretend to be a Microsoft compiler. Only after fine-tuning this virtual environment did the parser stop panicking at the sight of Windows source code.&lt;/p&gt;

&lt;h2&gt;
  
  
  Conclusion
&lt;/h2&gt;

&lt;p&gt;We spent a ton of time not on parsing the client code itself, but on configuring the environment in which that code lives. But the result was worth it: our parser learned to read developers' real code "out of the box" on any operating system, without requiring complex configurations from them.&lt;/p&gt;

&lt;p&gt;But "seeing" the code doesn't mean understanding its structure. When the parser finally read all the headers, we discovered that it loses half the methods if a developer dared to define them outside the class (Out-Of-Line). How we manually stitched torn methods back to templates—read about it in the next episode.&lt;/p&gt;




&lt;p&gt;&lt;em&gt;Originally published on our blog: &lt;a href="https://blog.flude.guide/blog/libclang-system-headers-gcc-msvc" rel="noopener noreferrer"&gt;https://blog.flude.guide/blog/libclang-system-headers-gcc-msvc&lt;/a&gt;&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Also read us:&lt;/strong&gt;&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href="https://t.me/ude_blog_en" rel="noopener noreferrer"&gt;Telegram channel&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://blog.flude.guide/rss-en.xml" rel="noopener noreferrer"&gt;RSS feed&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

</description>
      <category>cpp</category>
      <category>libclang</category>
      <category>ast</category>
      <category>flude</category>
    </item>
    <item>
      <title>Firing Doxygen: Native Parser Architecture and Adopting libclang</title>
      <dc:creator>Flude team</dc:creator>
      <pubDate>Tue, 27 Oct 2026 04:10:13 +0000</pubDate>
      <link>https://dev.to/flude_team/firing-doxygen-native-parser-architecture-and-adopting-libclang-11i3</link>
      <guid>https://dev.to/flude_team/firing-doxygen-native-parser-architecture-and-adopting-libclang-11i3</guid>
      <description>&lt;p&gt;Doxygen had been with us since day one. At the MVP stage, it was a conscious and absolutely correct choice: it allowed us not to write a C++ parser from scratch, but to immediately focus on business logic and documentation rendering.&lt;/p&gt;

&lt;p&gt;But as we transitioned from local scripts to a cloud SaaS, Doxygen turned into a burden. It couldn't cache the AST, its binary was too bulky, and its internal parser broke from C++ templates (remember the SFINAE incident from the &lt;a href="https://dev.to/en/blog/crash-test-sfinae-doxygen"&gt;previous episode&lt;/a&gt;, which forced us to write crutches via &lt;code&gt;INPUT_FILTER&lt;/code&gt;).&lt;/p&gt;

&lt;p&gt;It was time to do what we planned from the very beginning: fire Doxygen and migrate the system to native parsers.&lt;/p&gt;

&lt;h2&gt;
  
  
  Divide and Conquer
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F6f0oj5q33sjzk5l34s6s.jpg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F6f0oj5q33sjzk5l34s6s.jpg" alt="Firing Doxygen Native Cpp Parser Part 2" width="800" height="800"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;We never harbored illusions about creating a "universal parser". Just like with Doxygen dialects, we initially designed the system for separate parsers for each language. A tool that equally well understands hellish C++ templates with SFINAE and dynamic Python decorators simply doesn't exist.&lt;/p&gt;

&lt;p&gt;Therefore, we conducted research and selected the perfect, native tool for each language:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;&lt;p&gt;&lt;strong&gt;Python:&lt;/strong&gt; The built-in &lt;code&gt;ast&lt;/code&gt; module. No one will parse Python better than the interpreter itself (planned).&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;&lt;strong&gt;C# and Java:&lt;/strong&gt; &lt;code&gt;tree-sitter&lt;/code&gt;—an incredibly fast and modern incremental parser that has become an industry standard (planned).&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;&lt;strong&gt;C++:&lt;/strong&gt; Our most complex language and the first candidate for implementation.&lt;/p&gt;&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Boss Fight: C++ and libclang
&lt;/h2&gt;

&lt;p&gt;We started the implementation of native parsers specifically with C++, as it was the most critical vector. Trying to parse modern C++ with regexes or lightweight parsers is pure suicide. Preprocessors, macros, templates, and operator overloading will break any homegrown tool.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F3exaeqql79z5c1btr8u4.jpg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F3exaeqql79z5c1btr8u4.jpg" alt="Libclang Native Parser Architecture" width="800" height="800"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;That's why we took &lt;code&gt;libclang&lt;/code&gt;. Only a true compiler frontend can output a 100% accurate AST for C++. Yes, integrating with a C++ API from Python is not an easy task, but it's the only guarantee that we will correctly understand all the client's code.&lt;/p&gt;

&lt;h2&gt;
  
  
  The Triumph of Planned Architecture (Intermediate Representation)
&lt;/h2&gt;

&lt;p&gt;The most beautiful part about moving to &lt;code&gt;libclang&lt;/code&gt; was that we didn't have to rewrite the renderers (that same &lt;code&gt;hugo_markdown&lt;/code&gt; we talked about in the &lt;a href="https://dev.to/en/blog/crash-test-sfinae-doxygen"&gt;previous article&lt;/a&gt;).&lt;/p&gt;

&lt;p&gt;This became possible because our architecture, from day one, was based on an Intermediate Representation (IR). All parsers are required to convert the result of their work into a unified &lt;code&gt;ProjectCatalog&lt;/code&gt; structure.&lt;/p&gt;

&lt;p&gt;The new parser based on &lt;code&gt;libclang&lt;/code&gt; simply started assembling the exact same &lt;code&gt;ProjectCatalog&lt;/code&gt; that Doxygen used to output. The rendering layer didn't even know that the engine under the hood had changed. The architecture laid down at the start of the project worked exactly as intended.&lt;/p&gt;

&lt;h2&gt;
  
  
  Conclusion
&lt;/h2&gt;

&lt;p&gt;The core was freed from a heavy third-party dependency that prevented caching implementation. We closed a huge security hole (by removing &lt;code&gt;INPUT_FILTER&lt;/code&gt;) and significantly lightened our cloud workers.&lt;/p&gt;

&lt;p&gt;Transitioning to a native parser is the technical step that finally turned an MVP utility into a serious product.&lt;/p&gt;

&lt;p&gt;But as soon as we connected &lt;code&gt;libclang&lt;/code&gt; to real projects, a surprise awaited us. The native parser turned out to be blind: it flat-out refused to see the C++ standard libraries. How we searched for paths to GCC system headers on Linux and survived with MSVC-STL on Windows—read about it in the next episode.&lt;/p&gt;




&lt;p&gt;&lt;em&gt;Originally published on our blog: &lt;a href="https://blog.flude.guide/blog/firing-doxygen-native-cpp-parser" rel="noopener noreferrer"&gt;https://blog.flude.guide/blog/firing-doxygen-native-cpp-parser&lt;/a&gt;&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Also read us:&lt;/strong&gt;&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href="https://t.me/ude_blog_en" rel="noopener noreferrer"&gt;Telegram channel&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://blog.flude.guide/rss-en.xml" rel="noopener noreferrer"&gt;RSS feed&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

</description>
      <category>cpp</category>
      <category>python</category>
      <category>parsing</category>
      <category>architecture</category>
    </item>
    <item>
      <title>C++ Crash Test: Hidden SFINAE Traps and Parser Silence</title>
      <dc:creator>Flude team</dc:creator>
      <pubDate>Fri, 23 Oct 2026 03:07:26 +0000</pubDate>
      <link>https://dev.to/flude_team/c-crash-test-hidden-sfinae-traps-and-parser-silence-29b8</link>
      <guid>https://dev.to/flude_team/c-crash-test-hidden-sfinae-traps-and-parser-silence-29b8</guid>
      <description>&lt;p&gt;We were still trying to squeeze the maximum out of good old Doxygen in our cloud pipeline when we suddenly encountered a classic problem of harsh enterprise C++: the parser started silently "eating" entire chunks of the codebase.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fm8na63naup8ps7r7awoc.jpg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fm8na63naup8ps7r7awoc.jpg" alt="Crash Test Sfinae Doxygen" width="800" height="800"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;It all began when we noticed an anomaly: important structures (like &lt;code&gt;BITMAPINFO&lt;/code&gt; and &lt;code&gt;RGBQUAD&lt;/code&gt;) had vanished without a trace in the generated documentation.&lt;/p&gt;

&lt;p&gt;The scariest part was that the pipeline passed successfully. Doxygen returned &lt;code&gt;exit code 0&lt;/code&gt;, didn't issue a single warning, but the XML output for these files was practically empty. It simply swallowed the code and stayed silent.&lt;/p&gt;

&lt;h2&gt;
  
  
  Investigation by Binary Search
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fukc9aohb62qmcecs1j51.jpg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fukc9aohb62qmcecs1j51.jpg" alt="Crash Test Sfinae Doxygen Part 2" width="800" height="800"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;When a parser is silent, the only way to find the cause is the bisection method. We would take a problematic header file of several thousand lines, delete half of it, run the parser, and see if the necessary structures appeared.&lt;/p&gt;

&lt;p&gt;Narrowing the search down to 50 lines, we found the culprit. It turned out to be a classic C++ trick—SFINAE (Substitution Failure Is Not An Error). The codebase extensively used the construct:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight cpp"&gt;&lt;code&gt;&lt;span class="k"&gt;typename&lt;/span&gt; &lt;span class="n"&gt;std&lt;/span&gt;&lt;span class="o"&gt;::&lt;/span&gt;&lt;span class="n"&gt;enable_if&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;CONDITION&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="kt"&gt;bool&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;::&lt;/span&gt;&lt;span class="n"&gt;type&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;VALUE&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;To a C++ compiler, this is absolutely valid code. But the legacy Doxygen parser went crazy at the sight of such a pile of angle brackets (&lt;code&gt;&amp;lt; &amp;gt;&lt;/code&gt;). Its internal state machine broke, and it stopped understanding C++ syntax &lt;em&gt;until the very end of the file&lt;/em&gt;. This is exactly why structures declared below the ill-fated SFINAE template simply fell out of reality.&lt;/p&gt;

&lt;h2&gt;
  
  
  A UNIX-style Solution
&lt;/h2&gt;

&lt;p&gt;We couldn't go to the product developers and say: "Rewrite all your C++ code because our parser doesn't understand it." We needed a systemic solution that didn't touch the source files.&lt;/p&gt;

&lt;p&gt;Fortunately, Doxygen has the &lt;code&gt;INPUT_FILTER&lt;/code&gt; mechanism. This is a script through which every file is run before the parser sees it.&lt;/p&gt;

&lt;p&gt;We wrote a small Python script (&lt;code&gt;sfinae_filter.py&lt;/code&gt;) with a clever regular expression. The script caught all &lt;code&gt;std::enable_if&lt;/code&gt; constructs on the fly and replaced them with a syntax equivalent in the number of arguments: &lt;code&gt;bool = VALUE&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;At the same time, we strictly observed an important rule: the script calculated the number of line breaks in the removed block and added exactly the same number of blank lines to the replacement. Thanks to this, the line numbers in the source code did not shift, and all parser warnings continued to point to the correct lines in the developers' IDEs.&lt;/p&gt;

&lt;h2&gt;
  
  
  Conclusion
&lt;/h2&gt;

&lt;p&gt;A small Python filter solved the problem in dozens of files, returning the lost classes to the documentation. We won again.&lt;/p&gt;

&lt;p&gt;But this incident became the "last straw." Crutches with regular expressions on top of C++ code is a road to nowhere. The language is too complex to parse as text, and the unsafe &lt;code&gt;INPUT_FILTER&lt;/code&gt; opened holes in cloud security.&lt;/p&gt;

&lt;p&gt;It was time to do what we had avoided for so long: fire Doxygen for good. How we migrated to the native &lt;code&gt;libclang&lt;/code&gt; compiler frontend and why we didn't have to rewrite half the project—read about it in the next episode.&lt;/p&gt;




&lt;p&gt;&lt;em&gt;Originally published on our blog: &lt;a href="https://blog.flude.guide/blog/crash-test-sfinae-doxygen" rel="noopener noreferrer"&gt;https://blog.flude.guide/blog/crash-test-sfinae-doxygen&lt;/a&gt;&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Also read us:&lt;/strong&gt;&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href="https://t.me/ude_blog_en" rel="noopener noreferrer"&gt;Telegram channel&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://blog.flude.guide/rss-en.xml" rel="noopener noreferrer"&gt;RSS feed&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

</description>
      <category>cpp</category>
      <category>doxygen</category>
      <category>parsing</category>
      <category>sfinae</category>
    </item>
    <item>
      <title>The Butterfly Effect: How Renaming One String Broke Our Distributed System</title>
      <dc:creator>Flude team</dc:creator>
      <pubDate>Tue, 20 Oct 2026 04:49:01 +0000</pubDate>
      <link>https://dev.to/flude_team/the-butterfly-effect-how-renaming-one-string-broke-our-distributed-system-3pcc</link>
      <guid>https://dev.to/flude_team/the-butterfly-effect-how-renaming-one-string-broke-our-distributed-system-3pcc</guid>
      <description>&lt;p&gt;When we designed the SaaS version of Flude, we were very proud of our architecture. We split the logic into independent components: the parser core (&lt;code&gt;engine&lt;/code&gt;), the API gateway (&lt;code&gt;control-plane&lt;/code&gt;), the cloud workers (&lt;code&gt;job-runner&lt;/code&gt;), and the thin clients for CI integration (&lt;code&gt;flude-action&lt;/code&gt; and similar).&lt;/p&gt;

&lt;p&gt;All of this lived in different repositories and was deployed independently. We thought we had achieved perfect "loose coupling". We were certain that changes in one module would never bring down the entire system.&lt;/p&gt;

&lt;p&gt;Until one harmless refactoring proved us wrong.&lt;/p&gt;

&lt;h2&gt;
  
  
  A Harmless Refactoring (The First Flap of a Wing)
&lt;/h2&gt;

&lt;p&gt;It all started with perfectionism in the core repository. I noticed a technical inaccuracy: our parser generated not just classic Markdown, but a highly specific dialect with metadata (frontmatter) and shortcodes, tailored strictly for the Hugo static site generator.&lt;/p&gt;

&lt;p&gt;Leaving the output format under the generic name &lt;code&gt;markdown&lt;/code&gt; was incorrect—it would mislead future users if they tried to feed this code into a different generator (like Docusaurus).&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fvwpqvmwnfbuvivqi5021.jpg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fvwpqvmwnfbuvivqi5021.jpg" alt="Microservices Butterfly Effect" width="800" height="800"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;I did the most logical thing in the world: I renamed the CLI argument and the internal format identifier from &lt;code&gt;markdown&lt;/code&gt; to &lt;code&gt;hugo_markdown&lt;/code&gt;. The core tests predictably turned green, and the commit flew into &lt;code&gt;main&lt;/code&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  Chain Reaction
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fbmrkcnve8f2c35ln1whn.jpg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fbmrkcnve8f2c35ln1whn.jpg" alt="Butterfly Effect Microservices Rename Part 2" width="800" height="800"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;In that very minute, our "loosely coupled" microservice architecture began to fold like a house of cards. It turned out that the word &lt;code&gt;"markdown"&lt;/code&gt; was not just a local variable, but an implicit hard contract wired into all layers of the system.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Strike #1: Control Plane&lt;/strong&gt;&lt;br&gt;
The API gateway, which receives jobs from users, fell first. It suddenly started throwing &lt;code&gt;HTTP 422 Unprocessable Entity&lt;/code&gt; errors. Why? Because at the entrance stood a strict OpenAPI schema that validated the &lt;code&gt;format&lt;/code&gt; field. The schema allowed only two values: &lt;code&gt;["markdown", "html"]&lt;/code&gt;. Receiving the new parameter &lt;code&gt;hugo_markdown&lt;/code&gt; from the client, the API simply rejected the request as invalid. We had to urgently patch the validation schemas.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Strike #2: Cloud Workers&lt;/strong&gt;&lt;br&gt;
As soon as the API was fixed and requests passed through, the workers themselves (Data Plane) crashed. A worker would successfully run the updated parser core, but upon completion, it tried to find the &lt;code&gt;out/markdown&lt;/code&gt; directory on the disk to pack it into a ZIP archive. Naturally, the folder wasn't there—the updated engine was now carefully putting the result in &lt;code&gt;out/hugo_markdown&lt;/code&gt;. The workers crashed with a &lt;code&gt;FileNotFoundError&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Strike #3: Thin Clients (CI Scripts)&lt;/strong&gt;&lt;br&gt;
The workers were updated. Archives started forming. But the pipelines on the users' side continued to burn red. Our thin clients (running in GitHub, GitLab, etc.) sent a request to download the artifact, expecting to receive the &lt;code&gt;markdown.zip&lt;/code&gt; file. The server, however, was now returning &lt;code&gt;hugo_markdown.zip&lt;/code&gt;. The scripts simply couldn't find the needed file and failed the build.&lt;/p&gt;

&lt;h2&gt;
  
  
  An Expensive Lesson
&lt;/h2&gt;

&lt;p&gt;To roll out the renaming of &lt;em&gt;just one variable&lt;/em&gt;, we had to coordinate a synchronous release across four independent repositories.&lt;/p&gt;

&lt;p&gt;That day, we learned an important lesson. Microservices do not save you from tight coupling if your contracts are based on implicit Magic Strings smeared across the code. If one service changes a data format and another hardcodes paths to files—that's not a distributed system. It's a distributed monolith, which is much more painful to break than a regular one.&lt;/p&gt;

&lt;h2&gt;
  
  
  What's Next?
&lt;/h2&gt;

&lt;p&gt;We stabilized the contracts, covered them with end-to-end tests, and finally brought the SaaS infrastructure to a working state. The system was ready for real loads.&lt;/p&gt;

&lt;p&gt;But one fundamental architectural problem of the core, which started it all, wouldn't let us go—Doxygen. We tolerated its flaws: the impossibility of proper AST caching, its slowness, and the huge size of its binary in containers. But one fine day, it simply capitulated to complex C++ code, and this became the beginning of the end.&lt;/p&gt;

&lt;p&gt;How a harmless SFINAE template trick forced Doxygen to silently delete classes from the project, and why we had to save ourselves with unsafe &lt;code&gt;INPUT_FILTER&lt;/code&gt; scripts—read about it in the next episode.&lt;/p&gt;




&lt;p&gt;&lt;em&gt;Originally published on our blog: &lt;a href="https://blog.flude.guide/blog/butterfly-effect-microservices-rename" rel="noopener noreferrer"&gt;https://blog.flude.guide/blog/butterfly-effect-microservices-rename&lt;/a&gt;&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Also read us:&lt;/strong&gt;&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href="https://t.me/ude_blog_en" rel="noopener noreferrer"&gt;Telegram channel&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://blog.flude.guide/rss-en.xml" rel="noopener noreferrer"&gt;RSS feed&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

</description>
      <category>backend</category>
      <category>architecture</category>
      <category>microservices</category>
      <category>flude</category>
    </item>
    <item>
      <title>Surviving the JS Ecosystem: Auth, Netlify, and the New Rules of Next.js 16</title>
      <dc:creator>Flude team</dc:creator>
      <pubDate>Fri, 16 Oct 2026 05:56:32 +0000</pubDate>
      <link>https://dev.to/flude_team/surviving-the-js-ecosystem-auth-netlify-and-the-new-rules-of-nextjs-16-2poi</link>
      <guid>https://dev.to/flude_team/surviving-the-js-ecosystem-auth-netlify-and-the-new-rules-of-nextjs-16-2poi</guid>
      <description>&lt;p&gt;A Python backend is predictable and stable. Infrastructure on Google Cloud means strict rules and transparent logs. But as soon as we stepped into the territory of modern frontend to build an API key issuance portal for our SaaS, we found ourselves on the rollercoaster of the JavaScript ecosystem.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fxhm7uzd494zzha799czk.jpg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fxhm7uzd494zzha799czk.jpg" alt="Surviving Js Ecosystem Clerk Nextjs" width="800" height="800"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;We just needed a single Next.js page where we could embed the &lt;code&gt;&amp;lt;UserProfile /&amp;gt;&lt;/code&gt; component from Clerk. On paper, it looked like a two-hour task. In reality, we spent a day fighting hosting providers, outdated documentation, and implicit conventions.&lt;/p&gt;

&lt;h2&gt;
  
  
  Choosing a Host: Cloudflare, Vercel, or Netlify?
&lt;/h2&gt;

&lt;p&gt;The first task was to find a home for our frontend (&lt;code&gt;app.flude.guide&lt;/code&gt;). We were choosing between three options:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Cloudflare Pages:&lt;/strong&gt; This was our first candidate, as all our static sites (including the blog) were already running there successfully. But a SaaS app requires Server-Side Rendering (SSR). To run Next.js on Cloudflare, you need Workers and adapters like OpenNext. It turned out that the fresh Next.js 16 and the &lt;code&gt;@clerk/nextjs&lt;/code&gt; library are strictly tied to the Node-specific &lt;code&gt;async_hooks&lt;/code&gt; module, which simply doesn't exist in the Cloudflare Workers runtime. We couldn't do a static export (&lt;code&gt;output: 'export'&lt;/code&gt;) because Clerk requires a live server. This option was out.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Vercel:&lt;/strong&gt; The native harbor of Next.js. We could have launched on the free Hobby tier, but their Fair Use Guidelines are categorical: commercial use is prohibited. Even if the project isn't making money yet, having paid developers on staff already violates the rules. The paid Pro tier for $20/month would be safe, but why pay for infrastructure for a page with near-zero traffic at launch?&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Netlify:&lt;/strong&gt; Unlike Vercel, their free tier officially allows commercial use (confirmed on support forums). Next.js SSR is natively supported, and the Clerk + Netlify combo is battle-tested. We chose them.&lt;/li&gt;
&lt;/ol&gt;

&lt;h2&gt;
  
  
  The War with Netlify Scanners
&lt;/h2&gt;

&lt;p&gt;Having chosen Netlify, we configured the pipeline and pushed the code to release. The build immediately crashed with a security error.&lt;/p&gt;

&lt;p&gt;It turned out that Netlify's built-in secrets scanner saw the string &lt;code&gt;NEXT_PUBLIC_CLERK_PUBLISHABLE_KEY&lt;/code&gt; in the configuration and blocked the deploy, deciding that we had committed a private token. We had to spend time digging through the documentation to manually add the &lt;code&gt;SECRETS_SCAN_OMIT_KEYS&lt;/code&gt; exception to &lt;code&gt;netlify.toml&lt;/code&gt;. We were literally arguing with the host that a public key is, in fact, public.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fsyehw6u04uh9nsp7zibh.jpg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fsyehw6u04uh9nsp7zibh.jpg" alt="Surviving Js Ecosystem Clerk Nextjs Part 2" width="800" height="800"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  The Silent Break: Next.js 16 and File Renaming
&lt;/h2&gt;

&lt;p&gt;Having solved the deployment issue, we moved on to authorization. According to the official Clerk documentation, route protection is configured in the &lt;code&gt;middleware.ts&lt;/code&gt; file. We set everything up, pushed the code, but authorization simply didn't work—the page let everyone in. No errors in the logs, just silence.&lt;/p&gt;

&lt;p&gt;We killed several hours before we realized what was wrong. In Next.js 16, internal conventions had changed: the middleware file is now required to be named &lt;code&gt;proxy.ts&lt;/code&gt;. As soon as we renamed the file, authorization worked. Because of one changed word in the framework's convention, the security of the entire application silently disabled itself.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fby8dmgugae8jxw8l2wgk.jpg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fby8dmgugae8jxw8l2wgk.jpg" alt="Surviving Js Ecosystem Clerk Nextjs Part 3" width="800" height="800"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  Sudden Deprecation: Chasing Standards
&lt;/h2&gt;

&lt;p&gt;In that very &lt;code&gt;proxy.ts&lt;/code&gt; file, we had configured protection for our &lt;code&gt;/account&lt;/code&gt; page using a special Clerk function—&lt;code&gt;createRouteMatcher&lt;/code&gt;. This was the recommended approach.&lt;/p&gt;

&lt;p&gt;But the joy was short-lived. We accidentally discovered that this pattern of route protection at the middleware level was already being marked as deprecated. Clerk was shifting its philosophy towards "Resource-based auth".&lt;/p&gt;

&lt;p&gt;We had to urgently rip out all routing logic from &lt;code&gt;proxy.ts&lt;/code&gt;, leaving only a "bare" context passthrough (&lt;code&gt;export default clerkMiddleware();&lt;/code&gt;), and move the protection inside the server components. Now the &lt;code&gt;/account/[[...rest]]/page.tsx&lt;/code&gt; page itself calls &lt;code&gt;await auth.protect()&lt;/code&gt; before rendering. Yesterday's "Best Practices" standard turned out to be legacy even before we could release the project.&lt;/p&gt;

&lt;h2&gt;
  
  
  What's Next?
&lt;/h2&gt;

&lt;p&gt;With much grief, we pushed the frontend through. The SaaS acquired working billing, secure cloud workers, and a portal for getting API keys. The architecture was ready.&lt;/p&gt;

&lt;p&gt;But just as we relaxed, we decided to rename the base export format of our core from &lt;code&gt;markdown&lt;/code&gt; to &lt;code&gt;hugo_markdown&lt;/code&gt;. This harmless decision sent ripples across the entire distributed system, breaking contracts between the engine, workers, and clients. How we eliminated this "butterfly effect"—read about it in the next episode.&lt;/p&gt;




&lt;p&gt;&lt;em&gt;Originally published on our blog: &lt;a href="https://blog.flude.guide/blog/surviving-js-ecosystem-clerk-nextjs" rel="noopener noreferrer"&gt;https://blog.flude.guide/blog/surviving-js-ecosystem-clerk-nextjs&lt;/a&gt;&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Also read us:&lt;/strong&gt;&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href="https://t.me/ude_blog_en" rel="noopener noreferrer"&gt;Telegram channel&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://blog.flude.guide/rss-en.xml" rel="noopener noreferrer"&gt;RSS feed&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

</description>
      <category>frontend</category>
      <category>saas</category>
      <category>architecture</category>
      <category>flude</category>
    </item>
    <item>
      <title>SaaS Economics: Why We Overpaid 10x for Auth and How We Protected the Cloud from Spam</title>
      <dc:creator>Flude team</dc:creator>
      <pubDate>Tue, 13 Oct 2026 05:14:37 +0000</pubDate>
      <link>https://dev.to/flude_team/saas-economics-why-we-overpaid-10x-for-auth-and-how-we-protected-the-cloud-from-spam-599b</link>
      <guid>https://dev.to/flude_team/saas-economics-why-we-overpaid-10x-for-auth-and-how-we-protected-the-cloud-from-spam-599b</guid>
      <description>&lt;p&gt;Having developed the secure cloud worker architecture described in the &lt;a href="https://dev.to/en/blog/zero-trust-cloud-config-trap"&gt;previous article&lt;/a&gt;, we solved the main engineering task—our parser's core was secure. But now we faced a product problem.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F4ugeg2avg602usu3tp96.jpg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F4ugeg2avg602usu3tp96.jpg" alt="Saas Economics Abuse Protection" width="800" height="800"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;How could we allow developers to test Flude for free without letting them bankrupt us on GCP Cloud Run bills? Every second of parsing costs real money. We needed a Free-Tier, but with ironclad protection against Abuse loads. And the foundation for this protection became the authentication system.&lt;/p&gt;

&lt;h2&gt;
  
  
  The Foundation: Choosing an Auth Provider
&lt;/h2&gt;

&lt;p&gt;We needed to manage users, quotas, and B2B organizations. We considered three options: Auth0, Supabase Auth, and Clerk.&lt;/p&gt;

&lt;p&gt;Auth0 dropped out first: it lacked a native integration with GitLab, and for our CI tool, GitHub, GitLab, and Bitbucket had to be absolutely equal platforms "out of the box."&lt;/p&gt;

&lt;p&gt;That left Supabase Auth and Clerk. According to preliminary calculations for a scale of 100,000 monthly active users (MAU), Supabase would have cost us pennies, while the bill from Clerk would be roughly ten times larger.&lt;/p&gt;

&lt;p&gt;And yet, we chose the more expensive Clerk. Why?&lt;/p&gt;

&lt;p&gt;First, development savings were the deciding factor. Our future Team pricing plan implied multi-tenancy: the entity of an organization, roles (admin and member), and shared billing. Clerk provided the Organizations feature and ready-made UI components "out of the box"—this fit our model perfectly. With Supabase, we would have had to build a B2B role model from scratch.&lt;/p&gt;

&lt;p&gt;Second—architectural purity. Supabase is a full-fledged BaaS with its own PostgreSQL database. Our project was already firmly tied to the Google Cloud stack (specifically, Firestore). Dragging a second DBMS into the project just for cheap authentication would have been a mistake.&lt;/p&gt;

&lt;p&gt;In the context of projected revenue, the overpayment for Clerk would amount to only a couple of percent. We consciously traded money for months of saved engineering time.&lt;/p&gt;

&lt;h2&gt;
  
  
  Defense in Depth (Free-Gate)
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fvtdhf1i4ef75sm6okz54.jpg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fvtdhf1i4ef75sm6okz54.jpg" alt="Saas Economics Abuse Protection Part 2" width="800" height="800"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Equipped with a powerful identification tool, we started setting limits. Our philosophy during the beta phase was simple: we want to support indie developers and their small Open Source projects, while cutting off giant enterprise mono-repos.&lt;/p&gt;

&lt;p&gt;To do this, we built a three-level "gate" that cuts off excess load even before the heavy parsing process starts in the cloud:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Entity Limit:&lt;/strong&gt; The API token is checked by the server. If a request comes from an account linked to an organization—it is rejected. Free access is open only for personal projects, and support for corporate teams is reserved for future paid plans.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Privacy Limit:&lt;/strong&gt; We make a cheap preliminary request to the public API (e.g., GitHub) before starting a heavy repository clone. If the code is private—rejection (&lt;code&gt;rejected_private&lt;/code&gt;).&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Greed Metric (5MB Limit):&lt;/strong&gt; The most important check happens inside the worker after a shallow clone (&lt;code&gt;git clone --depth 1&lt;/code&gt;). We don't trust the repository size from the API (it might contain gigabytes of garbage). We weigh only those files that actually match the &lt;code&gt;include_patterns&lt;/code&gt;. If the net volume of code exceeds 5 MB, the worker immediately aborts the job.&lt;/li&gt;
&lt;/ol&gt;

&lt;h2&gt;
  
  
  Dynamic Rate-Limit and the Window of Loyalty
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fmot237f3zytxjlejwd6f.jpg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fmot237f3zytxjlejwd6f.jpg" alt="Saas Economics Abuse Protection Part 3" width="800" height="800"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Even small Open Source projects can trigger CI on every tiny commit 100 times a day. To avoid parsing all of this at our expense, we implemented a dynamic rate-limit based on Firestore.&lt;/p&gt;

&lt;p&gt;For new accounts, we open a "window of loyalty": for the first 7 days, we allow up to 5 builds per day so the developer can calmly configure CI and play with the Flude configuration.&lt;br&gt;
But a week later, harsh reality sets in—the limit drops strictly to 1 free build per day. If you want to parse documentation on every PR, you'll have to wait for the launch of paid plans, which we are currently only designing.&lt;/p&gt;

&lt;p&gt;As a final chord, we embedded a global "kill switch" in the database, which allows us to disable all free builds with a single button in case of any infrastructure attack.&lt;/p&gt;

&lt;h2&gt;
  
  
  What's Next?
&lt;/h2&gt;

&lt;p&gt;We designed great business logic protecting our servers from spam and integrated a powerful authorization provider. But, as often happens in the JS ecosystem, third-party dependencies have a habit of suddenly breaking.&lt;/p&gt;

&lt;p&gt;The integration of Clerk and the transition to the new Next.js 16 standards turned our frontend development into a real quest with deprecated functions and broken routes. About this (and how a single renamed line broke contracts across the entire distributed system)—in the next episode.&lt;/p&gt;




&lt;p&gt;&lt;em&gt;Originally published on our blog: &lt;a href="https://blog.flude.guide/blog/saas-economics-abuse-protection" rel="noopener noreferrer"&gt;https://blog.flude.guide/blog/saas-economics-abuse-protection&lt;/a&gt;&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Also read us:&lt;/strong&gt;&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href="https://t.me/ude_blog_en" rel="noopener noreferrer"&gt;Telegram channel&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://blog.flude.guide/rss-en.xml" rel="noopener noreferrer"&gt;RSS feed&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

</description>
      <category>business</category>
      <category>architecture</category>
      <category>saas</category>
      <category>flude</category>
    </item>
  </channel>
</rss>
