<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Technology @ Funding Societies | Modalku - Medium]]></title>
        <description><![CDATA[Funding Societies | Modalku is the largest SME digital financing platform in Southeast Asia, operating in 5 countries. - Medium]]></description>
        <link>https://medium.com/fsmk-engineering?source=rss----95882711d047---4</link>
        <image>
            <url>https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png</url>
            <title>Technology @ Funding Societies | Modalku - Medium</title>
            <link>https://medium.com/fsmk-engineering?source=rss----95882711d047---4</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 17:22:34 GMT</lastBuildDate>
        <atom:link href="https://medium.com/feed/fsmk-engineering" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Human-Led, AI-Powered: Building a Digital Twin for Real-World Vulnerability Research]]></title>
            <link>https://medium.com/fsmk-engineering/human-led-ai-powered-building-a-digital-twin-for-real-world-vulnerability-research-045f77903bd7?source=rss----95882711d047---4</link>
            <guid isPermaLink="false">https://medium.com/p/045f77903bd7</guid>
            <category><![CDATA[funding-societies]]></category>
            <category><![CDATA[penetration-testing]]></category>
            <category><![CDATA[bug-bounty]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[claude-code]]></category>
            <dc:creator><![CDATA[Product Security, Funding Societies]]></dc:creator>
            <pubDate>Tue, 13 Oct 2026 05:54:57 GMT</pubDate>
            <atom:updated>2026-10-13T05:54:55.865Z</atom:updated>
            <content:encoded><![CDATA[<p><em>How we built an internal AI-powered vulnerability research workflow — and what we learned about making AI useful for real-world penetration testing.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*z3tANFAZVyGslDuK" /></figure><p>Application security testing has traditionally been a very human-driven process.</p><p>A security engineer learns the application, understands its workflows, maps the attack surface, forms hypotheses, perform penetration testing, validates vulnerabilities, collects evidence, and eventually turns everything into a report.</p><p>That process works, but it can also become repetitive.</p><p>Modern applications expose hundreds or thousands of endpoints, multiple user roles, complex APIs, asynchronous workflows, and business logic that is difficult to understand from an automated scanner alone.</p><p>This is where AI-assisted security testing becomes interesting.</p><p>Rather than asking an AI model to simply “scan this website for vulnerabilities,” we wanted to explore a different approach:</p><blockquote><strong><em>What if an AI model could act as an orchestrator for a structured penetration-testing methodology?</em></strong></blockquote><p>That question eventually led us to build <strong>Nova</strong>, an internal AI-powered vulnerability research workflow using Claude Code.</p><h3>Why AI-Assisted Pentesting?</h3><p>AI is becoming increasingly useful in security engineering, but its value in penetration testing is not simply about replacing traditional scanners with an “AI scanner.”</p><p>Traditional security scanners are highly effective when a vulnerability can be expressed as a repeatable check:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/480/1*Fbu61Fiy1l22Youyv8grRg.png" /></figure><p>Application security testing becomes more interesting when vulnerabilities depend on workflow, state, user roles, and relationships between multiple requests.</p><p>Consider a simplified payment workflow:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/560/1*djkGU5xMaz5cTL0-g9gf4w.png" /></figure><p>Testing this scenario requires more than sending an isolated request. The tester needs to understand the workflow, maintain separate user sessions, identify the objects created by one user, and then test how another user can interact with those objects.</p><p>This is an area where our AI-assisted workflow can provide practical value.</p><p>Nova can be provided with authorized test credentials and application context, including information about available roles and workflows. It can then use those sessions while testing a specific security hypothesis.</p><p>For example, an authorization test may involve:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/520/1*PfOkB2RelDZVJIDA3x5g2A.png" /></figure><p>The important point is that the AI is not simply looking for a known vulnerability pattern in an individual HTTP request. It can execute a <strong>sequence of related actions</strong> while maintaining the context required to test the hypothesis.</p><p>This makes AI particularly useful as an orchestration and reasoning layer around existing security tooling.</p><h3>The Idea Behind Nova</h3><p>Nova started from a relatively simple idea:</p><blockquote><strong><em>Give an AI coding agent the context, tools, and security methodologies required to perform structured vulnerability research.</em></strong></blockquote><p>The architecture can be thought of as:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/620/1*4DfIhPsEa27OASZ-PPd-vw.png" /></figure><h3>Claude Code as the Orchestrator</h3><p>One of the reasons this architecture worked well for us was that we didn’t want to create a massive monolithic security agent.</p><p>Instead, the project is organized around separate pieces of context and methodology.</p><p>At a high level, the project contains four important concepts:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/490/1*zymwuw4VI52lNqhVZquIOQ.png" /></figure><p>The actual internal implementation contains additional tooling and engagement-specific material, but those details aren’t necessary to understand the architecture.</p><h3>1. Instructions</h3><p>A central instruction file defines how the AI should behave during an assessment.</p><p>This includes things such as:</p><ul><li>Its role as a security researcher</li><li>Rules of engagement</li><li>Scope restrictions</li><li>Evidence requirements</li><li>Testing methodology</li><li>Validation expectations</li><li>Reporting requirements</li></ul><p>This is important because unrestricted AI exploration isn’t necessarily desirable during a penetration test.</p><p>The model needs boundaries.</p><p>A useful security agent should know not only <strong>what it can test</strong>, but also <strong>what it must not test</strong>.</p><h3>2. Context Is Critical</h3><p>One of the biggest lessons from building Nova was that <strong>security testing quality depends heavily on context</strong>.</p><p>Giving an AI a URL and saying:</p><blockquote><em>“Find vulnerabilities.”</em></blockquote><p>is not enough.</p><p>A modern application may contain:</p><ul><li>Multiple user roles</li><li>Administrative functions</li><li>Approval workflows</li><li>APIs</li><li>Object relationships</li><li>Background processing</li><li>Payment flows</li><li>Tenant boundaries</li><li>Different permission levels</li></ul><p>Without understanding those relationships, an AI can easily spend time testing the wrong things.</p><p>Nova therefore maintains an engagement-specific context layer.</p><p>Conceptually:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/560/1*-5rv3YCIcd_UinVG7ymV3w.png" /></figure><p>The context doesn’t need to expose every internal implementation detail.</p><p>Its purpose is to provide the AI with enough information to reason about the application like a security engineer would.</p><h3>3. Security Skills</h3><p>The next layer is the security methodology.</p><p>Instead of putting every vulnerability-testing technique into one enormous prompt, Nova uses modular security “skills.”</p><p>For example, the internal workflow contains methodologies covering areas such as:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/778/1*CXXOkETs4_wTq8WU24mukw.png" /></figure><p>Each methodology describes how to approach a vulnerability class rather than simply giving the AI a list of payloads.</p><p>That distinction matters.</p><p>For example, an IDOR methodology shouldn’t simply say:</p><p>Change ID=123 to ID=124</p><p>It should encourage the model to reason about:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/520/1*5K74G1y-7Sj3z6n1zQTh9Q.png" /></figure><p>That turns a payload-oriented approach into a hypothesis-driven one.</p><h3>Giving the AI Real Application Traffic</h3><p>Another challenge with AI-assisted pentesting is giving the model useful visibility into the application.</p><p>We experimented with multiple ways of doing this.</p><p>One particularly useful addition was <strong>HAR capture using Playwright</strong>.</p><p>Playwright supports recording browser network activity into HAR files, which can then be used as an artifact for understanding application traffic.</p><p>We built a small wrapper around Playwright to simplify the process.</p><p>The workflow is essentially:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/500/1*JSp5xVL5Q9nSFAVY7Hx1cA.png" /></figure><p>The script launches a visible Chromium session and starts HAR recording:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/536/1*e1X1C5fYuP_PRM3AvDMSsw.png" /></figure><p>The engineer can then interact with the application normally.</p><p>When the session is finished, the browser context is closed and the HAR is finalized.</p><p>One important detail here is that Playwright writes the HAR when the browser context is closed, which is why the workflow explicitly closes the context before considering the capture complete.</p><p>The resulting HAR provides the AI with a much richer representation of how the application behaves than simply giving it a URL.</p><p>It can reveal things such as:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/410/1*q-5s2r_w-7s2SDxp7g9kcw.png" /></figure><p>Adding Burp MCP</p><p>HAR capture gives us a useful starting point, but real pentesting also requires interactive testing.</p><p>This is where <strong>Burp Suite and MCP</strong> become useful.</p><p>Model Context Protocol allows compatible AI clients to interact with tools through a standardized interface.</p><p>Burp provides MCP capabilities that allow compatible AI clients such as Claude Code to interact with Burp functionality using the existing security context and permissions.</p><p>In our workflow, this creates another layer:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/560/1*_3ZCtdX9ChpBeYnHQLMtVw.png" /></figure><p>This is an important difference from simply giving an AI a collection of HTTP requests.</p><p>The model can reason about a request and then use an appropriate security tool to investigate the hypothesis.</p><p>For example:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/520/1*BCxJwlrKaTA_alH3p2aXsw.png" /></figure><p>That starts to look much closer to how a human security researcher works.</p><h3>The Human + AI Loop</h3><p>We found that the most useful architecture wasn’t:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/700/1*jlkWCn9Uy7pjrVxJL2ocpg.png" /></figure><p>It was closer to:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/440/1*noO7d9IwRkHt-U_hAB_Pmw.png" /></figure><p>The human remains involved throughout the process.</p><p>This is especially important for business-logic vulnerabilities, where understanding the intended behavior of an application is often more important than generating a clever payload.</p><h3>A Typical Nova Assessment</h3><p>A simplified assessment looks like this:</p><h3>Step 1 — Define Scope</h3><p>Start with explicit scope.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/420/1*WJXfa-x21g8TOIAA9fwfhg.png" /></figure><p>Anything outside the agreed scope should remain outside the workflow.</p><h3>Step 2 — Load Application Context</h3><p>Provide the AI with relevant information about:</p><ul><li>Application functionality</li><li>User roles</li><li>Workflows</li><li>Scope</li><li>Test accounts</li><li>API information</li></ul><p>Sensitive credentials should be handled securely rather than embedded directly into prompts or published artifacts.</p><h3>Step 3 — Capture Application Traffic</h3><p>Use Playwright to record normal application activity.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/420/1*OKH1hx_7Xx-ICGU7w9Ed1A.png" /></figure><h3>Step 4 — Understand the Functionality</h3><p>Before testing a specific vulnerability class, understand the functionality.</p><p>For example:</p><blockquote><em>“Understand how this object is created, updated, approved and viewed by each role.”</em></blockquote><p>The AI can then identify interesting authorization boundaries and state transitions.</p><h3>Step 5 — Select a Security Methodology</h3><p>Once a potential attack surface is identified, select the relevant methodology.</p><p>For example:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*Wl79bRiXGsq4lwKivcVueA.png" /></figure><h3>Step 6 — Test a Specific Hypothesis</h3><p>This is where the workflow becomes much more focused.</p><p>Instead of:</p><blockquote><em>“Find anything.”</em></blockquote><p>we provide a concrete objective:</p><blockquote><em>“Investigate whether one user’s object can be modified by another user.”</em></blockquote><p>or:</p><blockquote><em>“Investigate whether the approval workflow can be completed without the required authorization.”</em></blockquote><p>The AI can then use the available tooling to investigate that specific hypothesis.</p><h3>Step 7 — Validate</h3><p>An observation is not automatically a vulnerability.</p><p>Nova is designed around the principle:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/380/1*jO7Jp_ZwTuJtSrH6qzquDg.png" /></figure><p>This reduces the risk of turning interesting behavior into false-positive findings.</p><h3>Findings and Reporting</h3><p>Another part of the workflow is separating <strong>research</strong> from <strong>report generation</strong>.</p><p>During an assessment, individual findings can be documented as they are validated.</p><p>Conceptually:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/640/1*NIKf7N6mChi2VntHPuehaQ.png" /></figure><p>Instead, it can first create a structured finding containing information such as:</p><ul><li>Vulnerability type</li><li>Affected functionality</li><li>Preconditions</li><li>Steps to reproduce</li><li>Evidence</li><li>Impact</li><li>Recommendation</li></ul><p>Once testing is complete, those findings can be consolidated into a final report.</p><h3>Slack Notifications</h3><p>We also added notification capabilities around the workflow.</p><p>The idea is simple:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/420/1*edSy4ycgqgb8bptvnvhf_Q.png" /></figure><p>This provides visibility without requiring the security engineer to continuously monitor the project directory.</p><h3>What the Architecture Looks Like</h3><p>Putting everything together:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/780/1*moW8QQ80fUOtj7nnnlTi1w.png" /></figure><p>The key idea is that the AI sits in the middle as an <strong>orchestrator</strong>, rather than being treated as a magic vulnerability scanner.</p><h3>The Most Important Lesson: Understand the Business Logic First</h3><p>If there is one thing I would emphasize from this project, it is this:</p><blockquote><strong><em>Don’t start by asking the AI to find vulnerabilities. Start by asking it to understand the application.</em></strong></blockquote><p>This made a significant difference in our workflow.</p><p>A security engineer rarely starts a pentest by blindly throwing payloads at every endpoint.</p><p>They first learn:</p><ul><li>What does the application do?</li><li>Who are the users?</li><li>What roles exist?</li><li>What objects exist?</li><li>Who owns those objects?</li><li>What actions can each role perform?</li><li>Which actions require approval?</li><li>Which workflows change state?</li><li>Which APIs implement those workflows?</li></ul><p>Only after that does vulnerability testing become much more meaningful.</p><p>For example, instead of:</p><blockquote><em>“Test this API for IDOR.”</em></blockquote><p>we can approach the problem as:</p><blockquote><em>“Understand how payment requests are created, viewed, modified and approved. Identify the authorization boundaries between the different user roles. Then investigate whether those boundaries can be bypassed.”</em></blockquote><p>The second instruction provides significantly more useful direction.</p><p>The AI now has a <strong>security hypothesis</strong>.</p><h3>Conclusion</h3><p>AI-assisted penetration testing is still an evolving space.</p><p>The most interesting opportunity, in our opinion, isn’t simply using an LLM to generate payloads.</p><p>It is using AI to connect the different pieces of a real security assessment:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/460/1*aUP2dzx9egC-ifCOqrAKRQ.png" /></figure><p>Our internal project, Nova, started as an experiment around this idea.</p><p>What began as a collection of instructions and vulnerability-testing methodologies evolved into a workflow that combines <strong>Claude Code, Playwright-based traffic capture, HAR artifacts, Burp MCP, modular security skills, structured findings, reporting, and notifications</strong>.</p><p>The biggest lesson has been surprisingly simple:</p><blockquote><strong><em>Give the AI context before giving it a vulnerability to find.</em></strong></blockquote><p>And that’s probably where we’ll see the most useful evolution of AI in application security: not replacing security engineers, but giving them a much more capable research assistant.</p><p><strong>Proudly brought to you by the FSMKCU Product Security Team</strong> 🛡️</p><p><strong>Author: Yash Kulkarni</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=045f77903bd7" width="1" height="1" alt=""><hr><p><a href="https://medium.com/fsmk-engineering/human-led-ai-powered-building-a-digital-twin-for-real-world-vulnerability-research-045f77903bd7">Human-Led, AI-Powered: Building a Digital Twin for Real-World Vulnerability Research</a> was originally published in <a href="https://medium.com/fsmk-engineering">Technology @ Funding Societies | Modalku</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[High Signal, High Impact: Scaling Dependency Security Efficiently]]></title>
            <link>https://medium.com/fsmk-engineering/high-signal-high-impact-scaling-dependency-security-efficiently-5f0f6c05c5ac?source=rss----95882711d047---4</link>
            <guid isPermaLink="false">https://medium.com/p/5f0f6c05c5ac</guid>
            <dc:creator><![CDATA[Product Security, Funding Societies]]></dc:creator>
            <pubDate>Mon, 28 Sep 2026 04:32:11 GMT</pubDate>
            <atom:updated>2026-09-28T04:32:09.761Z</atom:updated>
            <content:encoded><![CDATA[<p>Turning Alert Volume Into Engineering Focus</p><p>Most of what runs in your production services is code your team never wrote.</p><p>During a test period against a set of repositories in a test environment, spanning Node, Go, Java, and Python services, that inherited surface produced several hundred Dependabot alerts from roughly eighty distinct packages over one month, the pilot window for the triage pipeline this piece describes. One vulnerable package can raise dozens of these: nanoid, a popular ID-generation library, alone accounted for approximately two dozen alerts in code paths nobody on the team remembered writing.</p><p>A typical service names maybe ten packages by hand. Resolving those ten pulls in hundreds more, several levels deep, none of which passed a code review on your side. That’s just what a modern dependency tree looks like.</p><p>The alerts weren’t the problem. What to do with them was.</p><p>What follows is that pipeline: built to answer this, and run as a deliberate test before being trusted with the full backlog, not treated as a slice of its steady-state operation.</p><h3>The vocabulary that makes the rest of this make sense</h3><p>Your manifest (package.json, requirements.txt, go.mod) is what you asked for by name: reviewed, deliberate, usually short. Your lockfile is what you actually got: hundreds of entries, pinned to exact versions, that nobody reviewed line by line. It’s what ships.</p><p>Two independent axes matter. <strong>Direct versus transitive</strong> is about who asked for it: express is direct, in your manifest; qs, pulled in by express via body-parser, is transitive, often five levels down. <strong>Runtime versus dev</strong> is about whether it ships: a runtime dependency is loadable while your service serves traffic, a dev dependency is build/test tooling that never reaches the production image. Every ecosystem the detector handles (Python, JavaScript, Go) reduces to the same lockfile logic underneath, and Dependabot reads exactly that lockfile, not your manifest.</p><h3>“It’s only transitive” is not the same as “it’s not used”</h3><p>A transitive dependency isn’t automatically harmless. It only means nobody on your side named it directly.</p><p>express pulls in body-parser, which pulls in qs. Your code never imports qs by name, and it still parses every query string your service serves, because express calls it internally. Direct or transitive, either one can be sitting in your hot path.</p><p>Settling that properly, for real and not by inference, means following the call chain from your code through every intermediate package to the specific vulnerable function. That’s thousands of lines across dozens of packages, per alert, repeated for every repository and every new advisory. The advisories themselves usually don’t help either: they name the package and the affected version range, but rarely the specific function or class that’s actually dangerous.</p><p>That gap is expensive to close exactly, and the data needed to close it exactly usually isn’t there. So we set the bar at a cheaper, still meaningful question: is the package imported at all by first-party code?</p><h3>How an alert becomes a decision</h3><p>The mechanical part of this pipeline is boring by design:</p><ol><li><strong>Advisory published</strong>: a maintainer or researcher discloses a flaw, usually with a CVE.</li><li><strong>Matched to your dependency graph</strong>: GitHub compares the affected version range against each repo.</li><li><strong>Dependabot alert fires</strong>: one per repository per advisory. The same package can raise many.</li><li><strong>A ticket lands in the queue</strong>: an automated flow enriches the alert and writes it up.</li><li><strong>Someone has to decide</strong>: does this deserve an engineer’s time, and how urgently?</li></ol><p>Steps one through four are free and continuous. Step five was the bottleneck, and here’s why: the alert tells you a vulnerable version is <em>present</em>. It never tells you whether your code actually <em>uses</em> it.</p><h3>The signal nobody hands you</h3><p>Every alert arrives already carrying four external signals, and none of them has seen your codebase:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2-mIA6WUSvKvADfkgl2zAQ.png" /></figure><p>There’s a fifth signal, and it’s the only one that’s actually about <em>you</em>: does your first-party code import the affected package? Nobody supplies that one. You have to compute it yourself, per alert, per repository.</p><p>Two alerts in the same batch made the point sharply. Same package, same CVE, same CVSS score, same EPSS score. One was imported in several places across one service; the identical alert in a different service imported nothing at all. Every external signal was identical. Only reachability told them apart, and reachability decided whether one ticket needed a fix and the other didn’t.</p><blockquote>Every external signal was identical. Only reachability told them apart.</blockquote><h3>The problem, in three numbers</h3><ul><li><strong>503 of 507</strong> alerts landed with the system default priority (the lowest band), regardless of what the vulnerability actually was.</li><li><strong>15 minutes</strong> of a security analyst’s time, per alert, to answer one question by hand: is this package actually used here?</li><li><strong>292</strong> high-and-critical alerts sat in the exact same queue as everything else, behind that same manual step.</li></ul><p>The prioritization matrix (severity, exploitation probability, known-exploited status, reachability) already existed and was already agreed on. What didn’t exist was a reliable, repeatable way to feed it the one input it leans on hardest: reachability.</p><h3>What the system actually does</h3><p>Given an alert: is the vulnerable package reachable from first-party code, and given that, what priority and what ticket action does the agreed policy dictate?</p><pre>prioritize(severity, reachable, transitive, in_kev, epss, has_cve) → Decision</pre><p>Six inputs in, one decision out. Reachability, computed live per alert, is what moves a row between bands.</p><h3>The full matrix</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UfxKzaMqGJTqEMwOC-F2Xw.png" /></figure><p>Only dev-dependency rows dismiss the underlying alert. Every other row triages the ticket and leaves the alert open, so a later recheck can still see it.</p><p><strong>Sync</strong> scans every repo for Dependabot alerts, enriches each one (severity, exploitation probability, known-exploited status, CVE), and creates a tracking ticket.</p><p><strong>Analysis</strong> picks up eligible tickets, clones the affected repo, and applies the decision matrix. Cloning is deduplicated by repo, ecosystem and package: the same scan never runs twice for the same combination.</p><p><strong>Outcome</strong> is binary:</p><ul><li><strong>Keep open</strong> <em>(should be fixed)</em>: the ticket stays open with updated severity and the exact import locations attached as evidence, for example package: nanoid, imported: yes, line: src/lib/id-generator.ts:1, src/services/user-service.ts:42. If severity moved upward during analysis, a fresh ticket is opened with the new values so the response-time clock restarts from the day of analysis, and the old ticket closes with a note pointing at the new one.</li><li><strong>Close, no fix warranted</strong>: the matrix says no ticket is needed. The ticket closes with the reason and the scan result recorded, and the underlying Dependabot alert stays open. Only the ticket is triaged; the alert itself is marked resolved by GitHub only when the package actually reaches its patched version, so continuous re-analysis can still catch it later.</li></ul><p>A fourth lane runs on its own schedule, independent of when tickets get created. <strong>Recheck</strong> sweeps closed tickets that have sat idle a few days, re-fetches the external signals fresh, re-scans for imports, and opens a new ticket only if the answer actually changed. Two things keep this safe to run forever: a ticket can be reopened at most once, and closing a ticket never closes the underlying alert, so nothing is ever silently dropped.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uIJ1LBISCMjv6t2DlsPx6w.png" /></figure><h3>Parsing real syntax trees</h3><p>Detecting an import sounds trivial until you try it on real code. A regular expression over source text fails on commented-out imports, a string that merely says the word “import,” multi-line import statements, aliases and re-exports. Each is a wrong answer waiting to happen, and a false “not imported” on a real vulnerability is far worse than a false alarm.</p><p>So detection walks real abstract syntax trees, using tree-sitter, with node types verified empirically against the exact library versions installed rather than assumed from documentation. Python’s import statements, JavaScript and TypeScript’s ES imports plus require() plus dynamic imports plus re-exports, Go’s import specs: all handled as actual syntax.</p><p>The package name an alert reports is also often not the name that shows up in your code: beautifulsoup4 installs as beautifulsoup4 but imports as bs4; PyYAML imports as yaml. Separating “the name Dependabot knows” from “the name that appears in an import statement” turned out to matter in practice, not just as a theoretical edge case.</p><h3>What this deliberately does not do</h3><p>Reachability here means imports, not a full call graph. It reports file:line locations a developer can open directly. It does not report whether a specific vulnerable method inside that import is actually invoked; that needs enriched, per-vulnerability data that’s frequently unavailable and expensive to compute.</p><h3>What actually changed</h3><p>Of the <strong>507 alerts</strong> in that pilot window, <strong>500</strong> were eligible for the automated matrix; the remaining 7 fell outside what the detector currently parses and were triaged by hand instead. Across those 500, the matrix produced:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GjoHQrmt76fFy5rKQQFQiQ.png" /></figure><p>That’s <strong>206 kept open</strong> against <strong>294 closed</strong>. Of the 206, 178 stayed open because the package is genuinely imported; the other 28 are unreachable criticals the policy still tickets, because a critical unreachable today can become reachable tomorrow and “unreachable” is not the same claim as “safe.” Every reachable ticket carries the exact file and line where the import happens, so the owning developer starts at the actual site, not a package name and a guess.</p><p><strong>284 alerts</strong> moved off the original default, every one of them upward, including 10 that turned out to be the most urgent category possible. Under manual triage, those ten were sitting indistinguishable from routine noise in the same queue.</p><p>The effort side: 15 minutes of analyst time per alert, across <strong>500 alerts</strong> in a month, is roughly <strong>125 hours</strong>, over three working weeks of human attention returned in a single month. It compounds further whenever the same package is flagged repeatedly within one repository: one clone and scan answers every alert sharing that repository, ecosystem and package, instead of a separate manual check for each.</p><h3>Checked by hand, not just by the tests</h3><p>Roughly a fifth of the dataset, about <strong>100 tickets</strong>, was checked by hand against the automated result, independently of the pipeline that produced it. That’s the kind of spot-check a pilot exists to run before anyone lets the pipeline near the full backlog unsupervised. Every single one agreed on the decision: fix, or don’t.</p><p>That validates the decision-making, not the exhaustiveness of detection. The blind spots listed above are still exactly that: known and unresolved, in both the automated result and the human check that confirmed it. But it’s the number that made the team comfortable letting a pure function make a call that used to need fifteen minutes of a person’s judgment, every time.</p><h3>Why it’s trustworthy</h3><p>The trust argument mattered most:</p><ul><li>The decision logic is a pure function of six inputs. Nothing else can influence it, and all the messy I/O, network calls, cloning, notifications, live well outside it.</li><li>That function is unit-tested exhaustively against the entire agreed decision table. If the policy changes, the tests are where that change gets expressed.</li><li>Every external dependency the system touches is swappable in tests, so the whole suite runs offline, deterministically, with zero flakiness.</li><li>Every run logs the exact values that drove a decision, so any outcome can be reconstructed later from the logs and the row alone.</li><li>Certificate verification is never disabled, no secret is hardcoded, and every shell-adjacent call passes an argument list rather than a string it built itself.</li></ul><blockquote>Two people used to reach different conclusions on the identical alert. A pure function can’t do that.</blockquote><h3>A decision has a shelf life</h3><p>A single analysis run is a snapshot of one specific day, and both sides of that snapshot keep moving after it’s taken.</p><p>The external metrics move on their own: an exploitation-probability score gets re-scored continuously, a CVE can be added to a known-exploited list weeks later, a severity score can be revised or published late. Your code moves too: a package reported as “not imported” last month can be imported today, after a new feature or a refactor. “Not reachable” was never meant to be read as a permanent answer, which is why only the ticket gets closed, never the underlying alert. Dismissing the alert itself would delete the very thing a future re-check needs to look at again.</p><p>With one exception: dev-only dependencies are dismissed upstream, since they never reach the production image. Everything else stays open on GitHub for as long as the risk is unresolved.</p><h3>Where the system points attention</h3><p>By the end of one month, 294 alerts had closed themselves with the reasoning already attached, and ten had jumped straight to the top of the queue with a file and a line number sitting in the ticket. The engineer who picked either one up never had to ask why.</p><p>That’s the pilot’s job done: one month of real alerts was the test case for whether this logic could be trusted, not a lucky sample. What happens next, letting the pipeline run against the full backlog on its own schedule rather than as a bounded test window, is a separate decision, made easier by having a month of hand-checked agreement behind it.</p><p><strong>Proudly brought to you by the FSMKCU Product Security Team </strong>🛡️<strong><br></strong>Hardik Nanda • Mochamad Akbar Anggamaulana • Goutham Madhwaraj</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HaagSR3BcQb1-ANr2CZHSQ.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5f0f6c05c5ac" width="1" height="1" alt=""><hr><p><a href="https://medium.com/fsmk-engineering/high-signal-high-impact-scaling-dependency-security-efficiently-5f0f6c05c5ac">High Signal, High Impact: Scaling Dependency Security Efficiently</a> was originally published in <a href="https://medium.com/fsmk-engineering">Technology @ Funding Societies | Modalku</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[AI-powered Bank Statement Analysis for SME Lending in Malaysia & Singapore]]></title>
            <link>https://medium.com/fsmk-engineering/ai-powered-bank-statement-analysis-for-sme-lending-in-malaysia-singapore-b9ae91b72e27?source=rss----95882711d047---4</link>
            <guid isPermaLink="false">https://medium.com/p/b9ae91b72e27</guid>
            <category><![CDATA[pdf]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[bank-statement]]></category>
            <dc:creator><![CDATA[Hau Ma]]></dc:creator>
            <pubDate>Fri, 31 Jul 2026 08:19:34 GMT</pubDate>
            <atom:updated>2026-07-31T08:32:50.613Z</atom:updated>
            <content:encoded><![CDATA[<h3>How Funding Societies Uses AI to Accelerate SME Underwriting Without Compromising Risk Controls</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yfvkVQsLMyNc03v46Jf4rA.png" /></figure><p>Small and medium-sized enterprises (SMEs) are the backbone of Southeast Asia’s economy. In markets like Malaysia and Singapore, these businesses require fast and flexible financing to maintain cash flow and scale operations. However, one of the primary hurdles in lending is the ability to evaluate a borrower’s financial health quickly while maintaining rigorous risk controls.</p><p>At <strong>Funding Societies</strong>, we built an AI-assisted underwriting pipeline that combines document parsing, transaction analysis, validation, and human review to improve turnaround time while maintaining risk discipline.</p><h3>The Underwriting Bottleneck</h3><p>To evaluate a borrower’s creditworthiness and repayment capacity, we typically review several months of bank statements. These documents provide a detailed financial record, showing transaction histories, balance movements, and income patterns.</p><p>Historically, this process was a significant bottleneck:</p><ul><li><strong>Manual Review</strong>: While thorough, manual analyst review is inherently slow, expensive, and difficult to scale as application volumes grow.</li><li><strong>Inconsistent Data</strong>: Bank statements are among the hardest semi-structured documents to work with because formats change from bank to bank and data quality is often inconsistent.</li><li><strong>Operational Strain</strong>: As we grew, neither manual review nor basic automated tools could keep up with the need for both speed and accuracy.</li></ul><h3>Why COTS Approaches Fell Short</h3><p>We initially explored Commercial Off-The-Shelf (COTS) and third-party extraction tools, but they often fell short due to three practical realities:</p><ol><li><strong>Extreme Document Variability</strong>: Bank statements in Southeast Asia come in dozens of formats. Differences in column structures, number formatting, and date representations mean that general-purpose parsers often fail on the “long tail” of uncommon layouts.</li><li><strong>Lack of Workflow Fit</strong>: Extraction is only one piece of the puzzle. The data must flow seamlessly into categorization, risk scoring, and analyst review. Owning the extraction layer allows us to control the full pipeline from intake to decision.</li><li><strong>Performance Trade-offs</strong>: Third-party tools often struggle with the variety of bank-specific layouts found across the region, leading to higher error rates or the need for constant manual intervention.</li></ol><h3>Our System Design Principles</h3><p>When building our in-house AI-powered automation pipeline, we followed a core guiding principle: <strong>Use deterministic logic where possible, use AI where flexibility is required, and validate everything before it moves downstream</strong>.</p><p>We moved away from a “pure AI” approach — feeding entire pages into a model — because it introduced too much variance for a lending context. Instead, our modular, hybrid architecture ensures each layer can be independently monitored and improved.</p><h3>The Workflow in Broad Terms</h3><p>Our pipeline processes bank statements through several distinct stages to ensure data integrity and accuracy.</p><h3>1. Document Integrity Checks</h3><p>Before any data is extracted, we perform a series of document integrity and consistency checks. These include validating PDF metadata and verifying document structure to identify potential inconsistencies or anomalies. Documents that do not meet our validation criteria are automatically flagged for manual review, helping ensure the accuracy and reliability of downstream processing.</p><h3>2. Header and Account Extraction</h3><p>We extract critical metadata such as account holder names, statement periods, and balances. Because these fields vary in position, we use a <strong>mix of lightweight and higher-reasoning models</strong> depending on task complexity, document variability, and cost-performance requirements.</p><h3>3. Coordinate-Aware Transaction Extraction</h3><p>To handle the complexity of transaction tables, we use coordinate-aware parsing combined with predefined header mappings. This allows the system to understand the geometric structure of the PDF while using model-assisted interpretation for ambiguous cases. We also employ <strong>skill-based agentic tooling</strong> to automatically process and verify new bank templates as they appear in our system.</p><h3>4. Categorization and Standardization</h3><p>Transactions are automatically categorized into common business groups such as revenue, payroll, rent, and operating expenses. To maintain consistency across reports, the system applies standardized categorization rules so that similar transactions are classified uniformly, even when transaction descriptions vary. This helps produce more reliable financial summaries and analysis while reducing the need for manual adjustments.</p><h3>Human-in-the-Loop and Quality Controls</h3><p>Our automation is designed to accelerate analysts’ work, not replace their judgment. Human review is a core part of the workflow and is triggered when:</p><ul><li>Document quality or structural inconsistencies are detected.</li><li>Confidence scores fall below predefined thresholds.</li><li>A case requires additional contextual assessment.</li></ul><p>This hybrid approach ensures that complex or low-confidence cases receive expert review while creating a continuous feedback loop that helps improve the accuracy and reliability of our models over time.</p><h3>Business Impact</h3><p>Since deploying this system, we have achieved <strong>production-grade accuracy</strong> comparable to or better than prior approaches on our internal benchmarks. The business outcomes include:</p><ul><li><strong>Faster Turnaround</strong>: Processing time has been reduced significantly, allowing SMEs to receive decisions faster and capture growth opportunities.</li><li><strong>Material Reduction in Unit Cost</strong>: By moving in-house and optimizing model selection, we have reduced per-file processing costs by an order of magnitude.</li><li><strong>Scalability</strong>: The system efficiently handles volume spikes without requiring a proportional increase in headcount.</li></ul><h3>Lessons Learned</h3><p>Running AI in a regulated lending environment has taught us that <strong>control is the product</strong>. Technically sound models are only half the battle; the ability to audit, explain, and override decisions is mandatory.</p><p>We have also learned that bank formats will always stay messy, requiring an ongoing operational commitment to tooling and alerting. Ultimately, matching model capability to task complexity — rather than just picking the “best” model — is what drives sustainable unit economics and reliable risk management.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b9ae91b72e27" width="1" height="1" alt=""><hr><p><a href="https://medium.com/fsmk-engineering/ai-powered-bank-statement-analysis-for-sme-lending-in-malaysia-singapore-b9ae91b72e27">AI-powered Bank Statement Analysis for SME Lending in Malaysia &amp; Singapore</a> was originally published in <a href="https://medium.com/fsmk-engineering">Technology @ Funding Societies | Modalku</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Spec-First Parallel AI Development: Early Lessons from a Two-Week Trial]]></title>
            <link>https://medium.com/fsmk-engineering/spec-first-parallel-ai-development-early-lessons-from-a-two-week-trial-64aa33ab64e6?source=rss----95882711d047---4</link>
            <guid isPermaLink="false">https://medium.com/p/64aa33ab64e6</guid>
            <category><![CDATA[claude-code]]></category>
            <category><![CDATA[fintech-startups]]></category>
            <category><![CDATA[ai-development]]></category>
            <category><![CDATA[claude]]></category>
            <category><![CDATA[rails]]></category>
            <dc:creator><![CDATA[An Tran]]></dc:creator>
            <pubDate>Wed, 08 Oct 2025 02:09:02 GMT</pubDate>
            <atom:updated>2025-10-08T02:08:58.382Z</atom:updated>
            <content:encoded><![CDATA[<p>At Funding Societies, we’re always exploring ways to ship features faster while maintaining our quality standards. Recently, we ran a two-week trial testing a new approach where one engineer coordinates multiple Claude Code agents working in parallel on separate parts of a feature.</p><p>The methodology relies on five key elements:</p><ol><li>Detailed specification documents that capture all decisions and requirements</li><li>Pattern libraries with concrete examples</li><li>Complete, self-contained feature segments that work independently</li><li>Fresh AI sessions per PR to maintain focus</li><li>Specialized review assistants that catch mistakes before human review</li></ol><p><strong>Security and Privacy Note</strong>: We conducted this experiment using Claude Code within an isolated development environment. We worked exclusively with code samples and synthetic test data — no customer data, credentials, or secrets were shared with external services. All changes passed human code review, automated tests, and security scans before merge.</p><p><strong>TL;DR</strong>: We ran a short, controlled pilot pairing engineers with AI coding agents on a migration task. By front-loading specification and using independent vertical slices, we saw ~40% improvements in internal throughput and ~50% reduction in cycle time without changing our security, review, or testing gates. The gains were uneven: they were strongest where work decomposed cleanly, and weakest in multi-layer debugging. We’re now running a 30–60 day validation using DORA-style indicators.</p><h3>Table of Contents</h3><ol><li><a href="https://medium.com/@an.tran_99237/64aa33ab64e6#1-background">Background</a></li><li><a href="https://medium.com/@an.tran_99237/64aa33ab64e6#2-the-experiment-plan-first-build-in-parallel">The Experiment: Plan First, Build in Parallel</a></li><li><a href="#3-code-review-and-refinement">Code Review and Refinement</a></li><li><a href="#4-what-we-observed">What We Observed</a></li><li><a href="#5-challenges-and-limitations">Challenges and Limitations</a></li><li><a href="#6-our-engineering-role-changed">Our Engineering Role Changed</a></li><li><a href="#7-conclusion">Conclusion</a></li></ol><h3>1. Background</h3><h3>The Business Context</h3><p>We have been migrating legacy Rails systems to modern Go APIs for a while. When working on the next batch of features to migrate, we saw multiple big features estimated to take up to 4 weeks to migrate by one developer. We’d been using AI tools for several months for specific tasks like code generation and test writing, but we sensed we could do more. By 2025, AI coding tools had become really powerful; they could understand complex requirements, build entire features, and keep code consistent across large projects.</p><p>We saw an opportunity to challenge ourselves: <strong>What if we took a feature that would typically take 4 weeks for one engineer and tried to finish it faster by working with multiple AI agents simultaneously?</strong></p><p>For our experiment, we chose to migrate a legacy reward program built in Rails — to our new Go service. This feature allows users to generate user codes, share them with friends, and earn rewards when friends successfully sign up. The system includes code generation, validation pipelines, reward tracking, and redemption flows with different business rules across regions.</p><h3>Our Hypothesis</h3><p>Traditionally, engineers work through features one step at a time — implement, review, merge, repeat. What if we could explore a different approach?</p><p><strong>Here’s what we wanted to test:</strong></p><ul><li><strong>Traditional approach</strong>: One engineer, 4 weeks, working step by step</li><li><strong>Our experiment</strong>: One engineer guiding 2–3 AI agents working simultaneously, perhaps finishing in 2 weeks</li><li><strong>The key</strong>: Breaking work into independent pieces that could happen in parallel</li></ul><p>The diagram shows our thinking: instead of writing all the code ourselves, what if we could guide three AI agents, each focused on different parts? We thought it was worth exploring.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vUPUIX72DxqPAwDuN7BSAA.png" /><figcaption>Multi-Agent Development Hypothesis</figcaption></figure><h3>How We Set Up Our Development Workflow</h3><p>To make parallel AI development work, we refined our existing workflow to take advantage of what AI does best. Here’s what our setup looked like:</p><ol><li><strong>AI-powered documentation cycle</strong> — AI writes better code when it has better documentation. We used AI to analyze our legacy system and create comprehensive technical documentation, implementation plans, user stories, and pattern guides that humans and AI could understand perfectly.</li><li><strong>Parallel end-to-end development</strong> — We designed work so that 2–3 AI agents could each implement a complete vertical slice of the feature. Each agent would work sequentially through their slice — models, repository, service, tests — but multiple agents did this in parallel on different slices. For example, while Agent 1 built the entire code generation flow end-to-end, Agent 2 implemented the complete validation pipeline. Each owned their piece from the database to the API, working independently without blocking others.</li><li><strong>Small PRs for fast iteration</strong> — We’ve always kept PRs under 100 lines as a team practice, but this turned out to be perfect for AI development. Small PRs make it easy to spot and correct AI mistakes before they compound — you can review in seconds, provide feedback immediately, and get back on track. With AI, this practice became even more powerful: most PRs went from creation to merge in 30 minutes to 2 hours.</li><li><strong>Living pattern documentation</strong> — We documented our team’s coding patterns in detail, including how we structure each layer, handle errors, write logs, and organize tests. We created pattern files with real examples from our codebase, not just rules. The AI-generated code almost always conformed to these patterns perfectly. When we spotted any ambiguity in AI output — maybe a variable naming inconsistency or a slightly different error handling approach — we immediately updated our pattern docs to be clearer. This continuous refinement meant the patterns improved over time, and AI code became increasingly indistinguishable from what our team would write.</li></ol><p>With this workflow in place, we were ready to put our hypothesis to the test.</p><h3>2. <strong>The Experiment: Plan First, Build in Parallel</strong></h3><p>Our approach had two clear stages: first, we used one AI agent to understand what we were building, then we unleashed multiple agents to construct different parts simultaneously.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xvG1v4ZwCE8vUfgP321z4Q.png" /><figcaption>Two-stage implementation</figcaption></figure><h3>Stage 1: Planning with AI</h3><p>Before we could coordinate multiple AI agents working in parallel, we needed clear plans for each to follow. We used AI to accelerate this discovery phase — analyzing the legacy system and creating detailed specifications.</p><p><strong>Phase 1: Understanding the Legacy System</strong></p><p>First, we needed to understand what already existed. We pointed AI at our legacy systems and got back comprehensive documentation:</p><ul><li><strong>Multiple key database tables</strong>: Complete schema and relationships documented</li><li><strong>ActiveRecord models</strong>: Business logic extracted with all validations and callbacks</li><li><strong>16-step validation pipeline</strong>: Existing flow that needed extension for a new feature</li><li><strong>Region-specific configurations</strong>: Different rules for different regions/markets</li><li><strong>Multiple system integration points</strong>: How different services interact</li></ul><p>This analysis gave us a deep understanding that would have taken weeks to build manually.</p><p><strong>Phase 2: Clarifying What to Build</strong></p><p>Understanding the existing system was just the starting point. Next, we needed to clarify what we wanted to build. We asked AI to identify gaps in our understanding and generate questions we needed to answer:</p><ul><li>What format should user codes use?</li><li>When do users get rewards — immediately or after verification?</li><li>What happens with expired or already-used codes?</li><li>How should this work with our existing validation system?</li></ul><p>We answered each question to define what we wanted to build. AI turned our answers into clear documentation.</p><p><strong>Phase 3: Creating the Implementation Plan</strong></p><p>With requirements clarified, we needed an actionable plan. We used AI to create detailed specifications:</p><ul><li><strong>Execution roadmap</strong>: A structured approach with clear phases and dependencies</li><li><strong>Effort estimation</strong>: Initial timeline projections that we could refine as we learned more</li><li><strong>Architectural decisions</strong>: Key choices like extending our existing validation pipeline rather than building from scratch</li><li><strong>Implementation scope</strong>: Complete picture of files and components that would need creation or modification</li><li><strong>Testing approach</strong>: Strategy focused on HTTP integration tests for reliable validation</li></ul><p>This planning gave us confidence that we understood what to build and how to build it.</p><p><strong>Phase 4: Breaking Work into Independent Pieces</strong></p><p>Finally, we needed to organize work so multiple AI agents could build in parallel. Instead of creating new technical breakdowns, we used the user stories our product team had already defined:</p><ul><li><strong>Feature A: Generate User Codes</strong> — The core user code creation system</li><li><strong>Feature B: View Codes via API</strong> — New API for dashboard access</li><li><strong>Feature C: Validate Code Enhancement</strong> — Extending the existing validation pipeline</li><li><strong>Feature D: Code Redemption</strong> — Redemption flow integration</li><li><strong>Feature E: Statistics API</strong> — Analytics and monitoring capabilities</li></ul><p>Each story represented a complete feature that delivered customer value. Using existing product stories meant we could communicate progress in business terms that everyone understood.</p><p>The key insight: once we built core models and basic infrastructure, we could guide multiple AI agents simultaneously, each focused on different user stories built upon the shared foundation.</p><h3>Stage 2: Building in Parallel</h3><p>With planning complete, we could finally test our core hypothesis: could multiple AI agents working simultaneously compress our timeline from 4 weeks to 2 weeks?</p><p>The answer was yes, but it required the right setup.</p><p><strong>Setting Up the Workspace</strong></p><p>First, we needed a workspace where multiple agents could work independently. We organized it like separate workbenches for each AI agent, with shared blueprints they could all reference.</p><p>Here’s the structure:</p><pre>workspace/<br>├── specifications/                     # Shared context for all agents<br>│   ├── analysis/                       # Discovery phase outputs<br>│   │   ├── legacy_analysis.md          # Comprehensive system understanding<br>│   │   ├── requirements_final.md       # Clarified business rules<br>│   │   └── questionnaire_answers.md    # Complete Q&amp;A documentation<br>│   ├── plans/                          # Implementation roadmaps<br>│   │   ├── implementation_plan.md      # Master plan with phases<br>│   │   ├── effort_estimation.md        # Time estimates<br>│   │   └── task_sequencing.md          # Optimized execution order<br>│   └── stories/                        # Independent story breakdowns<br>│       ├── feature-a_generation.md<br>│       ├── feature-b_api.md<br>│       └── ...<br>├── implementation/                     # Per-story execution tracking<br>│   ├── 002__feature-a_generation/<br>│   │   ├── 001__attempt_1/<br>│   │   │   ├── implementation.md       # PR breakdown &amp; status<br>│   │   │   ├── feedback.md             # Pattern corrections<br>│   │   │   └── branches.txt            # Active branch tracking<br>│   │   └── prompts/<br>│   │       ├── plan_prompt.md          # Standard planning prompt<br>│   │       └── continue_prompt.md      # Continuation instructions<br>│   └── 003__feature-b_api/<br>└── patterns/                           # Living style guide<br>    ├── STYLE_GUIDE.md                  # Quick reference guide<br>    └── detailed/                       # Pattern library<br>        ├── 01-patterns__errors.md      # Error handling patterns<br>        ├── 01-patterns__models.md      # Domain model patterns<br>        ├── 01-patterns__repositories.md # Data access patterns<br>        ├── 01-patterns__services.md    # Service layer patterns<br>        ├── 02-testing.md               # HTTP-first test approach<br>        └── 03-architecture.md          # DDD and layering rules</pre><p><strong>Coordinating Multiple Agents</strong></p><p>The key to coordination was implementation.md files. These living documents served as the coordination center for each story.</p><p>Each story folder contained an implementation.md file—a detailed plan that broke down the user story into smaller steps. The focus was speed and fast feedback loops: AI completes each step quickly, we course correct if needed, and we review each PR in under 5 minutes. This enabled any Claude Code session to pick up exactly where the previous session left off.</p><p>Each file contained:</p><ul><li><strong>Status tracker</strong>: Real-time progress of each PR (completed, in progress, pending)</li><li><strong>Current branch</strong>: Which git branch should the agent be working on</li><li><strong>PR-by-PR breakdown</strong>: Clear scope and specific file changes for each component</li><li><strong>Auto-continue instructions</strong>: How can any AI session pick up work seamlessly</li></ul><p><strong>Example implementation tracking:</strong></p><pre>## Status Tracker<br><br>| Status           | PR      | Component     | Result               |<br>|------------------|---------|---------------|----------------------|<br>| ✅ **Completed** | PR #1   | API Models    | Implemented &amp; Tested |<br>| ✅ **Completed** | PR #2   | Repository    | Implemented &amp; Tested |<br>| ✅ **Completed** | PR #3   | Service       | Implemented &amp; Tested |<br>| ✅ **Completed** | PR #4   | Controller    | Implemented &amp; Tested |<br>| ✅ **Completed** | PR #5   | Integration   | Implemented &amp; Tested |<br>| 📋 **Total**     | 5/5 PRs | 100% Complete | **FEATURE COMPLETE** |</pre><p>This tracking system enabled any AI session to quickly identify what was completed, in progress, and pending — eliminating context confusion when running multiple agents or restarting sessions.</p><p><strong>Running Multiple Agents</strong></p><p>With our workspace ready, we could test the core idea: running multiple AI agents simultaneously. Here’s how it worked.</p><p>We focused on four user stories that AI agents could build independently:</p><ul><li><strong>Feature A</strong>: Generate user codes (core creation logic)</li><li><strong>Feature B</strong>: Customer API for viewing codes (new API endpoints)</li><li><strong>Feature C</strong>: Create user records during payment flow</li><li><strong>Feature E</strong>: Statistics API for analytics dashboard</li></ul><p>We opened 2–3 terminal sessions, each running its own AI agent:</p><pre># Terminal 1: Feature A Generation<br>$ &quot;&gt; help me with implementation/002__feature-a_generation/implementation.md&quot;<br><br># Terminal 2: Feature B API<br>$ &quot;&gt; help me with implementation/003__feature-b_api/implementation.md&quot;<br><br># Terminal 3: Feature C Validation<br>$ &quot;&gt; help me with implementation/004__feature-c_validation/implementation.md&quot;</pre><p>Each agent would pick up exactly where the previous session left off, work through the next PR in sequence, and update the progress tracker. The key insight was that once our database models were established, multiple AI agents can build different functional areas simultaneously without conflicts — one agent handling code generation, another building analytics APIs, and a third extending validation pipelines.</p><p>This parallel approach worked because of four essential elements: self-contained implementation files with auto-continue instructions, clear PR boundaries preventing overlap, frequent merges to share completed work, and consistent coding patterns that made AI output predictable.</p><p>The implementation.md files included specific instructions like “review current progress,” “implement next step,” and “update tracker,” allowing any AI session to pick up exactly where needed without confusion.</p><h3>3. Code Review and Refinement</h3><p>Running multiple AI agents in parallel revealed a quality challenge. While Claude Code could understand our patterns when explained, it would consistently miss some in the actual implementation. We’d repeatedly fix the same issues — verbose variable names, inconsistent error handling, or missing validations.</p><p>This became frustrating when working across multiple stories. Instead of focusing on development, we spent time providing repetitive feedback about pattern violations.</p><p><strong>Using Specialized Subagents</strong></p><p>We realized we could use Claude Code’s subagent system. Subagents are specialized AI assistants with their own context windows. Instead of having the main Claude Code session implement features and check patterns simultaneously, we delegated pattern checking to a dedicated code-reviewer subagent.</p><p>This subagent focused entirely on scanning for pattern violations. Each AI assistant could excel at its specific task — one for coding, one for quality checking.</p><p><strong>The Review Process</strong></p><p>The workflow was simple:</p><pre># After implementation completes<br>$ &quot;&gt; @code-reviewer please review the current PR&quot;</pre><p>The code-reviewer subagent would analyze the changes and categorize findings by priority:</p><ul><li><strong>Critical</strong>: Pattern violations (must fix)</li><li><strong>Major</strong>: Missing error handling (should fix)</li><li><strong>Minor</strong>: Variable naming, comment clarity (nice to have)</li></ul><p>Then Claude Code could address issues with specific, targeted guidance:</p><pre>$ &quot;&gt; address the critical and major review comments&quot;</pre><p>The code-reviewer subagent pinpointed exactly where patterns were missed and explained the issues clearly. This eliminated the repetitive feedback cycle.</p><p><strong>Improving Over Time</strong></p><p>Each story folder included feedback.md files that captured recurring issues. When we noticed the same problem across multiple stories, we&#39;d update our style guide to prevent it everywhere.</p><p>For example, after seeing repeated verbose variable naming, we added:</p><pre># Variable Naming: Use concise helper variable names (`m` for mapper, not `sqlMapper`)</pre><p>This created a feedback loop: our patterns became more comprehensive over time, and later stories required fewer corrections.</p><h3>4. <strong>What We Observed</strong></h3><h3><strong>Throughput and Quality Metrics</strong></h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OKssoAuJAyN1KMM-CC-jcA.png" /><figcaption>PR Volume Comparison</figcaption></figure><p>The charts above compare our two-week trial against a matched baseline period. We observed ~40% higher PR throughput. We were simultaneously learning new coordination patterns, refining implementation processes, and establishing our parallel AI workflow during the experiment period.</p><p>But measuring throughput alone tells an incomplete story. An important question remains: did this come at the cost of quality? This is where standardized engineering metrics would be valuable.</p><p>The industry-standard DORA metrics would help measure both speed and quality dimensions. However, meaningful quality assessment requires time. Change failure rates need sufficient deployment cycles to be statistically meaningful. Recovery patterns typically emerge over months, not weeks. This is why we’re conducting extended 30–60 day validation studies using change-failure rate, rework ratio, and escaped-defect counts.</p><p>The larger question isn’t whether we can ship faster for two weeks — it’s whether a spec-first parallel approach might enable sustained speed without compromising production quality.</p><p><strong>Important Context</strong>: These figures reflect a time-boxed pilot in a non-production environment on a subset of migration tasks, compared with a matched internal baseline. They are directional indicators, not representative of company-wide output.</p><h3><strong>AI Interaction Efficiency</strong></h3><p>The basic metric we considered was the input/output ratio — ideally, you want to maximize output while minimizing input.</p><p>During the experiment, our patterns and practices were evolving rapidly. We were learning how to structure the implementation.md files, refining our CLAUDE.md patterns, and discovering what worked for parallel AI coordination. This constant evolution means any patterns in our data should be viewed as preliminary observations.</p><p>With that context in mind, here’s what our dataset across multiple git branches showed:</p><ul><li><strong>Average: 23.4 messages per branch</strong></li><li><strong>Median: 20 messages per branch</strong></li><li><strong>Most branches (75%) required fewer than 30 messages</strong></li><li><strong>About 10% required extensive iteration (30+ messages)</strong></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Ck49K7JZsbB-DN3BwLFvOQ.png" /><figcaption>Branch Distribution by User Prompt</figcaption></figure><p><strong>What Drove These Numbers</strong></p><p>We front-loaded complexity into our markdown specifications. Instead of explaining context and requirements in every interaction, we wrote a detailed implementation.md files once, then used simple prompts like “help me with implementation.md” repeatedly.</p><p>The chart shows this approach working for most branches, but the high-interaction outliers tell an interesting story. These typically fell into three categories: pattern development (especially early on), complex validation logic, and multi-layer debugging challenges.</p><p>Notably, many high-interaction branches occurred early in our experiment, suggesting we were building reusable patterns from which later work could benefit. This temporal pattern raises an intriguing possibility. Front-loading effort into comprehensive planning and pattern development might reduce ongoing interaction costs — representing a fundamentally different approach to AI-assisted development.</p><p>Of course, with just two weeks of rapidly evolving practices, we can’t separate learning curve effects from genuine efficiency differences. Validating this hypothesis would require much longer studies with stable methodologies and proper controls — but it’s a question worth exploring as more teams experiment with similar approaches.</p><h3>5. Challenges and Limitations</h3><p>While we observed promising throughput improvements, we also discovered areas where the approach required more attention than expected. These experiences helped us understand both the potential and the practical considerations of parallel AI development.</p><h3>AI Context Degradation</h3><p>AI sessions gradually lose clarity over extended periods. After 2–3 hours of intensive work, agents would begin mixing patterns, forgetting previous decisions, and generating less consistent code.</p><p>Fresh sessions for each PR became our standard practice, though this creates a trade-off. While each agent starts with a clear context for its specific task, it needs to re-read implementation files and loses the accumulated system understanding from previous sessions. This costs additional tokens and time, but gives more reliable results. This pattern shaped how we structure work into smaller, more focused chunks:</p><pre># Instead of marathon sessions<br>$ &quot;&gt; implement entire story-001&quot;  # ❌ Degrades over time<br><br># We used focused sprints<br>$ &quot;&gt; implement PR #1 for story-001&quot;  # ✅ Clear and focused<br># Complete PR, merge, start new session<br>$ &quot;&gt; implement PR #2 for story-001&quot;  # ✅ Fresh context</pre><h3>Verification and Citation Challenges</h3><p>AI can occasionally generate plausible-sounding code examples when referencing legacy systems. While this happened rarely, when Claude Code did create convincing code snippets rather than searching our actual Rails reference codebase, it was problematic:</p><pre># Was this real legacy code or AI assumption?<br>def calculate_user_bonus(amount, tier)<br>  base_rate = RATES[tier] || 0.05<br>  amount * base_rate<br>end</pre><p>Without file paths and line numbers, we couldn’t easily distinguish between actual legacy patterns and AI assumptions about how the code “probably” worked.</p><p>We developed verification practices: emphasizing that Claude Code should search existing Rails reference code when analyzing legacy systems, asking for file paths and line numbers whenever AI shows code snippets from legacy codebases, and spot-checking referenced code to verify citations.</p><p>Verification takes time and attention that traditional development doesn’t require. This “trust but verify” approach works well once you establish the habit, though it does add a layer of checking to the development process.</p><h3>Complex Debugging</h3><p>We write functional integration tests that cover all the layers of the system. When these tests failed, we observed Claude Code struggling with complex validation chains spanning multiple layers — model validations, service business rules, database constraints, and HTTP controller checks.</p><p>Claude Code would often fix one layer while breaking another. It might add error handling in the service layer, only to break the database constraints. Fix that, and the original service logic would be wrong again. Each attempt typically made the code more complex and moved further from the actual solution.</p><p>We developed a three-attempt pattern to contain these debugging sessions:</p><ol><li><strong>First three attempts</strong>: Let AI try to fix the test failures</li><li><strong>After three attempts</strong>: AI stops and asks for guidance</li><li><strong>Human step-in</strong>: Often involves showing Claude Code similar examples from the codebase</li></ol><p>This approach helps manage the debugging time, but these multi-layer scenarios remain where AI struggles most. The three-attempt limit prevents extended unproductive sessions, though complex debugging continues to be an area where the approach shows its limitations.</p><h3>6. Our Engineering Role Changed</h3><p>Beyond the technical challenges and metrics, something more fundamental shifted during our experiment. The most significant change was how we approached development work. Running multiple AI agents in parallel meant stepping back from writing code and focusing on coordination and specification.</p><p>To test whether parallel agents could compress development time, we needed to resist the urge to code ourselves. This shift felt counterintuitive at first — shouldn’t engineers be writing code? But the experiment required us to become orchestrators rather than implementers.</p><p>Our daily work has transformed. Instead of spending most of our time coding, we wrote detailed specifications in markdown files, managed multiple terminal sessions, and documented patterns for AI agents to follow. The implementation.md files became our primary tool for communicating with each agent — detailed enough for any session to pick up exactly where the previous one left off.</p><p>This approach had an unexpected benefit: when issues appeared across multiple work streams, like verbose variable naming or inconsistent error handling, we could update our style guide once, and all agents would immediately follow the new pattern. Rather than fixing code directly, we refined the instructions, keeping all parallel work streams consistent without becoming a bottleneck ourselves.</p><p>By the end of the experiment, our git history told the story: mostly markdown files documenting specifications, patterns, and feedback notes. The actual Go code came from AI while we focused on aligning multiple work streams and moving forward. This role transformation was essential to achieving the parallel execution we were testing.</p><h3>7. Conclusion</h3><p>Looking back on our two-week trial, we observed ~40% higher PR throughput compared to a recent baseline period while maintaining comparable review and CI gates. Results are preliminary; longer validation studies are underway. But what surprised us most wasn’t the throughput improvement — it was how different the work felt.</p><p>The challenges we encountered taught us as much as the successes, shaping our understanding of what works when orchestrating multiple AI agents and revealing areas where this approach shows its limitations. Perhaps most significantly, the trial required us to rethink our role as engineers — instead of writing code, we found ourselves writing specifications and refining patterns that AI could follow consistently.</p><p>The five-element methodology we developed worked for our specific Rails-to-Go migration context, but the larger question isn’t whether this approach can work in isolated trials — it’s whether it enables sustained development speed while maintaining quality standards over months. That assessment requires time, and the industry-standard DORA metrics would help measure both speed and quality dimensions comprehensively.</p><p>We’re continuing to experiment with these ideas, refining both the methodology and our understanding of its limitations. We’d love to hear what works — and what doesn’t — as more teams explore similar approaches to parallel AI development.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=64aa33ab64e6" width="1" height="1" alt=""><hr><p><a href="https://medium.com/fsmk-engineering/spec-first-parallel-ai-development-early-lessons-from-a-two-week-trial-64aa33ab64e6">Spec-First Parallel AI Development: Early Lessons from a Two-Week Trial</a> was originally published in <a href="https://medium.com/fsmk-engineering">Technology @ Funding Societies | Modalku</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Migrating from In-House Authentication to SaaS: Our FusionAuth Journey]]></title>
            <link>https://medium.com/fsmk-engineering/migrating-from-in-house-authentication-to-saas-our-fusionauth-journey-26889f5def5d?source=rss----95882711d047---4</link>
            <guid isPermaLink="false">https://medium.com/p/26889f5def5d</guid>
            <category><![CDATA[legacy]]></category>
            <category><![CDATA[authentication]]></category>
            <category><![CDATA[auth]]></category>
            <category><![CDATA[saas]]></category>
            <category><![CDATA[migration]]></category>
            <dc:creator><![CDATA[Yubo Dong]]></dc:creator>
            <pubDate>Tue, 24 Jun 2025 00:49:17 GMT</pubDate>
            <atom:updated>2025-06-24T00:49:17.282Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*q1lWpwxklLzjhh3J9_tuAQ.png" /></figure><p>As our fintech platform scaled across Southeast Asia, our legacy Java-based authentication system began to show its age. What started as a simple solution for issuing tokens and handling logins became a bottleneck for feature development, security, and operational efficiency. Here’s how we migrated from our in-house authentication to FusionAuth, and what we learned along the way.</p><h3>The Challenge: Outgrowing Our In-House Auth</h3><p>Our original authentication service was a Java-based system that handled user logins, token issuance, and basic 2FA. Over time, it became clear that:</p><ul><li><strong>Feature development was slow</strong>: Adding new flows like SSO or advanced MFA took months of engineering effort.</li><li><strong>Security gaps emerged</strong>: Real-time threat detection, breach alerts, and device monitoring were missing.</li><li><strong>Maintenance was costly</strong>: Only a handful of engineers understood the system, and incidents were frequent.</li><li><strong>Scaling pains</strong>: Supporting hundreds of thousands of users across multiple countries led to technical debt and operational headaches.</li></ul><p>The system was tightly coupled to our internal databases and required direct integration with our API gateways for access control. As our product suite grew, so did the complexity of managing user credentials, enforcing security policies, and supporting new authentication requirements. The lack of modern features such as adaptive MFA, passwordless login, and robust monitoring made it increasingly difficult to keep up with both regulatory demands and user expectations.</p><h3>Why SaaS, Why FusionAuth?</h3><p>Recognising that authentication is not our core business, we proposed moving to a SaaS solution. Our goal was to find a platform that could not only match our current capabilities but also provide a foundation for future growth and security enhancements.</p><p>We evaluated several options (back in mid 2023, information may be outdated), comparing them across key factors:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bJqtJUxxKsb1rEYYm9-8Mg.png" /><figcaption>Feature Comparison</figcaption></figure><p><strong>Key:</strong></p><ul><li><strong>Price:</strong> Estimated monthly cost for 50,000 Monthly Active Users (MAU).</li><li><strong>MFA Support:</strong> Range and flexibility of multi-factor authentication options.</li><li><strong>Support &amp; SLA:</strong> Availability of enterprise support and Service Level Agreements.</li><li><strong>Documentation &amp; Ease of Use:</strong> Quality of docs and developer experience.</li><li><strong>Flexible Deployment:</strong> Managed cloud, self-hosted, or both.</li></ul><p>A thorough technical evaluation confirmed that FusionAuth could support our migration strategy, including phased user migration, integration with our existing infrastructure, and future enhancements.</p><h3>Migration Strategy</h3><p><strong>Migrating authentication systems is a high-stakes endeavour </strong>— any disruption can directly impact user experience and business operations. To minimise risk, we adopted a phased migration strategy, using FusionAuth as a data store behind our existing authentication service. This approach allowed us to keep our legacy auth service as the interface for all authentication requests while gradually shifting the underlying data operations to FusionAuth. By proxying requests and synchronising user data, we could validate the new system in production, catch issues early, and ensure a seamless experience for users.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/656/1*Oqym5J-J8-KIL8nN6owsQQ.png" /><figcaption>Migration Strategy</figcaption></figure><h3>Phase 1: Refactor Auth Service to Use FusionAuth as a Data Store</h3><p>Key tasks included:</p><ul><li><strong>Repository Layer Refactoring</strong>: Implement additional Repo layer, instead of DB queries, use FusionAuth API calls.</li><li><strong>User Data Migration</strong>: Import credentials, MFA settings, and metadata to FusionAuth while preserving password hashes.</li><li><strong>API Gateway Integration</strong>: Supported both JWT (FusionAuth) and legacy tokens for gradual client transition.</li><li><strong>Parallel Operation</strong>: Legacy and new systems ran in parallel with our FusionAuth data serve as single source of truth.</li></ul><p>The key to use FusionAuth as a data store is the repository layer refactoring. The original UserRepo was moved to UserPostgresRepo, with the new UserRepo containing both UserPostgresRepo and the newly implemented UserFusionAuthRepo . We are able to switch base on user’s migrated flag and dynamically to determine which repo to use when handling requests.</p><pre>public class UserRepository {<br>    UserPostgresRepository postgresRepo;<br>    UserFusionAuthRepository fusionAuthRepo;<br>    <br>    public User findByUsername() {<br>        User user = fusionAuthRepo.findByUsername(username);<br>        if (user == null) {<br>            user = postgresRepo.findByUsername(username);<br>        }<br>        return  user;<br>    }<br>    <br>    public void updateUser(User user) {<br>        if (user.isMigrated()) {<br>            fusionAuthRepo.updateUser(user);<br>        } else {<br>            postgresRepo.updateUser(user);<br>        }<br>    }<br>}<br><br>public class UserFusionAuthRepository {<br>    public User findByUsername(String username) {<br>        // find user in FusionAuth with API calls<br>    }<br><br>    public void updateUser(User user) {<br>        // update user in FusionAuth with API calls<br>    }<br>}<br><br>public class UserPostgresRepository {<br>    public User findByUsername(String username) {<br>        // find user in legacy Postgres database<br>    }<br><br>    public void updateUser(User user) {<br>        // update user in legacy Postgres database<br>    }<br>}</pre><p>At this point, both auth service and FusionAuth is able to hand out access tokens and clients are able to use either of them to get authenticated. This gave us the opportunity to migrate clients one by one at their own pace.</p><h3>Phase 2: Client Migration</h3><p>We then began updating clients to use FusionAuth directly.</p><ul><li><strong>Documentation and Support</strong>: Created guides for engineering teams with clear integration steps.</li><li><strong>Backend Services Migration</strong>: FusionAuth Library was created and Services use the library to call FusionAuth directly.</li><li><strong>Frontend Migration</strong>: Design a common login experience and customise FusionAuth’s hosted login pages. Frontend clients redirected to FusionAuth to authenticate.</li><li><strong>Custom Flows</strong>: Implemented region and application specific MFA and SMS OTP with FusionAuth’s extensibility.</li></ul><p>Given our limited dev resource and bandwidth, the whole migration process happened slowly over the span of a year.</p><h3>Phase 3: Cleanup and Deprecation</h3><p>With all clients migrated, we are able to finally stop the legacy auth service.</p><ul><li><strong>Migrate Active Code</strong>: Some auth related feature like encryption endpoint are still active and migrated to other services.</li><li><strong>Resource Cleanup</strong>: Clean up the API gateway authentication rules and stop the auth service.</li></ul><h3>Benefits Realised</h3><p>We achieved significant improvements:</p><ul><li><strong>Reduced Maintenance</strong>: Legacy Java stack is gone; duplicated user data are now in a single place.</li><li><strong>Stronger Security</strong>: Multiple MFA options, breach alerts, and modern threat detection now built-in.</li><li><strong>Faster Development</strong>: Features like SSO and passwordless login can be enabled via config.</li><li><strong>Unified UX</strong>: Seamless login across all products and applications to improved user satisfaction.</li><li><strong>Cost Savings</strong>: Lower TCO and better allocation of engineering resources.</li></ul><h3>Lessons Learned</h3><p>Some takeaways from the journey:</p><ul><li><strong>Focus on Core Value</strong>: Delegating auth freed us to focus on our mission — empowering SMEs.</li><li><strong>Phased Migration Minimises Risk</strong>: The data-store approach enabled two systems to function at same time, this minimises the risk and provide greater flexibility for client migration.</li><li><strong>Maintain Project Oversight</strong>: While this approach gave clients the flexibility to transition at their own pace, it is equally important to maintain tight control over the project timeline to ensure timely delivery.</li></ul><h3>Conclusion</h3><p>Migrating to FusionAuth was a complex but rewarding project. With careful planning, cross-team collaboration, and the right partner, we improved security, reduced operational burden, and laid a foundation for future growth.</p><p>For teams facing similar challenges, we recommend this migration strategy to keep both systems working so that clients can be migrated gradually. The incremental progress, can make auth modernisation achievable — and transformative.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=26889f5def5d" width="1" height="1" alt=""><hr><p><a href="https://medium.com/fsmk-engineering/migrating-from-in-house-authentication-to-saas-our-fusionauth-journey-26889f5def5d">Migrating from In-House Authentication to SaaS: Our FusionAuth Journey</a> was originally published in <a href="https://medium.com/fsmk-engineering">Technology @ Funding Societies | Modalku</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From days to minutes: How we revolutionized our i18n workflow with AI and Github Actions]]></title>
            <link>https://medium.com/fsmk-engineering/from-days-to-minutes-how-we-revolutionized-our-i18n-workflow-with-ai-and-github-actions-e14219588cb5?source=rss----95882711d047---4</link>
            <guid isPermaLink="false">https://medium.com/p/e14219588cb5</guid>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[i18n]]></category>
            <category><![CDATA[github-actions]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[Shawn Lim]]></dc:creator>
            <pubDate>Mon, 16 Jun 2025 02:56:26 GMT</pubDate>
            <atom:updated>2025-06-16T02:56:26.295Z</atom:updated>
            <content:encoded><![CDATA[<p><em>How we cut translation costs by &gt;90% and reduced turnaround time from days to minutes using LLMs</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HvIOOTetk8NfTvXukLjvrg.png" /></figure><h3>The problem with traditional i18n tools</h3><p>About a year ago, we found ourselves drowning in i18n SaaS subscription costs. Like many growing companies, we had adopted a popular translation management platform that promised to streamline our localization workflow. The monthly bills were substantial, but what really frustrated us was the feature bloat — we were paying for complex project management tools, translator marketplaces, and workflow orchestration systems that we simply didn’t need.</p><p>Our usage pattern was straightforward: we had a small team of developers shipping features regularly, and we needed those features translated into our target languages quickly and accurately. We weren’t managing dozens of translators or complex approval workflows. We just needed good translations, fast.</p><h3>The AI translation shift</h3><p>The turning point came when we noticed a curious trend among our team members. Despite having access to our expensive i18n platform, developers were increasingly turning to ChatGPT and other AI tools for quick translations. They’d copy a string, paste it into their favorite AI assistant, and get a translation in seconds.</p><p>This behavior made us realize something important: the landscape of translation had fundamentally changed. Before AI became mainstream, machine translations were semi-reliable, and human translators were essential for quality. The complex SaaS tools we were paying for were built for that era — they excelled at coordinating human translators, managing review cycles, and ensuring quality through human oversight.</p><p>But with modern LLMs producing remarkably good translations, especially for common languages and standard application text, the value proposition of these platforms had shifted dramatically.</p><h3>Our solution: AI-powered translation in the development flow</h3><p>We decided to build our own solution that would automate the translation process directly within our development workflow. The concept was simple but powerful: when a developer opens a pull request, our AI translation bot would automatically detect new or modified translatable strings, translate them into our target languages, and update the PR with the translations.</p><p>Here’s how our system works:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FyXmytoJzZpzp9xwPh0jzA.png" /></figure><h3>GitHub Actions workflow</h3><p>Our complete GitHub Actions workflow handles the entire translation pipeline, but with an important twist — we trigger translations via review comments to give developers control over when translations happen:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GzUpwjjFbliUlU0kTnL6MQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GKGStlawt59iYRO97Gy0vg.png" /></figure><h3>Smart diffing for translation detection</h3><p>The heart of our system is intelligent string detection. When a developer comments “<strong>translate</strong>” on their PR, our GitHub Action:</p><ol><li>Analyzes the diff to identify changes in translation files</li><li>Intelligently detects when the last auto-translation occurred, allowing for multiple locale change commits within the same PR</li><li>Extracts new or modified translation keys since the last auto-translation</li><li>Determines the context by examining the JSON configuration</li><li>Identifies the source language and target languages needed</li></ol><p>We use comment-triggered translation (rather than automatic triggers) to give developers flexibility to work on WIP code until they’re ready for translation. This is also particularly useful when developers want to manually fix one translation after running auto-translation, avoiding any complications or overwrites.</p><pre>jobs:<br>  translate:<br>    runs-on: ubuntu-latest<br>    steps:<br>      - uses: actions/checkout@v4<br>      - name: Detect translation changes<br>        id: detect<br>        run: |<br>          # Smart diff analysis to extract translatable strings<br>          node scripts/detect-translation-changes.js<br>      - name: Generate translations<br>        if: steps.detect.outputs.has-changes == &#39;true&#39;<br>        run: |<br>          node scripts/translate-strings.js<br>      - name: Commit translations<br>        run: |<br>          git config --local user.email &quot;translation-bot@company.com&quot;<br>          git config --local user.name &quot;Translation Bot&quot;<br>          git add .<br>          git commit -m &quot;🤖 Auto-translate new strings&quot;<br>          git push</pre><h3>Context-aware translation with LLMs</h3><p>Simply translating strings in isolation often produces poor results. Our system allows for rich context to be manually specified in the JSON configuration to ensure accurate, culturally appropriate translations.</p><p>Context information is manually populated as part of the translation configuration. For example, if we have text that needs to be translated for deployment in Islamic-friendly territories, we can specify that context directly in the JSON config. This contextual information is then fed into the LLM to generate appropriate, culturally-aware translations.</p><pre>{<br>    &quot;source_language&quot;: {<br>      &quot;name&quot;: &quot;English&quot;,<br>      &quot;file&quot;: &quot;en.json&quot;<br>    },<br>    &quot;target_languages&quot;: [<br>      {<br>        &quot;name&quot;: &quot;Thai&quot;,<br>        &quot;file&quot;: &quot;th.json&quot;<br>      },<br>      {<br>        &quot;name&quot;: &quot;Bahasa Melayu&quot;,<br>        &quot;file&quot;: &quot;my.json&quot;<br>      },<br>      {<br>        &quot;name&quot;: &quot;Bahasa Indonesia&quot;,<br>        &quot;file&quot;: &quot;id.json&quot;<br>      },<br>      {<br>        &quot;name&quot;: &quot;Vietnamese&quot;,<br>        &quot;file&quot;: &quot;vn.json&quot;<br>      }<br>    ],<br>    &quot;contexts&quot;: {<br>      // ... other context<br>    },<br>    &quot;custom_prompt&quot;: &quot;When translating to bahasa indonesia and melayu, please use words that are compliant to islamic law and sharia law&quot;<br>  }</pre><h3>Multi-platform support</h3><p>Our solution handles multiple platforms seamlessly because of our architectural approach: all our applications load translations from files uploaded to a CDN. This design decision makes platform support almost trivial — whether we’re working with React, Vue, Angular, React Native, or Flutter applications, the translation files are universally accessible.</p><p>Since most of our applications are not very large, the translation payload remains manageable without needing to over-engineer for size optimization. Applications simply fetch their translation files from the CDN at startup, keeping the architecture simple and reliable.</p><p>By standardizing on JSON format, applications can choose their favorite translation libraries without any constraints. Whether a team prefers react-i18next, vue-i18n, or any other i18n library, they can all consume the same JSON translation files from our CDN.</p><p>This approach provides several advantages:</p><ul><li><strong>Platform agnostic</strong>: Any framework that can load JSON files can use our translations</li><li><strong>Library flexibility</strong>: Teams can choose their preferred i18n libraries without affecting the translation pipeline</li><li><strong>Consistent deployment</strong>: All platforms get updates simultaneously when translations are published to the CDN</li><li><strong>Simple caching</strong>: CDN handles caching and global distribution automatically</li><li><strong>No runtime complexity</strong>: Applications don’t need special translation libraries or complex loading logic</li></ul><h3>Quality assurance and review process</h3><p>Rather than building complex validation rules, we took a pragmatic approach by leveraging our existing PR infrastructure. Every pull request in our workflow already triggers a preview environment deployment, so we simply piggyback on this existing process for translation quality assurance.</p><p>When our translation bot updates a PR with new translations, the standard preview deployment kicks in automatically. This gives stakeholders — product managers, designers, and other team members — the ability to access the deployed test pages and review translations in their actual context.</p><p>This approach catches the issues that matter most:</p><ul><li><strong>UI overflow</strong>: Stakeholders can immediately see if translated strings break layouts or overflow containers</li><li><strong>Contextual accuracy</strong>: Translations are reviewed in the actual user interface where they’ll appear</li><li><strong>Cultural appropriateness</strong>: Team members can spot translations that might be technically correct but culturally awkward</li><li><strong>Consistency</strong>: Reviewers can check that translations align with the overall product voice and existing terminology</li></ul><h3>Model selection and performance optimization</h3><p>When choosing LLMs for translation, we discovered that you don’t always need the most expensive, flagship models. While premium models like GPT-4.1 or Claude 4 offer exceptional quality, we found that general all-rounder models with fast inference speeds are often sufficient for typical application translations.</p><p>Our current go-to model is <strong>Gemini 2.0 Flash</strong>, which strikes an excellent balance between translation quality, speed, and cost. For most UI strings, button labels, and standard application text, the difference in quality between premium models and fast general-purpose models is negligible, but the difference in speed and cost is substantial.</p><p>This approach has several benefits:</p><ol><li><strong>Cost efficiency</strong>: Fast models are typically 5–10x cheaper per token</li><li><strong>Speed optimization</strong>: Sub-second response times keep the workflow snappy</li><li><strong>Quality sufficiency</strong>: For 90% of application text, the quality difference is minimal</li><li><strong>Scalability</strong>: Lower costs and faster responses mean we can translate more content without budget constraints</li></ol><h3>Results and conclusion</h3><p>After almost a year of running this AI-powered translation system in production, the results have been transformative:</p><ul><li><strong>&gt;90% reduction</strong> in translation-related SaaS costs</li><li><strong>Translation time from days to minutes</strong>: The actual translation process is now completed in minutes, with the full end-to-end process including review taking at most a day</li><li><strong>95% first-pass acceptance</strong> rate from stakeholders</li><li><strong>Zero translation debt</strong>: All new features ship with complete translations</li><li><strong>Seamless developer integration</strong>: No friction in the development workflow</li></ul><p>The key insight was that AI translations, when provided with proper context and integrated into the right workflow, can match or exceed traditional translation processes for most application text. By automating the entire pipeline, we’ve eliminated translation bottlenecks and significantly improved our development velocity.</p><h3>Future enhancements</h3><p>As we continue to evolve our translation system, we’re exploring several enhancements to improve consistency and reduce costs:</p><p><strong>Translation memory and historical awareness</strong>: Building a system where the AI can remember previous translations and reference past translation decisions to maintain consistency across similar phrases. This would help ensure that terms like “dashboard,” “settings,” or product-specific terminology are translated consistently throughout the application while learning from approved translations to maintain the established tone and terminology choices.</p><p><strong>Prompt caching optimization</strong>: Leveraging AI providers’ prompt caching features to reduce costs and improve response times. By caching the context and instructions portion of our prompts, we can significantly reduce token usage for repeated translation requests.</p><p>These enhancements would further improve both the consistency and cost-effectiveness of our translation pipeline while maintaining the speed and developer experience we’ve achieved.</p><p>The future of i18n is AI-powered, developer-integrated, and friction-free.</p><p><em>Interested in how we apply AI across other areas of our company? Check out our post on </em><a href="https://medium.com/fsmk-engineering/scaling-customer-outreach-with-conversational-ai-0e3ec7d3136f"><em>Scaling Customer Outreach with Conversational AI</em></a><em> or reach out to our engineering team for more insights.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e14219588cb5" width="1" height="1" alt=""><hr><p><a href="https://medium.com/fsmk-engineering/from-days-to-minutes-how-we-revolutionized-our-i18n-workflow-with-ai-and-github-actions-e14219588cb5">From days to minutes: How we revolutionized our i18n workflow with AI and Github Actions</a> was originally published in <a href="https://medium.com/fsmk-engineering">Technology @ Funding Societies | Modalku</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Scaling customer outreach with Conversational AI]]></title>
            <link>https://medium.com/fsmk-engineering/scaling-customer-outreach-with-conversational-ai-0e3ec7d3136f?source=rss----95882711d047---4</link>
            <guid isPermaLink="false">https://medium.com/p/0e3ec7d3136f</guid>
            <category><![CDATA[self-service]]></category>
            <category><![CDATA[customer-engagement]]></category>
            <category><![CDATA[customer-service]]></category>
            <category><![CDATA[eleven-labs]]></category>
            <category><![CDATA[conversational-ai]]></category>
            <dc:creator><![CDATA[Debojyoti Chakraborty]]></dc:creator>
            <pubDate>Thu, 05 Jun 2025 04:15:23 GMT</pubDate>
            <atom:updated>2025-06-05T04:15:23.726Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jSabv4df0kHw_3h5ml8E-g.png" /></figure><p>Imagine making 1,000+ customer calls daily without hiring an army of agents. That’s exactly what we are accomplishing at Funding Societies.</p><p>In today’s fast-paced financial services world, the companies that grow aren’t necessarily those with the best products — they’re the ones that can reach the most customers efficiently.</p><p>Enter <strong>conversational AI</strong>, it revolutionised Funding Societies (FS) customer outreach by implementing an AI-powered calling system (conversational AI) using <strong>ElevenLabs technology</strong>. Our digital agents now handle thousands of conversations across Singapore and Malaysia daily, delivering consistent, high-quality interactions while dramatically reducing operational costs.</p><h3>Why Funding Societies chose ElevenLabs</h3><p>After evaluating multiple conversational AI platforms, we selected ElevenLabs based on several critical factors:</p><h4>1. Cost Structure and self-serve simplicity</h4><p>ElevenLabs offers a very competitive pay per minute model. We could make hundreds of calls for the price of a single human agent hour.</p><p>ElevenLabs provides a self-serve model with upgrade options as needed. For our development team, their comprehensive API documentation meant we could get up and running quickly without long onboarding cycles.</p><h4>2. Conversations that flow naturally</h4><p>One of the most critical factors in creating AI conversations that don’t feel robotic is response time. ElevenLabs demonstrated consistently low latency, with most questions being processed and answered within 1–2 seconds — comparable to human response times in professional conversations.</p><h4>4. Voices that sound like us</h4><p>The default voices available through ElevenLabs were impressive, but what really sold us was the custom voice cloning capability. With just 30 minutes to 2 hours of voice recording from our customer experience team members, followed by verification, we created authentic-sounding agents that perfectly represented our brand. The ElevenLabs control panel offers full transparency on calls made, with access control and collaboration features.</p><h3>Under the hood: our technical architecture</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/641/1*NxpFZ-bXGqk2rAArUsC5zw.png" /></figure><p>At the top sits our <strong>Client Layer</strong> — our low-code internal dashboard that gives business team a simple interface to pull contact lists from our CRM tools and monitor results. We chose Appsmith for its flexibility and low-code approach, which allowed us to iterate quickly as we learned what metrics mattered most.</p><p>The heart of our system is the <strong>Application Layer</strong> where our application server (AI agent backend) orchestrates everything. This central coordinator handles the complex task of routing audio streams, managing call state, and handling call termination.</p><p>For the <strong>Service Layer</strong>, we integrated two providers: ElevenLabs for conversational AI and Twilio for telephony.</p><p>Finally, our <strong>Data Layer</strong> uses DynamoDB to track everything from call status to conversation analysis. We chose DynamoDB for its scalability and consistent performance.</p><p>To tie it all together, we implemented scheduler services using AWS Lambda functions that periodically check for contacts ready to be called and trigger the appropriate workflows also ensuring we process in batches so that system load can be managed.</p><p>Each layer has a clear responsibility, making the system both maintainable and extensible as our needs evolve.</p><h3>How the magic happens: Technical Workflow</h3><h4>Setting up our Digital Team members</h4><p>First, we configured our conversational AI agents in ElevenLabs. We wanted these agents to have personalities, to understand our products, and to handle complex conversations.</p><p>We recorded over 2 hours of audio from our customer experience team members and used this to clone professional voices. We then carefully crafted knowledge bases and system prompts to guide AI responses in a way that felt natural and authentic.</p><p>We spent considerable time fine-tuning for the optimal conversation experience, adjusting speed, tone, and other elements until they sounded just right.</p><blockquote><strong>We ensured that we clone voice of our customer service agents so that when we do the transition from AI to human agent, user does not feel any difference and good user experience is maintained.</strong></blockquote><h4>From Contact List to Conversation</h4><p>When it’s time to make calls, system pull contact list from CRM tools into our database. A scheduling system automatically queues and initiates calls. We segregate the calls in batches to protect our system, by capping the number of web-sockets loaded at one point in time.</p><p>The technical workflow establishes two WebSocket connections — one between our application server (AI agent backend) and Twilio, and another between our application server and ElevenLabs. These real-time connections enable seamless audio streaming between all components. Each call receives a unique identifier for tracking outcomes and performance metrics.</p><h4>The call experience</h4><p>When user answers, several things happen almost simultaneously:</p><ul><li><strong>An initial greeting plays from Twilio assets, eliminating perceived latency</strong></li><li>Audio from the call recipient is forwarded to ElevenLabs for processing</li><li>The Elevenlabs AI agent analyzes the audio, does internal processing and then generates appropriate responses</li><li>Response audio streams back through our application server to Twilio</li><li>Calling agent handles interruptions, errors, and maintains natural conversation flow</li></ul><h4>After the Call ends</h4><p>The system’s work isn’t done when the call ends:</p><ol><li>We ensure WebSocket connections close gracefully</li><li>Call status updates in our database</li><li>ElevenLabs AI evaluates the conversation and provides a summary of the interaction</li><li>While ElevenLabs offers conversation summaries, we found these summaries focus more on general conversation mechanics rather than our specific business needs. To address this gap, we implemented a separate call analysis process using LLM models with custom prompts tailored to our business case.</li><li>This additional analysis layer processes the call transcripts and accurately maps conversations to our specific analysis criteria, giving us more actionable business insights.</li><li>Results from both analyses are stored and notifications triggered based on outcomes</li></ol><blockquote><strong>For cold calling when our system identifies an “interested” prospect, it instantly sends a WhatsApp message with a product application link while simultaneously notifying our CX team for prompt follow-up. This seamless handoff ensures we capitalise on every opportunity.</strong></blockquote><h3>Overcoming Real-World challenges</h3><p>No implementation is without challenges. Here are three key obstacles we faced and how we solved them:</p><h4>Challenge #1: The Awkward Silence Problem</h4><p><strong>Issue</strong>: Initially, we experienced a 3–4 second latency from call connection to the agent’s first response. That might not sound like much, but in conversation terms, it’s an eternity — creating an awkward silence that immediately signalled “this is a robot calling”. We adopted the following solution to reduce the latency.</p><ol><li><strong>Pre-warming the signed URL call</strong>: We separated call creation and initiation steps. During call creation, we pre-emptively retrieve the signed URL for that agent, reducing latency when the actual call happens.</li><li><strong>Default greeting message</strong>: We added a default greeting delivered through Twilio using the same voice sample used throughout the call. This eliminated initial silence while the AI agent prepared its first response.</li></ol><p>These optimisations reduced our initial latency to less than 1 second, creating a much more natural call experience that doesn’t immediately trigger suspicion.</p><h4>Challenge #2: Voicemail Handling</h4><p><strong>Issue</strong>: Some calls were connecting to voicemail systems, which confused our AI agents.</p><p><strong>Solution</strong>: We implemented a detection system that examines the termination_reason field for each call. When the system detects “Ending conversation after {second_count} seconds of silence” in elevenlabs call details we tag the call as voicemail. These numbers are then flagged for human agent to follow-up.</p><h4>Challenge #3: who Hung Up first?</h4><p><strong>Issue</strong>: For analysis purposes, we needed to determine whether calls were ended by the AI agent or by the call recipient.</p><p><strong>Solution</strong>: We implemented a dual-check system:</p><ul><li>If we receive a “stop event” first from Twilio and our internal data shows <em>call_terminated_by</em> field as empty, we confirm the call was terminated by the recipient.</li><li>If we receive a ConnectionClosedOK exception from the websocket before Twilio sends the “stop event”, we record that the call was terminated by the AI agent.</li></ul><p>This distinction helps us better analyse call outcomes and continuously refine our conversation flows.</p><h3>Areas to Improve</h3><p>While our conversational AI implementation has been transformative, we’ve identified several areas for improvement:</p><p><strong>Background noise challenges</strong> In many real call scenarios, there’s significant background noise. Unlike human agents, AI calling agents like ElevenLabs cannot easily differentiate between background noise (people talking nearby) versus actual user conversation. In these cases, the agent often responds incorrectly, and the conversation becomes unproductive.</p><blockquote><strong>Very important note — Ensure your AI calling agent has a maximum end call time. This is critical because sometimes background noise can trick the AI into thinking the user is talking when they’ve actually left the phone unattended without hanging up. Without this safeguard, the agent continues the call, wasting valuable call credits with no meaningful conversation occurring.</strong></blockquote><p><strong>Mumbling voice detection</strong> In some calls with unclear or mumbling voices, the agent struggles to capture user speech clearly. This limits the effectiveness of our system with certain demographics and in less-than-ideal calling conditions.</p><h3>The Results: Transforming our business</h3><p>The numbers tell a compelling story of transformation:</p><ul><li><strong>Increased Scale</strong>: We’re now close to making 1000+ calls daily across regions — far exceeding our previous manual capacity and this is just the start.</li><li><strong>Improved Efficiency</strong>: Our system automatically categorises leads and triggers appropriate follow-up actions, streamlining our sales process</li><li><strong>Better Customer Experience</strong>: The professionally cloned voices and natural conversation flow create a positive impression with potential customers</li><li><strong>Data-Driven Insights</strong>: The detailed call reports and analytics have given us unprecedented visibility into our outreach effectiveness. We crunch call transcript data to derive customer insights.</li></ul><p>But perhaps the most telling result isn’t in the numbers — it’s in the quality of the conversations. Our AI agents are consistently delivering interactions that feel genuine, professional, and helpful.</p><blockquote>The AI agents aren’t replacing our human team — they’re strategically enhancing our outreach process. <strong>By handling initial qualification calls at scale, they allow our specialists to invest their expertise exclusively in meaningful conversations with prospects who have already expressed genuine interest.</strong> This creates a perfect partnership: AI efficiently identifies opportunities, while our human experts deliver the personalised guidance these qualified prospects deserve.</blockquote><h3>Beyond the technology: Lessons Learned</h3><p>Implementing this system taught us valuable lessons that extend beyond the technical details:</p><ol><li><strong>Iteration is essential</strong>: Our first implementation wasn’t perfect. We continuously gather feedback, analyse calls, and make improvements. We are still working on how to seamlessly handle conversations in multiple language in the same call.</li><li><strong>Transparency matters</strong>: We’re always clear with customers that they’re speaking with an AI assistant. Trust is paramount in financial services.</li><li><strong>The hybrid approach works best</strong>: AI handles initial outreach, but human specialists manage relationship development. This combination delivers the best of both worlds.</li></ol><h3>What’s next? The future of Conversational AI</h3><p>We’re just scratching the surface of what’s possible. Our future roadmap includes:</p><ul><li>Expanding to additional languages to serve more markets</li><li>Implementing more sophisticated intent recognition</li><li>Add more business cases to be empowered by AI calling</li></ul><h3>Conclusion: The new frontier of Customer Outreach</h3><p>Our implementation of conversational AI using ElevenLabs technology has fundamentally changed how we think about customer outreach at Funding Societies. What began as an experiment has become a core component of our growth strategy.</p><blockquote>The combination of professional voice cloning, low-latency responses, and automatic follow-up mechanisms has enabled us to significantly expand our market reach while optimising operational costs.</blockquote><p>By addressing key technical challenges and optimising for natural conversation flow, we’ve created a system that efficiently scales our lead generation while maintaining a personal touch.</p><h3>AI Initiatives at Funding Societies</h3><p>At Funding Societies, our Engineering team actively explores practical applications of technology to build AI powered lending automation. We focus on developing AI solutions that address real business challenges while keeping pace with industry developments.</p><p>To learn more about our AI initiatives, explore our engineering blog where we share insights on building our loan application chatbot Shane and other innovative solutions related to democratization of AI:</p><ul><li><a href="https://medium.com/fsmk-engineering/how-we-built-our-first-loan-application-chatbot-using-llms-part-1-a1913ee40c01">How we built our first loan application chatbot using LLMs (Part 1)</a></li><li><a href="https://medium.com/fsmk-engineering/how-we-built-our-first-loan-application-chatbot-using-llms-part-2-eb2419341acc">How we built our first loan application chatbot using LLMs (Part 2)</a></li><li><a href="https://medium.com/fsmk-engineering/democratization-of-ai-d8685192d606">Democratization of AI</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0e3ec7d3136f" width="1" height="1" alt=""><hr><p><a href="https://medium.com/fsmk-engineering/scaling-customer-outreach-with-conversational-ai-0e3ec7d3136f">Scaling customer outreach with Conversational AI</a> was originally published in <a href="https://medium.com/fsmk-engineering">Technology @ Funding Societies | Modalku</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Democratization of AI]]></title>
            <link>https://medium.com/fsmk-engineering/democratization-of-ai-d8685192d606?source=rss----95882711d047---4</link>
            <guid isPermaLink="false">https://medium.com/p/d8685192d606</guid>
            <category><![CDATA[activepieces]]></category>
            <category><![CDATA[ai-prompts]]></category>
            <category><![CDATA[ai-workflow]]></category>
            <category><![CDATA[transformation]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[Shawn Lim]]></dc:creator>
            <pubDate>Mon, 14 Apr 2025 07:32:03 GMT</pubDate>
            <atom:updated>2025-04-14T07:32:03.758Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*H73lQ0n9CWxlLIreRuI3Bg.png" /></figure><h3>1. Background on our AI journey</h3><p>Over a year ago, we shared <a href="https://medium.com/fsmk-engineering/how-we-built-our-first-loan-application-chatbot-using-llms-part-1-a1913ee40c01">how we built our first loan application chatbot using LLMs</a> — a project that proved highly successful but highlighted a key challenge: scaling AI implementation required more engineers to build custom AI systems.</p><p>This created a bottleneck. While we had proven AI’s value in our fintech operations, we needed a way to extend these benefits throughout the organization, particularly to streamline the numerous tedious back-office workflows that are inherent to financial services. The traditional approach of building custom AI agents worked well for customer-facing applications, but wasn’t sustainable for addressing the hundreds of internal processes that could benefit from automation.</p><h3>2. Our search for a balanced solution</h3><p>We needed a solution that could meet several critical requirements:</p><ul><li><strong>Technical flexibility</strong> for developers who wanted to build complex integrations</li><li><strong>Business user friendliness</strong> so non-technical teams could create their own workflows</li><li><strong>Compliance readiness</strong> to meet the stringent requirements of financial services</li><li><strong>Strong AI integrations</strong> to leverage cutting-edge language models and other AI tools</li></ul><p>After evaluating multiple platforms, we discovered Activepieces, which offered the combination of technical depth and accessibility we were looking for. Its low-code interface made it approachable for business users, while its extensibility satisfied our technical teams. Most importantly, it allowed us to integrate various AI capabilities directly into our business processes without requiring custom development for each use case.</p><h3>3. From concept to implementation</h3><p>Once we began implementing our chosen platform, we first focused on setting up the infrastructure and necessary connections. After this foundation was in place, teams across our organization quickly identified processes ripe for automation. Here are some of the most impactful categories of flows we’ve created:</p><h4>AI-Driven document review for payments submission</h4><p>We implemented an AI-driven document review system that leverages OCR and LLM technologies to validate payment-related documents. The workflow triggers when a new payment is created, extracts key data using OCR, validates authenticity using LLM to detect official logos, invoice structures, and performs <strong>fuzzy matching to compare extracted details against expected payment data</strong>.</p><p>What makes this flow particularly valuable is its ability to provide <strong>real-time feedback to team members, with manual fallback options for edge cases</strong>. This thoughtful design ensures that automation enhances rather than replaces human judgment for critical financial processes. Additionally, the system <strong>scales naturally with transaction volume</strong>, allowing us to handle exponential growth without proportionally increasing headcount.</p><p>This automation has eliminated thousands of manual review hours yearly, achieved faster approvals with growing payment volumes, and significantly enhanced the customer experience through faster processing times.</p><h4>Smart document generation</h4><p>Teams automated the generation of critical business documents that are essential to our financial processes. Previously, sales teams had to manually generate and complete these forms for clients using various repayment methods.</p><p>The workflow now <strong>intelligently pulls relevant data from our systems, pre-populates required fields</strong>, and generates properly formatted documents ready for client review. This eliminates the time-consuming process of manually creating each document and <strong>drastically reduces the potential for human error</strong> in document preparation.</p><p>The results have been impressive: enhanced client experience by ensuring all required documents are prepared before disbursement, significantly reduced turnaround time for document preparation, and markedly improved accuracy rate. Perhaps most importantly, the automation <strong>allows our sales team to focus on higher-value client interactions</strong> rather than administrative paperwork.</p><h4>Customer insights from conversation data</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Z04SFimuKvNaFlB_h-qKFA.png" /></figure><p>Product design teams implemented flows that automatically generate monthly customer insights by analyzing conversation data from Intercom. This process, which previously <strong>took 1–3 weeks of manual work, is now instantaneous</strong>.</p><p>The workflow connects to our customer communication platforms, extracts relevant conversations, and uses <strong>natural language processing to identify common themes, pain points, and feature requests</strong>. It then compiles these insights into comprehensive reports that inform product development decisions.</p><p>This automation has transformed how we approach customer feedback. Traditional surveys typically captured only a small percentage of user sentiment, and manual analysis of conversations was too time-consuming to perform regularly. Now, we <strong>receive rich customer insights monthly without burdening our CX or engineering teams</strong>. The result is a more responsive product development cycle that better addresses actual user needs rather than assumptions.</p><h4>Intelligent support triage</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7xSoJ4R1IvpOZ4OZesJngQ.png" /></figure><p>Support operations have been transformed through automation that uses Retrieval-Augmented Generation (RAG) to automatically triage and route support requests to the right squads.</p><p>The core innovation here is how we’ve implemented RAG: all past production support requests are stored in a <strong>vector database, creating a knowledge repository that grows more intelligent with each resolved ticket</strong>. When new requests arrive, the system automatically analyzes the content, compares it to historical patterns, and determines the optimal squad assignment based on expertise, capacity, and resolution patterns.</p><p>This provides <strong>instant triage 24/7</strong> (including after hours and holidays), frees engineers from manual triaging, and handles unlimited query volume without additional human effort. Most impressively, the <strong>system’s routing accuracy continually improves through automated learning</strong> from resolved tickets, creating a virtuous cycle of increasing efficiency. The result has been faster issue detection and resolution, with the right experts being pulled in immediately.</p><h4>Content production automation</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LgKD-BOb3Mvl0lkgbTAskQ.png" /></figure><p>Content teams created integrated AI workflows that enhance and repurpose top-performing articles for targeted keywords. This was one of our most sophisticated implementations, as it required <strong>seamless integration between multiple AI platforms to create a cohesive content production pipeline</strong>.</p><p>The workflow begins by analyzing search performance data to identify high-potential content opportunities. It then retrieves and analyzes top-performing articles related to our target keywords, extracting the core concepts and structures that make them successful. Using a combination of AI tools, the system then generates new content that maintains perfect alignment with our financial content guidelines for SME audiences while <strong>implementing strategic FAQ formatting to optimize for emerging AI search platforms</strong>.</p><p>The impact has been dramatic: <strong>content production timeframes have been slashed by 85%</strong> (from half-day projects to under 30 minutes), delivering significant cost savings per article. More importantly, the automated approach has <strong>boosted organic traffic metrics by 20–30%</strong> through consistent dual-optimization techniques, all while maintaining brand voice consistency across all content assets.</p><h3>4. Impact and conclusion</h3><p>Since launching the initiative in Q1, we’ve seen remarkable results that demonstrate the power of democratized AI. The high-level metrics tell a compelling story:</p><ul><li><strong>Over 100 automation flows</strong> deployed across our organization</li><li><strong>Saving teams almost a quarter of a year in time</strong> that would otherwise be spent on manual tasks</li><li><strong>Significant qualitative benefits</strong> including error reduction, improved communication, and reduced context switching</li></ul><p>Beyond the numbers, the most profound impact has been the shift in mindset across our organization. Teams that previously saw AI as the domain of specialized engineers now approach their workflows with an automation-first mentality.</p><p>The democratization of AI through low-code automation platforms isn’t just changing how work gets done — it’s transforming who can participate in the AI revolution. This shift is particularly valuable in fintech, where regulatory requirements and complex operational processes often create massive backlogs of manual work.</p><p>By empowering teams to build their own intelligent workflows, we’ve unlocked efficiency at a scale that would have been impossible with a centralized AI development approach. What began as a search for efficiency has evolved into a platform for innovation, proving that with the right tools, AI isn’t just for engineers — it’s for everyone.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d8685192d606" width="1" height="1" alt=""><hr><p><a href="https://medium.com/fsmk-engineering/democratization-of-ai-d8685192d606">Democratization of AI</a> was originally published in <a href="https://medium.com/fsmk-engineering">Technology @ Funding Societies | Modalku</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[“From Fixing IT Issues to Defending Against Threats”: My Journey into Enterprise Security]]></title>
            <link>https://medium.com/fsmk-engineering/from-fixing-it-issues-to-defending-against-threats-my-journey-into-enterprise-security-2b8db4292851?source=rss----95882711d047---4</link>
            <guid isPermaLink="false">https://medium.com/p/2b8db4292851</guid>
            <category><![CDATA[enterprise-security]]></category>
            <category><![CDATA[professional-development]]></category>
            <category><![CDATA[endpoint-security]]></category>
            <category><![CDATA[it-transformation]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <dc:creator><![CDATA[Sandi Oktarian]]></dc:creator>
            <pubDate>Fri, 17 Jan 2025 06:26:52 GMT</pubDate>
            <atom:updated>2025-01-17T06:26:51.974Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*QyZTaERQAMfrllnL" /></figure><p><strong>Background</strong></p><p>After spending over four years as an <em>IT Engineer</em>, I dedicated myself to ensuring smooth operations, resolving technical issues, and supporting users to maintain productivity. Each day brought new challenges, ranging from troubleshooting hardware failures to addressing network problems, which honed my ability to think quickly and prioritize effective solutions. Over time, I began to notice patterns — many of the issues stemmed from security gaps or insufficient safeguards. This realization sparked a growing interest in implementing proactive measures to prevent such problems. Fortunately, my current company, <em>Funding Societies | Modalku Group</em>, provided me the opportunity to transition into an <em>Enterprise security engineering</em> role, where my focus shifted from solving immediate issues to safeguarding systems and users against potential threats.</p><p><strong><em>“Balancing Speed, Security, and User Experience in a New Role”</em></strong></p><p>The transition wasn’t just about a title change — it was a complete shift in priorities and mindset. As an <em>IT engineer</em>, my focus was on minimizing downtime and ensuring user satisfaction. Speed was critical, and solutions often had to be immediate, even if they were temporary.</p><p>But as I started exploring the<em> field of security</em>, I realized that fast solutions could sometimes come at a cost. Temporary fixes might leave vulnerabilities exposed or fail to address the root cause of a problem. Security demanded a different approach — one that prioritized protecting data, systems, and users, even if it meant taking more time to implement a solution. My focus began to change, and so did my role.</p><p><strong>Lessons Learned During the Transition</strong></p><p>Switching from<em> IT engineering to enterprise security engineering wasn’t without its challenges</em>. Here are a few key lessons I’ve learned along the way:</p><p><strong>1. The Importance of a Security-First Mindset</strong></p><p>In IT, speed is often king, but in security, thoroughness and caution take precedence. I had to retrain my instincts to think about potential vulnerabilities, compliance, and long-term impact before jumping to solve a problem.</p><p><strong>2. Expanding Technical Knowledge</strong></p><p>Transitioning roles required me to broaden my skillset. I delved into topics like identity and <em>access management (IAM), threat detection, and incident response</em>. Learning to see the bigger picture of how IT and security intersect was both challenging and rewarding.</p><p><strong>3. Balancing User Experience with Security</strong></p><p>One of the hardest parts of the transition was finding ways to make systems secure without compromising the user experience. Security measures can sometimes feel like obstacles to end-users, so I’ve worked to implement solutions that strike a balance between safety and usability.</p><p><strong>4. Patience in Problem-Solving</strong></p><p>Security solutions often require more time and deliberation than IT fixes. I learned to embrace this patience, knowing that taking the time to implement a secure solution would pay off in the long run.</p><p><strong>5. A New Sense of Responsibility</strong></p><p>As an<em> IT engineer</em>, my focus was on the here and now — fixing issues as they arose. As a <em>Enterprise Security Engineer,</em> I’m now responsible for protecting the organization against threats that might not yet be visible. This shift has given me a deeper sense of responsibility and purpose in my work.</p><p><strong>Advice for IT Professionals Considering the Switch</strong></p><p>If you’re an IT professional thinking about transitioning into a security-focused role, here are a few tips based on my experience:</p><p><em>Cultivate a Security Mindset</em>: Start by thinking about security in your current role. How can you make your workflows more secure? How can you reduce risks while solving problems?</p><p><em>Learn Continuously:</em> Security is a vast and ever-evolving field. Invest time in learning new concepts, earning certifications, and staying updated on the latest trends and threats.</p><p><em>Be Patient:</em> Security Engineering often requires a slower, more methodical approach. Embrace this change and trust the process.</p><p><em>Collaborate with Security Teams:</em> If your organization has a dedicated security team, reach out to them. Learning from their expertise and understanding their challenges can provide valuable insights.</p><p><em>Balance Speed and Security:</em> While security is critical, it’s also important to keep the end-user in mind. Strive to implement solutions that are both safe and user-friendly.</p><p><strong>A New Chapter</strong></p><p>The journey from <em>IT engineer</em> to <em>Enterprise Security Engineer</em> has been one of the most rewarding transitions of my career. It’s taught me to look at problems through a different lens, to prioritize the bigger picture, and to embrace the responsibility of safeguarding users and systems.</p><p><strong><em>An exciting journey lies ahead, and I’m eager to continue working, learning, and growing alongside Funding Societies | Modalku Group for years to come.</em></strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2b8db4292851" width="1" height="1" alt=""><hr><p><a href="https://medium.com/fsmk-engineering/from-fixing-it-issues-to-defending-against-threats-my-journey-into-enterprise-security-2b8db4292851">“From Fixing IT Issues to Defending Against Threats”: My Journey into Enterprise Security</a> was originally published in <a href="https://medium.com/fsmk-engineering">Technology @ Funding Societies | Modalku</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Streamlining IAM Processes: Transitioning from Manual to Automated Efficiency]]></title>
            <link>https://medium.com/fsmk-engineering/streamlining-iam-processes-transitioning-from-manual-to-automated-efficiency-e2f2eb3b8a79?source=rss----95882711d047---4</link>
            <guid isPermaLink="false">https://medium.com/p/e2f2eb3b8a79</guid>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[enterprise-security]]></category>
            <category><![CDATA[automation]]></category>
            <category><![CDATA[it-operations]]></category>
            <category><![CDATA[identity-and-access]]></category>
            <dc:creator><![CDATA[Juliani Sarah]]></dc:creator>
            <pubDate>Fri, 17 Jan 2025 02:52:30 GMT</pubDate>
            <atom:updated>2025-01-17T02:52:30.004Z</atom:updated>
            <content:encoded><![CDATA[<p>Identity and Access Management (IAM) is used in IT operations to ensure suitable persons have timely access to resources. However, any IT professional will tell you that manually managing IAM tasks is daunting. This entails managing multiple duties, achieving rigorous deadlines, and ensuring an error-free environment. Automation has become necessary rather than elective, providing a path to more smooth IAM operations.</p><p><strong>Difficulties of Manual IAM Procedures</strong></p><p>1. Huge Task Volume</p><p>IAM management is more than just granting or revoking access. It entails sophisticated operations like as provisioning, deprovisioning, access evaluations, and role assignments. When these duties are managed manually, they can easily accumulate, causing IAM Engineer workers to get overloaded with messages, emails, and ticketing systems.</p><p>2. Operations that are time-critical and high-risk</p><p>Timing is key in IAM. Delays in granting access to new employees can interrupt their onboarding experience, while late de-provisioning might expose the organization to security risks. These obligations are both important and time-consuming, and mistakes can have major implications.</p><p>3. Unnoticed Success and Noticeable Failures.</p><p>Successful IAM operations frequently go unnoticed, yet even a single overlook can have serious consequences, such as compliance violations, security breaches, or dissatisfied users. Manual processes leave too much possibility for human mistakes, with IAM Engineers personnel frequently taking the blame.</p><p>4. Adjusting to Organisational Growth.</p><p>As businesses grow, managing IAM becomes increasingly difficult. Manual techniques become unsustainable as the number of employees, systems, responsibilities, and access requests increases. Without automation, the task becomes unmanageable, placing an unnecessary demand on IAM Engineer workers.</p><p><strong>The necessity of automation.</strong></p><p>Automation transforms IAM processes from a barrier to a streamlined, efficient system. By using tools and scripts for repetitive work, IT teams may maintain consistency, reduce errors, and devote more time to strategic projects. It’s about increasing accuracy, not simply speed.</p><p><strong>Our Journey to Automation</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*REoevCWklcKOhLmpfDiqdw.png" /></figure><p><strong>From Slack to Jira.</strong></p><p>Initially, access requests were manually processed using Slack channels. Employees would request access, and IAM engineers handled the process manually by:</p><ol><li>Logging into JumpCloud.</li><li>Locate the user’s profile.</li><li>Adding the user to the correct group.</li><li>Updating the requester on the status.</li></ol><p>With 50–60 tickets per week, this process took 5–7 minutes per ticket, totaling 5–7 hours weekly. The repetitious nature of these operations constituted a considerable bottleneck.</p><p>Transitioning to Jira improved monitoring and documentation, but granting and revoking access remained manual. Engineers still needed to:</p><ol><li>Open a Jira ticket.</li><li>Determine the requested access.</li><li>Log into JumpCloud.</li><li>Make the necessary access modifications.</li><li>Update the Jira ticket’s status.</li></ol><p><strong>Introducing the ITSM dashboard.</strong></p><p>Recognizing the value of automation, we created an internal ITSM dashboard to centralize and automate access management procedures. The dashboard connects with JumpCloud APIs, allowing for smooth automation.</p><p>This is how it works:</p><ul><li><strong>Mapping system names to group IDs</strong>: The dashboard associates system names in Jira with JumpCloud group IDs. For example, a Jira request for Cloudflare causes the dashboard to fetch the associated Cloudflare user group ID from JumpCloud.</li><li><strong>Automated Access Granting/Revoking</strong>: Once a Jira issue has been authorized by the Line Manager and System Owner, the dashboard uses the JumpCloud API to add/remove the user to/from the appropriate group.</li><li><strong>Real-time updates</strong>: When access is granted/revoked successfully, the automated add a remark to the Jira ticket confirming the action taken.</li></ul><p><strong>Leveraging the JumpCloud API for Line Manager Integration</strong></p><p>We use internal automation to retrieve Line Manager details for Jira tickets, leveraging the JumpCloud API for this. The API allows for more accurate and streamlined integration, improving the whole workflow.</p><p><strong>Expanding Automation to Internal Tools.</strong></p><p>Beyond JumpCloud, we’ve extended Jira automation to handle user provisioning and de-provisioning for internal tools. The process now includes:</p><ol><li>Reading Jira tickets to determine requested roles.</li><li>Searching for team members using the internal tool.</li><li>Assigning or revoking roles as defined.</li><li>Updating the Jira ticket with the status.</li></ol><p>This eliminates the need for manual role assignment, hence increasing efficiency.</p><p><strong>Scalability using SAML 2.0</strong></p><p>We’ve integrated all systems that support SAML 2.0 with JumpCloud. This guarantees that IAM processes are consistent and scalable throughout the enterprise, simplifying access control for both internal and external tools.</p><p><strong>Key Takeaways</strong></p><p>Our transition from manual IAM operations to automation reveals numerous significant benefits:</p><ul><li><strong>Enhanced Precision</strong>: Reduced human error in critical operations.</li><li><strong>Time Efficiency</strong>: Automation saves hours of manual labor, allowing engineers to focus on critical projects.</li><li><strong>Improved security</strong> through timely access revocation and policy compliance.</li><li><strong>Scalability</strong>: The unified ITSM dashboard and JumpCloud connection ensure that the organization can scale as it grows.</li><li><strong>Better User Experience</strong>: Employees receive faster responses to access requests, which increases satisfaction.</li></ul><p><strong>Conclusion</strong></p><p>Having worked with IAM management personally, I appreciate the difficulties of doing everything manually. Transitioning to automated IAM workflows has improved our operations’ efficiency, scalability, and reliability. We built a strong system that satisfies the needs of a growing firm using Jira, JumpCloud, Slack, and our ITSM dashboard.</p><p>Consider starting with simple automated measures if your organization still uses manual IAM operations. As our experience has demonstrated, the time and effort saved are well worth the investment.</p><p>Automation is more than just convenience; it’s also about improving performance.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e2f2eb3b8a79" width="1" height="1" alt=""><hr><p><a href="https://medium.com/fsmk-engineering/streamlining-iam-processes-transitioning-from-manual-to-automated-efficiency-e2f2eb3b8a79">Streamlining IAM Processes: Transitioning from Manual to Automated Efficiency</a> was originally published in <a href="https://medium.com/fsmk-engineering">Technology @ Funding Societies | Modalku</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>