<?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[Stories by Prathamesh Mane on Medium]]></title>
        <description><![CDATA[Stories by Prathamesh Mane on Medium]]></description>
        <link>https://medium.com/@im-pratham?source=rss-91da0a5c7c31------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*nUByf-mvzZMg0uYkHOu9iA.jpeg</url>
            <title>Stories by Prathamesh Mane on Medium</title>
            <link>https://medium.com/@im-pratham?source=rss-91da0a5c7c31------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 08:56:22 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@im-pratham/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Building Agentic Systems: A Thought Process for AI Orchestration with Flowable]]></title>
            <link>https://im-pratham.medium.com/building-agentic-systems-a-thought-process-for-ai-orchestration-with-flowable-e532b8c80f2c?source=rss-91da0a5c7c31------2</link>
            <guid isPermaLink="false">https://medium.com/p/e532b8c80f2c</guid>
            <category><![CDATA[enterprise-ai]]></category>
            <category><![CDATA[agentic-ai]]></category>
            <category><![CDATA[design-patterns]]></category>
            <category><![CDATA[agentic-workflow]]></category>
            <category><![CDATA[flowable]]></category>
            <dc:creator><![CDATA[Prathamesh Mane]]></dc:creator>
            <pubDate>Wed, 03 Dec 2025 10:25:12 GMT</pubDate>
            <atom:updated>2025-12-03T10:25:12.451Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="Photo by Pixabay from Pexels: https://www.pexels.com/photo/low-section-of-man-against-sky-247851/" src="https://cdn-images-1.medium.com/max/1024/1*rr7dFrAQpWVQHkyRSN8x7w.jpeg" /></figure><p>The AI landscape has evolved rapidly from simple chatbots to autonomous agents, and now to coordinated agentic systems. But here’s what most discussions miss: before diving into frameworks and tools, you need a mental model for orchestration. The purpose of this article isn’t to overwhelm you with technical details, but to share a thought process — a way of thinking about complex automation that will outlast any specific technology. As I always like to do, let’s start diving deeper with a use case.</p><h3>The Orchestration Challenge</h3><p>Before jumping into implementation, let’s understand <em>“why orchestration matters”</em>. An AI agents, no matter how capable, face fundamental limitations in enterprise contexts:</p><ul><li><strong>Scope constraints</strong>: Each agent specializes in one task, document extraction, web search, or data analysis.</li><li><strong>Context management</strong>: Passing information between isolated agents requires manual coordination or a specialized handling.</li><li><strong>Governance gaps</strong>: Without orchestration, tracking decisions and ensuring compliance becomes impossible.</li><li><strong>Failure handling</strong>: Individual agent failures can cascade without proper coordination.</li><li><strong>Manual Failover: </strong>What happens when agent cannot decide path forward midway? How a human can take over the control from swarm of agents?</li><li><strong>Human In the Loop: </strong>Reviews or getting confirmation from user before proceeding further.</li></ul><blockquote>Enterprise workflows require more than capable agents — they need a orchestrator to coordinate them.</blockquote><h3><strong>Start With the Human Process</strong></h3><p>Let’s assume we’re building a platform to help recruiters quickly match and shortlist candidates for interviews. The problem statement is straightforward: “From a stack of hundreds of submitted CVs, identify the best 10 candidates to shortlist for the first round of interviews.”</p><p>Here’s the critical first step that most people skip: <strong>Don’t jump to AI solutions. Watch how humans solve this today.</strong></p><p>A recruiter doesn’t follow a rigid checklist. Based on the job description, they build a mental framework:</p><ol><li>Candidate must be domiciled in XXX region</li><li>Candidate must have prior work experience in a particular industry (e.g. finance)</li><li>Having specific certifications is a bonus</li><li>And so on…</li></ol><p>But here’s what makes this interesting — the order is flexible. A recruiter might:</p><ul><li>Start by checking location</li><li>Or jump straight to company experience</li><li>Or look for certifications first</li><li>Or even ask the candidate directly about something unclear</li></ul><p>As you map this thought process, it looks something like the diagram below.</p><figure><img alt="A diagrammatic planning board showing a recruiter’s flowchart for screening a candidate’s CV. The flowchart includes decision points and tasks organized on sticky notes, such as verifying the candidate’s location in Europe, checking past employers and their industry, assessing specializations, and noting automated skill checks." src="https://cdn-images-1.medium.com/max/1024/1*Zss0pqDaIlDwwl_PdlHIXA.png" /><figcaption>Image 1: Planning board showing recruiter’s decision flow</figcaption></figure><p>The recruiter can choose any step in whatever order makes sense. As they work, they accumulate information, sometimes in a checklist, sometimes mentally, and make decisions: shortlist now, review later, or discard.</p><p>This is <strong>knowledge work</strong>: flexible, judgment-based, and non-linear.</p><h3>The Orchestration Mindset</h3><p>Now let’s think about automation differently. Most people ask: <em>“What can AI do?”</em></p><p>Instead, ask: <strong>“What does the knowledge worker do, and which parts need human judgment vs. automation?”</strong></p><p>Let’s break down the recruiter’s process:</p><p><strong>Tasks that are repetitive and rule-based:</strong></p><ul><li>Extracting candidate name, location, job history from CV</li><li>Checking if location matches requirement</li><li>Listing previous companies</li></ul><p><strong>Tasks that require knowledge lookup:</strong></p><ul><li>What industry does this company operate in?</li><li>Is this certification relevant to the role?</li></ul><p><strong>Tasks that require judgment:</strong></p><ul><li>Does this experience truly match our needs?</li><li>Should we shortlist this candidate?</li></ul><p>Now here’s the insight: <strong>You’re not replacing the humans. You’re giving them AI co-workers.</strong></p><p>With LLMs powerful enough to extract and summarize information, we can automate the repetitive work. When a CV arrives:</p><ul><li>An AI agent extracts structured data (name, companies, dates, certifications)</li><li>Another agent tries to identify the company’s business domain</li><li>If the agent doesn’t know, it uses a tool (knowledge base or web search)</li><li>The human reviews the compiled information and makes decisions</li></ul><p>Our planning board now evolves to include automation capabilities:</p><figure><img alt="A diagrammatic planning board showing a recruiter’s hybrid process for screening a candidate’s CV. The flowchart includes sticky notes detailing decision points and tasks, such as verifying the candidate’s location in Europe, checking past employers and their industry, and performing automated skill checks. A legends box clarifies the roles of human recruiters (Human in the Loop), AI agents, and tools within the workflow." src="https://cdn-images-1.medium.com/max/1024/1*Mi4T9ZZrZT9RhHLI1mZtVQ.png" /><figcaption>Image 2: Planning board with AI agents, tools, and human-in-the-loop markers</figcaption></figure><p>Notice the distinction:</p><ul><li><strong>AI Agents</strong> (🤖): Handle extraction, classification, lookup</li><li><strong>Tools</strong> (⚙️): Provide capabilities like web search</li><li><strong>Human-in-the-loop</strong> (☑️): Make judgment calls</li></ul><blockquote>You’re not building an “AI system.” You’re orchestrating knowledge workers: some human, some AI, toward a shared goal.</blockquote><h3>From Thought Process to Implementation</h3><p>Now it’s time to introduce Flowable into the picture — not as a tool, but as a way to formalize your thought process.</p><p>Remember our observation, recruiters perform <strong>knowledge work</strong> where task order isn’t predetermined. Workers (human or AI) have autonomy in their approach, context accumulates as work progresses, and multiple paths are possible.</p><p>This is exactly what Case Management Model and Notation (CMMN) does best. Not rigid workflows, but flexible coordination. <strong>Your planning board becomes your case model.</strong> Each sticky note becomes a plan item. Each decision point becomes a milestone. Each “check if needed” becomes a conditional activation.</p><figure><img alt="The screenshot shows the Case Plan Model with the orchestrator agent (“Interview Application Orchestrator Agent”)" src="https://cdn-images-1.medium.com/max/906/1*FQrMEMSOHygbBbnZp6BdHg.png" /><figcaption>Image 3: Orchestrator Agent — Assignment to Case</figcaption></figure><h3><strong>The Orchestrator as Conductor</strong></h3><p>Think of the orchestrator agent like a conductor in an orchestra. The conductor:</p><ul><li>Knows all the musicians available <em>(your agents and tools)</em></li><li>Observes what’s been played so far <em>(case context)</em></li><li>Decides who plays next and when <em>(activates plan items)</em></li><li>Responds to how the performance is going <em>(adapts based on results)</em></li></ul><p>The orchestrator doesn’t play instruments — it coordinates those who do.</p><figure><img alt="A male conductor in a formal military uniform is leading an orchestra with a baton during a live performance. An audience is visible in the blurred background." src="https://cdn-images-1.medium.com/max/728/0*s9HN8U5rfcJukhbX.jpg" /><figcaption>Image 4: Orchestrator</figcaption></figure><h3><strong>Empowering the Orchestrator</strong></h3><p>The orchestrator needs three things to be effective:</p><h4><strong>1. Workers (Agents)</strong></h4><p>Your orchestrator needs a team. In our case:</p><p><strong>Document Agent — </strong>Processes CVs and extracts structured information</p><figure><img alt="Document agent configuration under Flowable’s “Orchestrator Agent”" src="https://cdn-images-1.medium.com/max/1024/1*0wu2nF_1hLz9wmqpN1WlBg.png" /><figcaption>Image 5: Flowable Document Agent in Orchestrator</figcaption></figure><p>Think of this as your data entry specialist. Upload a CV, get back structured fields: name, companies, roles, certifications. This agent doesn’t make decisions, it just organizes information.</p><p>Example of the structured output:</p><pre>{<br>  &quot;candidateName&quot;: &quot;Prathamesh Mane&quot;,<br>  &quot;email&quot;: &quot;prathameshmane@mywebsite.com&quot;,<br>  &quot;location&quot;: &quot;Not explicitly stated - requires verification&quot;,<br>  &quot;positions&quot;: [<br>    {<br>      &quot;company&quot;: &quot;Flowable&quot;,<br>      &quot;title&quot;: &quot;Solution Architect&quot;,<br>      &quot;duration&quot;: &quot;Apr 2020 - Present&quot;<br>    }<br>  ],<br>  &quot;certifications&quot;: [<br>    &quot;Flowable Developer Certification&quot;,<br>    &quot;Flowable Business Process Certification&quot;<br>  ]<br>}</pre><p>Within Flowable you can see all the extracted data as part of document metadata</p><figure><img alt="Image shows document extracted from the candidate’s CV" src="https://cdn-images-1.medium.com/max/1024/1*K7tFKpcxIU-LI3-_XhisHw.jpeg" /><figcaption>Image 6: Document Agent Extraction Result</figcaption></figure><h4><strong>2. Knowledge Base</strong></h4><p>Your orchestrator should have access to what it needs to know. This might be,</p><ul><li>A knowledge base mapping companies to industries</li><li>Historical data about successful candidates</li><li>Job requirement specifications</li></ul><figure><img alt="Knowledge Base configuration under Flowable’s “Orchestrator Agent”" src="https://cdn-images-1.medium.com/max/1024/1*S_Jib174BkcDdgUyLOiykQ.png" /><figcaption>Image 7: Knowledge Base</figcaption></figure><blockquote>What would a human expert consult? Give the orchestrator the same kind of resources.</blockquote><h4><strong>3. Decision Guidelines</strong></h4><p>This is where it gets interesting. How does the orchestrator know when to invoke which agent? To do this, you can mark any Flowable plan item with an “AI Activation” flag.</p><figure><img alt="Marking CMMN plan item with “AI activation flag”" src="https://cdn-images-1.medium.com/max/804/1*7CkYrXePB9HrQjQLr6q-bQ.png" /><figcaption>Image 8: CMMN stage for domain identification with AI activation marker</figcaption></figure><p>Instead of writing complex rules, you describe the situation in natural language. Above stage has an AI activation marker (AI). The orchestrator can trigger it autonomously when conditions are met.</p><figure><img alt="Stage configuration showing AI instruction and activation settings. In this example, the instruction reads: Activate this, when for every work experience of the user, we cannot determine the company type, whether it’s financial institute or product based company" src="https://cdn-images-1.medium.com/max/1024/1*tBK80koyJKHhqeRqD4oe_A.png" /><figcaption>Image 9: Stage configuration showing AI instruction and activation settings</figcaption></figure><p>The AI instruction reads:</p><pre>Activate this, when for every work experience of the user, we cannot <br>determine the company type, whether it&#39;s financial institute or product <br>based company</pre><blockquote>You’re teaching the orchestrator to think like you would. “If I see work experience but don’t know the company domain, I need to look that up.”</blockquote><p>No complex conditionals. No brittle rules. Just <em>“Here’s the situation that calls for this action.”</em></p><h3><strong>The ReAct Pattern in Action</strong></h3><p>The orchestrator follows a simple cycle:</p><ol><li><strong>Observe</strong>: What information is available? What’s missing? Which plan items are active?</li><li><strong>Reason</strong>: Based on what I see and my instructions, what should happen next?</li><li><strong>Act</strong>: Invoke the appropriate agent or tool</li></ol><figure><img alt="Shows CMMN digram with AI intent activation" src="https://cdn-images-1.medium.com/max/1024/1*3vy8z5AU1qO54-KBk9Snpg.png" /><figcaption>Image 10: Working with tools</figcaption></figure><p>The diagram illustrates the flow: The <em>“Candidate Work Domain Identified”, </em>which is denoted by “<em>AI Intent Event Listener</em>”. With AI instructions, we tell the orchestrator when to invoke a given stage or intent. The orchestrator agent has access to the complete case context — all information held within the case and all active plan items. Based on this, it can decide which actions should be executed next. Similar like AI activated plan item, when AI detects particular intent, it can automatically trigger that event listener, which then activates a subsequent task to <em>“Update Candidate work domain”</em> in the data object variables. This demonstrates how orchestrated stages chain together based on completion events.</p><h3>Beyond the Use Case: The Universal Pattern</h3><p>Now you know the template. Building an agentic system is fundamentally about orchestrating knowledge workers — it’s just that we now have AI agents as additional workers alongside humans.</p><p>This pattern repeats across domains:</p><ul><li><strong>Customer support</strong>: AI agents handle research and draft responses, humans review and send</li><li><strong>Financial analysis</strong>: Agents gather data and run models, analysts interpret and recommend</li><li><strong>Content creation</strong>: AI generates drafts and variations, editors refine and approve</li><li><strong>Medical diagnosis</strong>: AI agents compile patient history and suggest tests, doctors examine and decide</li></ul><p>The thought process remains constant:</p><ol><li><strong>Map the knowledge work</strong> — What does the expert do?</li><li><strong>Identify what’s repetitive</strong> — What can be automated?</li><li><strong>Find the judgment points</strong> — Where do humans add unique value?</li><li><strong>Design the coordination</strong> — How do workers hand off information?</li><li><strong>Build in flexibility</strong> — Can the path change based on what’s discovered?</li></ol><h3>Questions to Ask Before Building</h3><p>Before you start implementing your agentic system, work through these questions:</p><p><strong>About the work:</strong></p><ul><li>What knowledge work am I modeling?</li><li>Is the task sequence fixed or flexible?</li><li>What information accumulates as work progresses?</li></ul><p><strong>About automation:</strong></p><ul><li>Which tasks are repetitive and rule-based? (automate fully)</li><li>Which tasks require lookup or research? (AI agents with tools)</li><li>Which tasks require judgment or creativity? (human-in-the-loop)</li></ul><p><strong>About orchestration:</strong></p><ul><li>How will information flow between workers?</li><li>What triggers each step? (data availability, time, external events)</li><li>What happens when something fails?</li></ul><p><strong>About visibility:</strong></p><ul><li>Who needs to see what the orchestrator decided and why?</li><li>How will we know if the orchestration is working well?</li><li>What feedback loop improves the system over time?</li></ul><h3>Building the Foundation First</h3><p>I introduced Flowable to demonstrate how orchestration can be implemented, but the real focus is on the thought process. Before writing any code or configuring any system:</p><ul><li><strong>Draw your planning board.</strong> Use sticky notes if you must. Map the human process first.</li><li><strong>Mark what’s automatable.</strong> Be honest about what truly doesn’t need human judgment.</li><li><strong>Identify your agents.</strong> What specialized capabilities do you need? Don’t build one mega-agent — build focused agents that do one thing well.</li><li><strong>Plan your knowledge base.</strong> What static information helps decision-making?</li><li><strong>Design incrementally.</strong> Start with one agent. Add another. Introduce orchestration when coordinating manually becomes painful.</li><li><strong>Monitor and learn.</strong> Your first orchestration won’t be perfect. Use audit trails to understand what the orchestrator is doing and refine.</li></ul><h3>The Durable Insight</h3><blockquote>Technology changes rapidly. The models powering AI agents today will be different next year. The frameworks and tools will evolve.</blockquote><p>But the principles of good orchestration remain constant:</p><ul><li><strong>Transparency</strong>: Can you explain why decisions were made?</li><li><strong>Auditability</strong>: Can you trace what happened and when?</li><li><strong>Flexibility</strong>: Can the system adapt to unexpected situations?</li><li><strong>Graceful degradation</strong>: When something fails, does the system recover or collapse?</li><li><strong>Human sovereignty</strong>: Are humans empowered or sidelined?</li></ul><p>The goal isn’t to replace human judgment with AI. It’s to create systems where humans and AI agents collaborate effectively, each contributing their unique strengths.</p><p>Start with the thought process. Build the foundation. The implementation details will follow, but the mental model, <strong><em>how you think about orchestration</em></strong>, that’s what will serve you regardless of which tools you ultimately choose.</p><h3>Where to Go From Here</h3><p>If you’re ready to explore this orchestration approach:</p><ol><li><strong>Map your use case</strong>: Don’t start with “how to implement AI” — start with “how does a human do this today?”</li><li><strong>Identify patterns</strong>: Which of the orchestration patterns appear in your workflow?</li><li><strong>Start small</strong>: Pick one knowledge work task. Model it. Add one AI agent. See how it feels.</li><li><strong>Reflect</strong>: Did the orchestration make sense? Was the human-AI handoff smooth? What would you change?</li><li><strong>Iterate</strong>: Add complexity gradually. Each iteration teaches you something about your domain.</li></ol><p>The world doesn’t need more AI hype. It needs thoughtful orchestration that makes knowledge work more effective while keeping humans in meaningful control.</p><blockquote>Build the thought process. The rest is just implementation.</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e532b8c80f2c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How popular software use patterns — Singleton]]></title>
            <link>https://im-pratham.medium.com/how-popular-software-use-patterns-singleton-3879fd3a2961?source=rss-91da0a5c7c31------2</link>
            <guid isPermaLink="false">https://medium.com/p/3879fd3a2961</guid>
            <category><![CDATA[open-source]]></category>
            <category><![CDATA[design-patterns]]></category>
            <category><![CDATA[java]]></category>
            <dc:creator><![CDATA[Prathamesh Mane]]></dc:creator>
            <pubDate>Mon, 24 Oct 2022 12:04:10 GMT</pubDate>
            <atom:updated>2022-10-24T12:04:10.229Z</atom:updated>
            <content:encoded><![CDATA[<h3>How popular OSS use patterns — Singleton</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*j31WDijJ5079QgNqcn10dQ.png" /><figcaption>Pattern</figcaption></figure><p>Patterns are everywhere, from nature to gigantic buildings, from mechanical systems to software. You know you don’t want to reinvent the wheel, so you look to Design Patterns: the lessons learned by those who’ve faced the same software design problems. As software engineers, we have considerable patterns across domains like micro-service patterns, workflow patterns, software integration patterns, etc. When I started coding, I was very much into (still I’m) “Head First design patterns” by Eric Freeman, and Elisabeth Robson. I would strongly recommend the book if you haven’t read it already. The book provides a practical demonstration of various patterns and the scenarios in which to use them. But nothing gets me excited when I see those patterns peeking out of the frameworks I use or through an open-source software I was diving through its source code.</p><p>This series is nothing but a verbal representation of that excitement. I will try to show you the various patterns being used in popular <strong>O</strong>pen <strong>S</strong>ource <strong>S</strong>oftware and how you can do the same within your application. So let’s jump directly to it.</p><p>Let’s focus on our first pattern — Singleton Pattern (One of a kind object). It is one of the object creation patterns that ensures only single instance of the class is created in the whole application and provides a global access point to it. To create a perfect singleton, we have to make sure —</p><ol><li>It’s thread-safe. Concurrent threads can access the instance without data corruption</li><li>Serialization friendly — After deserializing the object, no new-instance should be created.</li><li>Lazy loaded — If creation of singleton is costly, then it should be created only when accessed for first time.</li></ol><p>The implementation we see a quite often is like below —</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/7bd07968936d455195955a491a31683d/href">https://medium.com/media/7bd07968936d455195955a491a31683d/href</a></iframe><p>As you see the comments, you have to take care of multiple things, but even after that, it’s still not the perfect solution. The deserialization can create another object (to avoid this, we need to implement <a href="https://docs.oracle.com/javase/7/docs/platform/serialization/spec/input.html#5903">readResolve</a> method), constructor visibility can be modified via reflections and new objects can be created without any runtime exception.</p><p>The best implementation is by using enum. And the same approach is used by “<a href="https://spring.io/projects/spring-data-rest">Spring Data Rest</a>” project (The project eases developer’s life by automatically exposing your repositories as REST APIs. It’s a very well designed project which you can learn more of from <a href="https://spring.io/projects/spring-data-rest">project page</a>).</p><p>The class we will see is <a href="https://github.com/spring-projects/spring-data-rest/blob/f48ab5a44a5b56050c31adf6835ac19763d392c9/spring-data-rest-webmvc/src/main/java/org/springframework/data/rest/webmvc/spi/BackendIdConverter.java#L52">org.springframework.data.rest.webmvc.spi.BackendIdConverter.<strong>DefaultIdConverter</strong></a>. Suppose you have entity class <em>User, </em>it will exposed at URI /users/{userId}. The textual representation of <em>userId </em>param is controlled by BackendIdConverter. One of it’s default implementation is <a href="https://github.com/spring-projects/spring-data-rest/blob/f48ab5a44a5b56050c31adf6835ac19763d392c9/spring-data-rest-webmvc/src/main/java/org/springframework/data/rest/webmvc/spi/BackendIdConverter.java#L52"><strong>DefaultIdConverter </strong></a>which does nothing but passes the #toString implementation as it is.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/7766c50ac680980a3d0c0b0b5cf9cb43/href">https://medium.com/media/7766c50ac680980a3d0c0b0b5cf9cb43/href</a></iframe><p>The above implementation is free from issues we discussed earlier because as per java specification,</p><ol><li>An enum type has no instances other than those defined by its enum constants. It is a compile-time error to attempt to explicitly instantiate an enum type. (Hence we only have one instance — <em>INSTANCE</em>).</li><li>The final clone method in Enum ensures that enum constants can never be cloned.</li><li>The special treatment by the serialization mechanism ensures that duplicate instances are never created as a result of deserialization.</li><li>Reflective instantiation of enum types is prohibited.</li></ol><p>Together, these four things ensure that no instances of an enum type exist beyond those defined by the enum constants.</p><p>Today we saw one of the many interesting patterns OSS uses. In coming posts we will explore more interesting things like Outbox pattern, locator interface to name a few.</p><p>Till then you can read my previous posts on Event Driven architecture, workflow automation from link below. Happy reading.</p><p><a href="https://medium.com/@im-pratham">Prathamesh Mane - Medium</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3879fd3a2961" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Performance Testing Your Kubernetes Kafka Cluster]]></title>
            <link>https://im-pratham.medium.com/performance-testing-your-kubernetes-kafka-cluster-95f6e7d8dfc5?source=rss-91da0a5c7c31------2</link>
            <guid isPermaLink="false">https://medium.com/p/95f6e7d8dfc5</guid>
            <category><![CDATA[apache]]></category>
            <category><![CDATA[benchmark]]></category>
            <category><![CDATA[kafka]]></category>
            <category><![CDATA[kubernetes]]></category>
            <dc:creator><![CDATA[Prathamesh Mane]]></dc:creator>
            <pubDate>Fri, 03 Jun 2022 17:53:18 GMT</pubDate>
            <atom:updated>2022-06-20T08:14:28.811Z</atom:updated>
            <content:encoded><![CDATA[<p>Over the last few years hosting the data workloads on the cloud is becoming the preferred approach due to the rise in container orchestrator platforms like Kubernetes. In the last post about “Deploying Flowable on OpenShift” I talked about why the developer community prefers these platforms for hosting their workloads. Today we will explore one such data-intensive product — Apache Kafka.</p><p>Apache Kafka is distributed commit log, used for real-time streaming, analytics, and many more use cases. The performance of Kafka (or any real-time streaming technologies) is dependent upon many factors like network latency, IO, memory throughput, etc. Along with that, it provides loads of configuration parameters on the broker/client/topic level for fine-tuning the deployment. Collectively if you are a DevOps engineer or a Kafka Administrator, you have to try benchmarking your deployment against varying loads and with different configurations. Luckily Kafka command-line binaries come with multiple scripts for performance testing your cluster. Today we will explore the most used configurations for perf-testing the Kafka cluster.</p><h3><strong>Background</strong></h3><p>In my particular case, I wanted to explore multiple deployment options for the Apache Kafka. VM-based deployments are the prominent choice of administrators. But due to the automation capabilities that come with k8s, I was more inclined to host on Kubernetes. But as Apache Kafka’s performance is suspected to the hardware and network you use, I need to be extra cautious when going cloud first. But I was confident that moving to the K8s cluster won’t affect the performance mainly because — First, we are using an on-premise K8s cluster using Openshift. Hence all backing nodes are within the same network zone and using the same hardware as of the VMs. And second, for persistence storage, we have a Portworx scheduler who can attach the nearest storage volume to our Kafka stateful sets.</p><p>So to prove my assumption I need to test the Kafka cluster against a load. The tests I did contain running multiple instances of the producer and consumer parallelly. When doing those tests on VMs, you have to coordinate manually to run those instances simultaneously. But we can use Kubernetes jobs and their parallelism settings to run as many as instances simultaneously.</p><h3>Tests</h3><p>I created multiple scenarios considering the variable load, message size, and the concurrent instances of the clients. I tested the cluster maintaining the same configuration for the clients, producers, and consumers throughout the scenarios.</p><p>There are five sets of scenarios relevant to the test:</p><ul><li>Single producer throughput.</li><li>Multiple producer throughput.</li><li>Single producer and consumer.</li><li>Multiple producers and single consumer throughput</li><li>End to End Latency.</li></ul><h4><strong>Producer setting:</strong></h4><ul><li>Producer is going to be the one generating most stress to the cluster (as they are writing to one topics, and other replicas will be replicating from the leader).</li><li>Message size: 1000 bytes.</li><li>Throughput: controlled manually. Do not let the producer pump as much as it can because then you would not get the latency impact under different loads.</li><li>acks=all (or acks=-1) to ensure there is at least 1 replica (in real world this would be most of the case).</li><li>Run with increasing throughput until: target throughput can no longer be achieved or latency increased more than 1,000 ms.</li></ul><h4>Job Template</h4><p>I created multiple job templates, with the scripts running performance tests against the cluster. All jobs are hosted under —</p><p><a href="https://github.com/im-pratham/kafka-perf-testing-k8s.git">GitHub - im-pratham/kafka-perf-testing-k8s: K8s jobs to benchmark Kafka cluster on Kubernetes</a></p><p>The resource template has the following pattern —</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/4961402374ae1d6d91fdc8128b14d306/href">https://medium.com/media/4961402374ae1d6d91fdc8128b14d306/href</a></iframe><p>The first resource is the config-map to host the script to run tests, and we have a second job resource that executes those commands.</p><p>Before jumping into actual tests, let’s first create the test topic.</p><p>From now on I will be using PowerShell syntax and OC client for interacting with the Kubernetes cluster. But these commands are also replaceable with kubectl. (Just replace <strong><em>oc</em></strong><em> </em>with <strong><em>kubectl</em></strong><em>).</em></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/c2f86c2e0a1e8b4c20849d106b83b013/href">https://medium.com/media/c2f86c2e0a1e8b4c20849d106b83b013/href</a></iframe><p>Let’s explore each scenario one by one —</p><h3>Single producer throughput</h3><h4>Context</h4><p>Apache Kafka installation hosts a bunch of helpful command-line tools. The kafka-*-perf-test tools can be used in several ways.</p><p>The kafka-*-perf-test tools allow you to:</p><ul><li>Measure, read, and write throughput.</li><li>Stress test the cluster based on specific parameters (such as message size).</li><li>Load test to evaluate specific metrics or determine the impact of cluster configuration changes.</li></ul><p>We will use these scripts to write our test scenarios.</p><h4>Settings</h4><p>Produce with an increasing number of throughput, from 1000, 2000, 5000, 10000, 20000, 30000, 40000</p><p>Refer — <strong><em>single-producer.yaml</em></strong></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/cdeda3e3594a0f168ad7b53b7fc2a941/href">https://medium.com/media/cdeda3e3594a0f168ad7b53b7fc2a941/href</a></iframe><h4>Results</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/813/1*IRgtdMkV9Z6vhd-5tgxH0g.png" /><figcaption>records vs throughput target</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/885/1*-3HdbUJRYmP8-Kg-WhRRTw.png" /><figcaption>latency vs throughput target</figcaption></figure><h4><strong>Conclusion</strong></h4><p>No significant drag observed in producers as throughput increases. As throughput target went above 40K avg latency went below 1sec. Max avg latency is also not more than 2sec.</p><h3>Multiple producer throughput</h3><h4>Settings</h4><p>On each producer, run the below command concurrently on each host (try to run within 1 second).</p><p>Refer — <strong><em>multiple-producer.yaml</em></strong></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/670f28061c326cf9fe3aa90a4df0b1b2/href">https://medium.com/media/670f28061c326cf9fe3aa90a4df0b1b2/href</a></iframe><h4>Results</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pgo9yv_ocipf540E5h4l_A.png" /><figcaption>latency vs throughput target</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/932/1*sThucjU896E-8VAxpnXLcA.png" /><figcaption>records vs throughput target</figcaption></figure><h4><strong>Conclusion</strong></h4><p>With three concurrent producers, the cluster capacity is 15k-20k msg/seconds. But we haven’t noticed a significant performance decrease as throughput increases.</p><h3>Single producer and consumer throughput</h3><h4>Settings</h4><p><strong>Consumer: </strong>Refer — <strong><em>consumer.yaml</em></strong></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/9f63ea60e3c852636d824c98e790ce1e/href">https://medium.com/media/9f63ea60e3c852636d824c98e790ce1e/href</a></iframe><p><strong>Producer: </strong>Refer — <strong><em>producer-fixed-single.yaml</em></strong></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1bc8ae5cd55fc88fb047cb9531e5ebfd/href">https://medium.com/media/1bc8ae5cd55fc88fb047cb9531e5ebfd/href</a></iframe><h4><strong>Results</strong></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/912/1*YUbRdaikhk1YJzTdCl_jIw.png" /><figcaption>consolidated results</figcaption></figure><h4><strong>Conclusion</strong></h4><p>Consumer performance is not impacted by the increase in producer throughput.</p><h3>Multiple producer and single consumer throughput</h3><h4>Settings</h4><p><strong>Consumer: </strong>Refer — <strong><em>consumer-fixed-single.yaml</em></strong></p><p><strong>Producer: </strong>Refer — <strong><em>producer-fixed-multiple.yaml</em></strong></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/374670c99c49ea61e9ae900d2e314ce2/href">https://medium.com/media/374670c99c49ea61e9ae900d2e314ce2/href</a></iframe><h4>Results</h4><p>As the results include consolidating logs from multiple pods, I have created a utility script to gather them and save them in excel. To run the script, use —</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/d2eeabde49ba6378c8f3910c5417670f/href">https://medium.com/media/d2eeabde49ba6378c8f3910c5417670f/href</a></iframe><p>It generates the excel file with details from each pod.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/722/1*RXRRquoCuZFr2101plqxcg.png" /><figcaption>log summary</figcaption></figure><p>The result of the above test is —</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/915/1*307gwrm4b9D53IkBeRj_Kw.png" /></figure><h4><strong>Conclusion</strong></h4><p>Consumer performance is not impacted by the increase in producer throughput.</p><h3>End to End Latency</h3><p>The EndToEndLatency class in Kafka binary records the average end-to-end latency for a single message to travel through Kafka. It takes the following arguments —</p><ul><li><strong>broker_list</strong>: location of the bootstrap broker for both the producer and the consumer</li><li><strong>num_messages: </strong>number of messages to send</li><li><strong>producer_acks: </strong>producer ack setting</li><li><strong>message_size_bytes: </strong>the size of each message in bytes</li></ul><h4>Settings</h4><p>Refer — <strong><em>e2e.yaml</em></strong></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/cfe7d49a87d35b7c8ef208a975ef3ca1/href">https://medium.com/media/cfe7d49a87d35b7c8ef208a975ef3ca1/href</a></iframe><figure><img alt="" src="https://cdn-images-1.medium.com/max/751/1*PkyjN6Z8sTe--5wElhCa2Q.png" /><figcaption>Messages vs Latency</figcaption></figure><p><strong>Avg latency:</strong> 4.0328 ms</p><p><strong>Percentiles</strong>: 50th = 3, 99th = 26, 99.9th = 57</p><h4><strong>Result:</strong></h4><p>End to end latency is well below the limits.</p><h3>Conclusion</h3><p>Deploying the distributed system and fine-tuning configuration parameters can be a very time-consuming process. To test the deployment against close to real-time concurrency loads can be very difficult. We can use the Kubernetes resources and Kafka perf tools to simulate concurrent load to the Kafka cluster.</p><p>I hope the shared job resources and scripts will make your streaming journey more comfortable.</p><p>Happy streaming !!</p><p>If you like reading articles like these, check out my other articles —</p><p><a href="https://im-pratham.medium.com/">Prathamesh Mane - Medium</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=95f6e7d8dfc5" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Deploying Flowable on Openshift]]></title>
            <link>https://im-pratham.medium.com/deploying-flowable-on-openshift-fa27cb8908a?source=rss-91da0a5c7c31------2</link>
            <guid isPermaLink="false">https://medium.com/p/fa27cb8908a</guid>
            <category><![CDATA[flowable]]></category>
            <category><![CDATA[openshift]]></category>
            <category><![CDATA[red-hat-openshift]]></category>
            <category><![CDATA[helm]]></category>
            <dc:creator><![CDATA[Prathamesh Mane]]></dc:creator>
            <pubDate>Sat, 12 Mar 2022 16:41:46 GMT</pubDate>
            <atom:updated>2022-03-26T08:01:23.481Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/700/1*WcCi1Md84qvSKSAlL3s6lg.png" /><figcaption>Flowable + Openshift</figcaption></figure><h3>Introduction</h3><p>Often time when we are exploring new technologies or trying out a new feature, we require an easy to configure, easy to manage, and reproducible deployment environment. For the past couple of years Openshift Container platform serving that need for me. I use Openshift mainly because —</p><ol><li>It’s Kubernetes at the core. Hence I can manage multi-container applications easily.</li><li>Security-focused (backed by RedHat). It configures docker images with strict and recommended security policies like strict security context, file system permissions, and dropping unnecessary capabilities. More about it later.</li><li>Provides <strong>free sandbox </strong>for a developer. So no need to install heavy docker daemons, k3s clusters on local systems.</li><li>Tools like Helm, Operator makes application deployment look like package installation in Linux, (<em>apt install git vs helm install flowable).</em></li></ol><h3>Making Images compactible to run on Openshift</h3><p>As mentioned in point 2 above, Openshift considers security policies as a first-class citizen of their platform. The platform runs the docker images with the following restrictions —</p><ol><li>Images are started with the random user id. This user is always part of the root group. Hence you cannot build your images as root or any specific user.</li><li>The mount volumes have fsGroup. So we have to make sure, the images are properly configured to access the data folder.</li><li>The capabilities like <a href="https://en.wikipedia.org/wiki/Setuid"><em>SETGID, SETUID</em></a> are dropped.</li></ol><p>Hence, you cannot assume that your images will run on Openshift as it is. This has been always the first issue I face when trying to deploy new applications on Openshift. But the beauty of Open-source always comes to your rescue. You can always raise issues and the PRs and get them fixed.</p><p><a href="https://github.com/flowable/flowable-engine/issues/2941">Docker image failing on openshift · Issue #2941 · flowable/flowable-engine</a></p><p>Flowable engineers are quick enough to accept the PR, and the latest images are now compatible to run on the Openshift.</p><h3>Setting Up Environment</h3><h4>Installing Tools</h4><p>If this is the first time you are working with Openshift, you need the following <strong><em>oc </em></strong>and <strong><em>helm</em></strong><em> </em>installed<em>. </em>Use package manager like choco if not used already.</p><pre><strong>&gt; choco install openshift-cli -y --force<br>&gt; choco install kubernetes-helm -y --force</strong></pre><h4>Getting Helm Chart</h4><p>To reduce our efforts, the Flowable team has already packaged the engine as Helm Chart. The source can be accessed from —</p><p><a href="https://github.com/flowable/flowable-engine/tree/main/k8s/flowable">flowable-engine/k8s/flowable at main · flowable/flowable-engine</a></p><pre>## add helm chart.<br><strong>&gt; helm repo add flowable-oss </strong><a href="https://flowable.github.io/helm/"><strong>https://flowable.github.io/helm/</strong></a><strong><br>&gt; helm repo update</strong></pre><pre>## check which charts are available.<br><strong>&gt; helm search repo flowable-oss</strong><br><em>NAME                    CHART VERSION   APP VERSION     DESCRIPTION<br>flowable-oss/flowable   6.7.2           6.7.2           A Flowable Helm chart for Kubernetes</em></pre><h4>Accessing Openshift Cluster</h4><p>Create the Openshift sandbox from <a href="https://developers.redhat.com/developer-sandbox/get-started">https://developers.redhat.com/developer-sandbox/get-started</a>. Once done, copy the login command from the dashboard and paste in the terminal.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*G6neevMy_NbzNBajHIIsnA.png" /><figcaption>Copy login command</figcaption></figure><pre>## login to cluster <br><strong>&gt; oc login --token=sha256~xxxx --server=</strong><a href="https://api.sandbox.x8i5.p1.openshiftapps.com:6443/"><strong>https://api.sandbox.x8i5.p1.openshiftapps.com:6443</strong></a></pre><p>As docker added rate-limiting to the image pull request (one IP can at max do ~300 requests), we need to create pull secrets with the docker hub account.</p><pre><strong>&gt; oc create secret docker-registry docker-key --docker-server=docker.io \<br>        --docker-username=YOUR_DOCKER_HUB_USERNAME --docker-password=YOUR_DOCKER_HUB_PASSWORD \<br>        --docker-email=YOUR_DOCKER_HUB_EMAIL</strong><br><em>secret/docker-key created</em></pre><pre>## add secret to default service account, so that it will be used for every image pull request<br><strong>&gt; oc patch serviceaccount default -p &#39;{\&quot;imagePullSecrets\&quot;: [{\&quot;name\&quot;: \&quot;docker-key\&quot;}]}&#39;</strong></pre><pre>## verify the changes<br><strong>&gt; oc get serviceaccount default -o yaml</strong><br><em>apiVersion: v1<br>imagePullSecrets:<br>- name: </em><strong><em>docker-key</em></strong><em><br>- name: default-dockercfg-p8qsm<br>kind: ServiceAccount<br>metadata:<br>  creationTimestamp: 2022-03-12T06:40:37Z<br>  name: default<br>  namespace: im-pratham-dev<br>  resourceVersion: &quot;923910545&quot;<br>  uid: 11e1c9f4-5292-482a-83d2-9c9318c46144<br>secrets:<br>- name: default-token-b58n9<br>- name: default-dockercfg-p8qsm</em></pre><h4>Installing Flowable</h4><p><strong>Using In-memory database</strong></p><p>First, we will try with an in-memory database. We need to set the following values —</p><ol><li>database.datasourceDriverClassName: H2 drive name</li><li>database.datasourceUrl: In memory DB connection string</li><li>postgres.enabled=false.</li></ol><pre><strong>&gt; helm upgrade --install flowable-demo flowable-oss/flowable --set database.datasourceDriverClassName=org.h2.Driver --set database.datasourceUrl=jdbc:h2:mem:testdb --set postgres.enabled=false</strong></pre><pre>## check if pod is installed<br><strong>&gt; oc get po -l &quot;app.kubernetes.io/name=ui&quot;</strong><br><em>NAME                  READY     STATUS    RESTARTS   AGE<br>ui-74c9cf8b94-nq8vm   0/1       Running   0          62s</em></pre><pre>## Use name of pod returned above. Port forwarding is to access the remote instance from the local system.<strong><br>&gt; oc port-forward ui-74c9cf8b94-nq8vm 8080</strong><br>Forwarding from 127.0.0.1:8080 -&gt; 8080<br>Forwarding from [::1]:8080 -&gt; 8080</pre><p>Now visit <a href="http://localhost:8080/flowable-ui">http://localhost:8080/flowable-ui</a>, and enter default credentials username: admin, password: test to login.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GyoqGBmbBUWEkN5N2zNd_g.png" /><figcaption>Flowable Open Source UI</figcaption></figure><p><strong>Using Persistent Database</strong></p><p>The above method is useful when you need a throw-away environment. The contents of the in-memory database will be wiped when a container is restarted. If you want a persistence solution, we can deploy any database we want and provide and connection string URL as we provided above.</p><p>The default PostgreSQL template coming with a flowable helm chart is again not compatible with Openshift. Hence we will install our own instance. Openshift has a pre-defined template for the same that we can re-use.</p><pre>## check openshift pre-defined template<strong><em><br>&gt; oc get template -n openshift | grep postgresql</em></strong><br><strong>postgresql-ephemeral</strong>                                PostgreSQL database service, without persistent storage. For more information...   7 (2 generated)   3<br><strong>postgresql-persistent</strong>                               PostgreSQL database service, with persistent storage. For more information ab...   8 (2 generated)   4</pre><pre>## as pointed above, we can use postgresql-persistence template.<br>## Now check which parameters are available for customization.<br><strong><em>&gt; oc describe template postgresql-persistent -n openshift</em></strong></pre><pre>## Provide correct parameters, and deploy database.<br>&gt; <strong>oc new-app --name=postgresql --template=postgresql-persistent -p POSTGRESQL_USER=flowable -p POSTGRESQL_PASSWORD=flowable -p POSTGRESQL_DATABASE=flowable-demo</strong></pre><pre><em>            Username: flowable<br>            Password: flowable<br>       Database Name: flowable-demo<br>      Connection URL: postgresql://postgresql:5432/</em></pre><pre>## check if deployment is correct<br><strong>&gt; oc get po</strong><br><em>NAME                  READY     STATUS      RESTARTS   AGE<br>postgresql-1-ch2wg    1/1       Running     0          31m<br>postgresql-1-deploy   0/1       Completed   0          31m</em></pre><p>Now we need to upgrade our existing deployment to use the newly deployed PostgreSQL instance.</p><pre>## Upgrade helm installation<strong><br>&gt; helm upgrade --install flowable-demo flowable-oss/flowable --set database.datasourceDriverClassName=org.postgresql.Driver --set database.datasourceUrl=jdbc:postgresql://postgresql:5432/flowable-demo --set postgres.enabled=false</strong></pre><pre>## Above step will only change the connection configuration. This will not affect the running pod. Hence we have to manually delete old pod.<br><strong>&gt; oc delete po -l &quot;app.kubernetes.io/name=ui&quot;</strong><br>pod &quot;ui-74c9cf8b94-nq8vm&quot; deleted</pre><pre>## Openshift is smart enough to create new pod with updated configuration<br><strong>&gt; oc get po</strong><br><em>NAME                  READY     STATUS      RESTARTS   AGE<br>postgresql-1-ch2wg    1/1       Running     0          32m<br>postgresql-1-deploy   0/1       Completed   0          32m<br>ui-74c9cf8b94-k7bdn   0/1       Running     0          13s</em></pre><pre>## Use name of pod returned above. Port forwarding is to access the remote instance from the local system.<br><strong>&gt; oc port-forward ui-74c9cf8b94-k7bdn 8080</strong><br><em>Forwarding from 127.0.0.1:8080 -&gt; 8080<br>Forwarding from [::1]:8080 -&gt; 8080</em></pre><p>Your final topology will look something like —</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7ASeamXCraKzpgtKi2JCaw.png" /><figcaption>Deployment topology</figcaption></figure><p>This way you can install the Flowable on Openshift using Helm Chart.</p><p>Happy Helming!!</p><p>Explore other articles here —</p><p><a href="https://im-pratham.medium.com/">Prathamesh Mane - Medium</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fa27cb8908a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to use Schema Registry Plugin with HTTPS enabled]]></title>
            <link>https://im-pratham.medium.com/how-to-use-schema-registry-plugin-with-https-enabled-a6af9fcfb8f4?source=rss-91da0a5c7c31------2</link>
            <guid isPermaLink="false">https://medium.com/p/a6af9fcfb8f4</guid>
            <category><![CDATA[kafka]]></category>
            <category><![CDATA[confluent]]></category>
            <category><![CDATA[schemaregistry]]></category>
            <category><![CDATA[maven-plugin]]></category>
            <category><![CDATA[schema]]></category>
            <dc:creator><![CDATA[Prathamesh Mane]]></dc:creator>
            <pubDate>Mon, 03 Jan 2022 14:08:57 GMT</pubDate>
            <atom:updated>2022-08-15T09:51:18.231Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/0*CwCvhY1eOSmRUpgD.png" /><figcaption>Confluent Schema Registry</figcaption></figure><p>One of the most sought-after components when deploying apache Kafka is <a href="https://github.com/confluentinc/schema-registry">Schema Registry</a>. A schema registry allows us to store the different schemas into a centralized location, versioning them and most importantly forcing the schema evolution policies.</p><p>The schema registry exposes the rest endpoints which are called by the clients to work with schemas. In a spring boot + maven project, you can use a plugin to download the schema from the Schema Registry using</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/d9965a48e9adfb535e5bbb729fde56b4/href">https://medium.com/media/d9965a48e9adfb535e5bbb729fde56b4/href</a></iframe><p>By default these endpoints are not secured are served through HTTP. You can enable the SSL for encryption and authentication using <a href="https://docs.confluent.io/platform/current/schema-registry/security/index.html"><strong>this guide</strong></a>. In some deployment environments like Openshift, you cannot expose non-secure endpoints to the outside clients via <a href="https://docs.openshift.com/container-platform/3.11/architecture/networking/routes.html">Routes</a>, this rule can be enforced by your company’s deployment engineers. In case you are using your own CA authority for signing certificates, the plugin will throw an error — “<em>Failed to execute goal io.confluent:kafka-schema-registry-maven-plugin:7.0.1:download (avro-resources) on project kafka-avro-example: Exception thrown: sun.security.validator.ValidatorException: </em><strong><em>PKIX path building failed: sun.security.provider.certpath.SunCertPathBuilderException: unable to find valid certification path to requested target</em></strong>”</p><pre>[INFO] --- kafka-schema-registry-maven-plugin:7.0.1:download (avro-resources) @ kafka-avro-example ---<br>[INFO] Getting all subjects on schema registry...<br>[INFO] ------------------------------------------------------------------------<br>[INFO] BUILD FAILURE<br>[INFO] ------------------------------------------------------------------------<br>[INFO] Total time:  5.904 s<br>[INFO] Finished at: 2022-01-03T17:47:11+05:30<br>[INFO] ------------------------------------------------------------------------<br>[ERROR] Failed to execute goal io.confluent:kafka-schema-registry-maven-plugin:7.0.1:download (avro-resources) on project kafka-avro-example: Exception thrown: sun.security.validator.ValidatorException: PKIX path building failed: sun.security.provider.certpath.SunCertPathBuilderException: unable to find valid certification path to requested target -&gt; [Help 1]</pre><p>This happens as the internal CA certificate is not part of the <a href="https://docs.oracle.com/javase/8/docs/technotes/guides/security/jsse/JSSERefGuide.html#Customization">default trust store</a>. I searched multiple forums to find out the way to provide trust store details, but found nothing. So the best way is to dig down the code and find out yourselves.</p><h4>Approach I: Provide Maven Arguments</h4><p>While creating the default security context, the library reads the <em>“javax.net.ssl.*” </em>properties. Hence you can pass them while running a maven goal.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/2cf9547fe3205ff6bd0ea6ed7a619533/href">https://medium.com/media/2cf9547fe3205ff6bd0ea6ed7a619533/href</a></iframe><h4>Approach II: Use plugin configuration (Preferred)</h4><p>The kafka-schema-registry-maven-plugin plugins allow passing the custom configuration via <a href="https://github.com/confluentinc/schema-registry/blob/master/maven-plugin/src/main/java/io/confluent/kafka/schemaregistry/maven/SchemaRegistryMojo.java#L56"><em>&lt;configs&gt;</em></a> tag. And this config is then<a href="https://github.com/confluentinc/schema-registry/blob/03a4e069783b2e4bf9aab3ef1e39ffda60811834/client/src/main/java/io/confluent/kafka/schemaregistry/client/CachedSchemaRegistryClient.java#L223"> passed to create the SSL context</a> of the rest client. The only thing, we have to ensure is to prefix them with the “<strong><em>schema.registry.</em></strong>”.</p><p>So our final pom.xml file will look like this —</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1cd446e3d8a1b7281c48ff46ce0c127a/href">https://medium.com/media/1cd446e3d8a1b7281c48ff46ce0c127a/href</a></iframe><p>Follow <a href="https://medium.com/@im-pratham">https://medium.com/@im-pratham</a> to read more about everything technology :)</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a6af9fcfb8f4" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Powering GCC backend with Apache Kafka]]></title>
            <link>https://im-pratham.medium.com/powering-gcc-backend-with-apache-kafka-8fdf7cec8942?source=rss-91da0a5c7c31------2</link>
            <guid isPermaLink="false">https://medium.com/p/8fdf7cec8942</guid>
            <category><![CDATA[kafka-streams]]></category>
            <category><![CDATA[heroku]]></category>
            <category><![CDATA[coding-challenge]]></category>
            <category><![CDATA[apache-kafka]]></category>
            <category><![CDATA[kafka]]></category>
            <dc:creator><![CDATA[Prathamesh Mane]]></dc:creator>
            <pubDate>Sun, 26 Dec 2021 18:40:31 GMT</pubDate>
            <atom:updated>2021-12-28T17:26:15.787Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/800/0*zNa8xY7ms5Du7EVv" /></figure><h3>About Global Coding Challenge</h3><p>Each year Credit Suisse organizes the <a href="https://www.credit-suisse.com/pwp/hr/en/codingchallenge/">Global Coding Challenge (GCC)</a>. It is an online coding competition between participants across the globe. Around 3 weeks, participants try to attempt solutions to nine coding problems. Participants can improve their code as many times as they like during the competition. The top performers across the regions win exciting prizes and they also have a chance to join Credit Suisse as a Technical Analyst (TA).</p><p>The competition has been entirely designed, built, and run by Credit Suisse TAs. As a former TA myself, along with my colleagues we try to improve the participants’ overall experience year on year.</p><h3>Initial Architecture</h3><p>Once any participant signs up for the competition, a private git repository is allocated to them. The participant has to commit the code against his/her repository only. Once the code is pushed, via git hooks, we capture the commit, run the code in a sandboxed environment and calculate the ranked score of the submission. The overview of the submission process is described below -</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/663/1*YoI6TnjtF5UF_Trc2yZ-5A.png" /><figcaption>GCC: Code Submission Flow</figcaption></figure><p>Along with Code evaluation, we have multiple services to manage. Some critical services include —</p><ol><li><strong>User Management Service</strong> — to support user management lifecycle, like sign-ups, logins, profiles, etc.</li><li><strong>Evaluator Service</strong> — Runs the user submitted code under a sandboxed environment and calculates the score.</li><li><strong>Support Service </strong>— To manage support queries raised by participants.</li><li><strong>Mailing Service</strong> — Send competition-related updates and results.</li><li><strong>Cache Service </strong>— Serve most accessed data.</li><li>etc,</li></ol><p>For the first 2 years, when we are mostly focused on bringing core features to the users, the system architecture looked like this —</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/751/1*oczqfP5gYaUVHIVbHONTlg.png" /><figcaption>GCC: Initial Design of the Backend System</figcaption></figure><p>This architecture worked pretty well during the initial phases where we have only 3 regions and participation in few thousand. But in the 2nd edition, due to the popularity of the first season and increased regions, we hit full throttle. The system hit its absolute capacity and we were certain that we need to rethink the current architecture to support future scale.</p><h3>Solution</h3><p>The day 1 solution had many point-to-point connections between the services. It caused the backpressure to other services when one dependent system is overloaded with the user requests. The one observation we had is, the user submission spikes after 7 PM IST, as the most number of the participants are from India, and this is the time when most of the universities are closed for the day, and a student gets free time to work on the challenges. Hence we must be prepared to handle the sudden spike in the submissions.</p><p>Secondly, the challenge requirements are mostly suitable for the asynchronous architecture. Consider the evaluator service as an example. The service gets triggered only when a user commits the code to the git repo or the online code editor. And once the code is evaluated, we either send them an email with the results or show the results in the code editor. This definitely can be processed asynchronously.</p><p>The third aspect, not that important as above, but very crucial for the smooth user experience is caching the most accessed data. For a mammoth coding event like this, what could be the most accessed information? And you guessed it correctly, it’s the submission results. This data is being consumed by multiple services like frontend, leaderboards, email services. And as those services are distributed across multiple systems, the cache can’t sit on a single service, but rather we need a distributed solution for it.</p><p>Considering the above factors, we need a solution that satisfies the following criteria —</p><ol><li><strong>High Availability</strong> — The system should be highly available during some system failures and between rolling new updates of the system.</li><li><strong>Decoupling producers and consumers</strong> — Producers and consumers share information asynchronously.</li><li><strong>Producers and consumers can be scaled up and down</strong> independently.</li><li>Ability to <strong>replay messages</strong> later in the future.</li><li><strong>Data must-read by multiple consumers </strong>— Consumers from different groups can read the same data snapshot.</li><li><strong>Load balancing data between multiple consumers</strong> — Consumers from the same group must read the mutually exclusive set of data.</li></ol><p>Considering the above factors, Kafka matches our requirements as —</p><ol><li>Kafka is a <em>distributed commit log messaging system</em>, hence it’s highly available by design by duplicating the message to multiple replicas.</li><li>As Kafka is a message queue, producers can independently send the messages to Kafka topics, and consumers can read them any time they want.</li><li>This allows independent scaling producers and consumers, hence slow consumers cannot backpressure the producer to halt its operations.</li><li>Kafka can act as a durable store for the messages. You can set the Kafka deletion policy to prune the messages after a certain amount of time or to store only the latest key-value pair in the system.</li><li>Consumer group semantics allows the client from different consumer groups to read the messages independently.</li><li>And the same semantics allows the clients in the same consumer group to load balance the data between them exclusively.</li></ol><p>The new approach that we used in the GCC 3.0 version is below —</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/584/1*FEwLkhA8KImwaEN6RFG2cQ.png" /></figure><p>The details of each component are —</p><ol><li><strong>Github (Submission) Controller</strong> — The producer is responsible for sending the user submitted code to the Kafka topic named “<em>evaluator-submission</em>”. We allow test submissions (which are not counted into the final score and are run against the small number of the test cases) and the real submissions (exhaustive set of test cases are executed against the submission). So the processor has to cater to both the submission types. The actual handling of the messages is out of the scope of this article for simplicity.</li><li><strong>Evaluator Service </strong>— The service is responsible for running the submitted code in a sandboxed environment, collecting the matrices as total time takes for execution, number of test cases passed, amount of memory used to name a few. The result is then pushed to the “<em>evaluator-result</em>” topic. During peak times we receive hundreds of requests per minute and each submission takes on average ~1.2 minutes to execute. Hence we run an average of 40–60 processors in parallel. The number of consumers in the same group Kafka can load balance is capped by the number of partitions the input topic has. Hence we have configured the input topic partitions accordingly.</li><li><strong>Submission Controller </strong>— This is a <a href="https://kafka.apache.org/10/documentation/streams/developer-guide/processor-api.html">stream processor</a>, which reads from the “<em>evaluator-result</em>” topic, applies the scoring function, and writes to the “<em>score-result</em>” topic. This topic is again read to form the <a href="https://www.confluent.io/blog/kafka-streams-tables-part-1-event-streaming/">KTable </a>which stores the latest submissions and the respective score. This table is then exposed to multiple services like leaderboard via “<a href="https://docs.confluent.io/platform/current/streams/developer-guide/interactive-queries.html"><strong>Interactive Queries</strong></a>”. This table we use as a distributed cache to serve the read requests for submissions. This is a plus for us as we don’t have to accommodate another library for doing this stuff.</li><li><strong>Score Persistor </strong>— This is a simple microservice, which reads from the “<em>score-result</em>” topic and stores them into Mongo DB. This part can be replaced with <a href="https://docs.mongodb.com/kafka-connector/current/sink-connector/"><em>a Mongo Sink connector for Apache Kafka</em></a>. The persisted data is then used for reporting and other stuff.</li></ol><p>The above architecture allowed us to scale our system to a greater load without any hassle. This year a total of 25,000+ students across 7 regions signed up for the content. During the competitions days, we saw traffic of 100,000+ messages flowing through the Kafka cluster. We managed to scale down evaluator services from a few tens to max 80 instances parallelly. So all in all we can say that we are heading towards a correct path :)</p><h3>Key Learnings and Way forward</h3><p>If I say we found a perfect secret sauce for our problem, then it would be a total lie. While observing the system over the competition we found out pretty good observations, which we will try to mitigate next year.</p><ol><li><strong>Head of line blocking</strong> — It only takes a small number of slow requests to hold up the processing of the subsequent requests. As an evaluation engine, we allow participants to submit code in multiple languages like C, C++, Java, Python, etc. Solutions in some languages like Javascript tends to take more time to execute than others. Hence we did set up a large timeout interval for Javascript evaluators. The “<em>evaluator-submission</em>” topic has key=submission-id, and Kafka <a href="https://github.com/apache/kafka/blob/trunk/clients/src/main/java/org/apache/kafka/clients/producer/internals/DefaultPartitioner.java">default partitioner</a> takes a hash of the key, modes it with the number of partitions and allocates the message to that partition. Hence a partition having JS submissions at the head starved much faster submissions in the queue. Hence our overall response time was affected. The good part is we have a very low number of JS submissions (in a few tens). As a solution, we are planning to write our custom partitioner, to allocate the slow executing submissions to a specific partition.</li><li><strong>Managing Persistence of State Stores</strong> — We used <a href="https://devcenter.heroku.com/articles/kafka-streams-on-heroku">Heroku</a> for hosting our services and the Apache Kafka. The containers used at Heroku are called Dynos, and they by default do not allow any persistence store. To store the state stores of the stream processor, we either have to buy new S3 storage or an NFS solution. A rather simpler approach is to use standby replicas of the stream processor. <strong>Standby Tasks</strong> are replicas of Stream Tasks that maintain fully-replicated copies of state. Dynos make use of Standby Tasks to resume work immediately instead of having to wait for the state to be rebuilt from changelog topics. Rebuilding the state can take up to 15–20 mins considering that we serve 100k messages per day. This is not realistic as Heroku mandates to make dynos up within 180 seconds. Hence having standby tasks by setting <em>num.standby.replicas</em> config in the application seems a way to go forward.</li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8fdf7cec8942" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Flowable: Deploying workflow model in Multi tenant environment]]></title>
            <link>https://im-pratham.medium.com/flowable-deploying-workflow-model-in-multi-tenant-environment-2c578589057b?source=rss-91da0a5c7c31------2</link>
            <guid isPermaLink="false">https://medium.com/p/2c578589057b</guid>
            <category><![CDATA[flowable]]></category>
            <category><![CDATA[jenkins]]></category>
            <category><![CDATA[multitenancy]]></category>
            <category><![CDATA[deployment]]></category>
            <dc:creator><![CDATA[Prathamesh Mane]]></dc:creator>
            <pubDate>Sun, 27 Jun 2021 13:03:35 GMT</pubDate>
            <atom:updated>2021-06-27T13:03:35.920Z</atom:updated>
            <content:encoded><![CDATA[<p>I have seen various scenarios where workflows engines are used. In some places, people use it for coordinating their multiple micro-services, while others use it orchestrating long-running processes.</p><p>Whatever might be the case, in a general IT environment, you cannot directly model your workflows and hand them over to workflow engines like Flowable to execute them.</p><p>The process/case models are nothing but a declarative code that tells the engine what to do next on the occurrence of specific pre-conditions. Hence you must be as vigilant as you are with other softwares. You need to test it and ensure that it works in all possible scenarios. So before putting the workflows in action, they must go through the following software development environments -</p><ol><li><em>dev </em>(developers model their workflows and test)</li><li><em>sit, QA, </em>etc (testers verify and validate the workflow against multiple scenarios)</li><li><em>uat</em> (business checks the developed workflows)</li><li><em>prod </em>(the ultimate zenith)</li></ol><p>In my current organization, we use Flowable in a quite interesting way. We call it a SaaS offering of workflow execution within the organization. Basically, we provide workflow execution environment to the teams who want to integrate workflow engines with their existing product. This allows them to reduce time to go live by cutting all ops-related stuff and all other compliance requirements. As a SaaS platform, we provide each team with —</p><ol><li>An isolated modelling environments</li><li>An isolated deployment for their workflows</li><li>Authentication and authorization mechanism as per organization standard.</li><li>Regulatory compliance.</li><li>and many more.</li></ol><p>To provide teams with an isolated execution platform, Flowable has a feature called <a href="https://blog.flowable.org/2018/09/11/multitenancy-in-flowable/">multi-tenancy</a>. That solves most of the problems for us. But the second is a bit trickier. As a platform, we need to ensure that, each team can model their workflows and they can follow their release cycle. We didn’t want to force them to a single release cycle. So we started exploring ways to achieve it.</p><p>We did a quiet brainstorming between my colleagues and engineers from Flowable on how to tackle this particular challenge. Flowable allows you to deploy models using the following methods -</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*J_OftLAvRdGjv71YNOYLCw.png" /><figcaption>Various app deployment methods in Flowable</figcaption></figure><p>As you see, method 2 is more suitable in dev environments, and it’s integrated with modeling tools. Method 3, we use it to deploy models to higher environments. We use a combination of both.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fScoonlaSgWXyxCddvXNUQ.png" /><figcaption>App deployment pipeline</figcaption></figure><p>At a first glance, the app deployment pipelines look too complicated. But believe me, this is not. The whole pipeline is divided into 3 separate phases -</p><h4>Development Phase</h4><p>Steps 1–8, Participants —<em> Modeler, Reviewer</em></p><p>This phase is quite an iterative phase. The modeler creates the workflows using all available standards supported by Flowable. At this time, the modeler uses the publish button available in the design to deploy models on Flowable work and test it. Once the models are ready, the reviewer validates against our own set of the quality matrix, suggests improvements. The quality matrix checks some generic rules such as whether an exclusive gateway has one default outgoing flow, and other use case specific implementations.</p><p>Once review comments are incorporated, models are then pushed to any version control system such as git. The 2 separate versions of the models are saved. zip version for design and bar (business archive) version to deploy on Flowable workflow engines.</p><h4>Release Preparation Phase</h4><p>Steps 9–11, Participants — <em>Release Manager</em></p><p>Once models are ready to be published to higher environments, we create a release artifact from VCS, and push it to JFrog artifactory. Each artifact has a unique release number.</p><h4>App promotion phase</h4><p>Steps 12–21, Participants — <em>Deployment Manager</em></p><p>We use a tool called the transporter, which allows you to trigger some scripts. You can use any alternatives, e.g. Jenkins. The deployment manager specifies the artifact version to be pushed and on which environment. The transporter reads those params, downloads artifacts, and deploys model.zip to design and model.bar to work to the specified environment.</p><p>The above method allows —</p><ul><li>Multiple teams to develop their models using a single instance of Design.</li><li>Each team maintains its artifacts.</li><li>Each team can release artifacts to higher environments without affecting another team.</li><li>We have configured each team’s technical user to deploy on their respective tenant only. Hence no one can deploy to other tenants.</li><li>We can use the same pipeline to handle default tenants. It is a special tenant, which hosts reusable models that can be shared with other tenants.</li></ul><p>Going ahead we are planning to improve the existing architecture by</p><ul><li>Automating rules validations from the quality matrix by integrating them into the pipeline.</li><li>Adding inspect test cases as a part of app promotion, as shown in the <a href="https://youtu.be/s7wEgvd0hgQ">demo by Valentine from Flowable</a>.</li></ul><p>If you have any questions or suggestions, leave them in the comments sections. I would be happy to address them.</p><p>If you liked reading the current post, you should definitely read previous blog posts in this series — <br><a href="https://im-pratham.medium.com/business-process-automation-solution-then-and-now-2d3fbe05586f">Business Process Automation Solution — Then and now.</a><br><a href="https://im-pratham.medium.com/bpmn-cmmn-and-dmn-triple-crown-of-process-improvement-standards-6254e9a083f8">BPMN, CMMN, and DMN — Triple Crown of Process Improvement Standards.</a><br><a href="https://im-pratham.medium.com/exception-handling-in-workflows-using-flowable-c30025d9da2b">Exception handling in workflows using Flowable.</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2c578589057b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Exception handling in workflows using Flowable]]></title>
            <link>https://im-pratham.medium.com/exception-handling-in-workflows-using-flowable-c30025d9da2b?source=rss-91da0a5c7c31------2</link>
            <guid isPermaLink="false">https://medium.com/p/c30025d9da2b</guid>
            <category><![CDATA[exception-handling]]></category>
            <category><![CDATA[bpmn]]></category>
            <category><![CDATA[flowable]]></category>
            <category><![CDATA[bpmn2]]></category>
            <dc:creator><![CDATA[Prathamesh Mane]]></dc:creator>
            <pubDate>Sun, 13 Jun 2021 16:05:36 GMT</pubDate>
            <atom:updated>2021-06-13T16:05:36.141Z</atom:updated>
            <content:encoded><![CDATA[<p>This is the 3rd blog of the series “Business Process automation”. If you haven’t checked them till now, I strongly recommend having a look. <a href="https://im-pratham.medium.com/business-process-automation-solution-then-and-now-2d3fbe05586f">Part 1</a>, <a href="https://im-pratham.medium.com/bpmn-cmmn-and-dmn-triple-crown-of-process-improvement-standards-6254e9a083f8">Part 2</a></p><p>Exceptions are part of any process. As a process modeler or an application developer, we always tend to write robust applications. Developers building business processes must able to handle exceptions to the business case to ensure that the process itself is resilient and can continue after failures occur. The exception handling logic differs based on what is your problem statement and what tools you have at your disposal. In this blog, I tried to define various exception handling methods using pattern language. Each pattern follows a specific structure, called <strong>Context </strong><em>(a common setup where you see the problem is repeating),</em> <strong>Problem </strong><em>(statement</em>), <strong>Forces </strong>(<em>conditions under which the proposed solutions can be recommended</em>), and a <strong>Solution. </strong>So let’s jump into it.</p><h3>1. XOR or Exclusive Gateway</h3><h4>Context</h4><p>You are tasked to create a workflow.</p><h4>Problem</h4><p>You want to handle the non-happy flow in the workflow.</p><h4>Forces</h4><ul><li>You want a naive approach to model non-happy scenario.</li><li>Your tool is not fully BPMN2.0 specification compliant.</li></ul><h4>Solution</h4><p>The BPMN service tasks allow the execution of a custom java code. When executing, you can catch the error and set some variables. And then use it in the BPMN diagram to model the flow. Let me tell you, it’s not an actual exception handling but modeling the flow based on result variables. You can use expression like ${IS_SUCCESSFUL == false} for XOR gateway.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/680/1*5c3ZuD3LMtHRpw5mDrGXbg.png" /><figcaption>Handle error via XOR gateway</figcaption></figure><p>The “<em>Validate Dat</em>a” service task executes following Java delegate.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/28572073132265e6b55b0329c537b585/href">https://medium.com/media/28572073132265e6b55b0329c537b585/href</a></iframe><h4>Alternate Solutions</h4><p>As mentioned, this is not a correct way of exception handling. If you want to go with a more BPMN compliant way, refer to the below solutions.</p><h3>2. Error Boundary Event (BPMN 2.0)</h3><p>BPMN 2.0 specifications adds capability to catch error events and trigger custom process flow. We will discuss them in details below.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/231/1*3xpq-su8q0ovj4Zg8h627Q.png" /></figure><h4>Context</h4><p>You are tasked to create a workflow.</p><h4>Problem</h4><p>You want to handle the non-happy flow in the workflow, and divert the execution flow based upon event.</p><h4>Forces</h4><ul><li>Your tool is BPMN2.0 specification compliant.</li><li>You want to handle multiple error scenarios arising from a particular activity/process context.</li></ul><h4>Solution</h4><p>A boundary event is attached to a boundary of the activity or a subprocess that can be triggered while the associated task is being performed. As the name suggested, <em>Error Boundary Event</em> will listen for any errors being thrown out of associated activity, and if the thrown error code matched with its definition, it will alter the flow and start executing its attached flow.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aCxcHLT4aj5b_mLHBmXSNw.png" /><figcaption>Error Boundary Event</figcaption></figure><p>The above process retrieves the contact details by calling some service or REST API. User selects the contact to which he/she wants to send the mail. The service task “<em>Prepare for Mail” </em>validates the input, checks whether the email address is blank or empty, if so, it throws a <a href="https://flowable.com/open-source/docs/javadocs/org/flowable/engine/delegate/BpmnError.html">BpmnError</a>. I have attached the Error boundary event with Error Code <strong>WRONG_EMAIL_DETAILS</strong>, which matched with one thrown from our java code below.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1820883e90547f529e361cb0cbc3d4b1/href">https://medium.com/media/1820883e90547f529e361cb0cbc3d4b1/href</a></iframe><p>You can see a similar pattern used in the implementation of <a href="https://documentation.flowable.com/latest/develop/be/service-registry/#docsNav">Service Registry</a> —</p><blockquote>The service registry is a feature of Flowable Enterprise offering which allows you to invoke any REST API or Java beans using modeler friendy UI.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/507/1*O8yaZC1uos6EC7Kls2LCWg.png" /><figcaption>Error handling in service registry</figcaption></figure><p>In workflow above “<em>Call HTTP Service” </em>is a service registry that calls a REST endpoint. Service registry allows you to handle HTTP status codes via a property called “<em>Handle status codes</em>”. You can specify the HTTP status codes you want to handle e.g. 404 and when flowable encounters the error, it will throw a BpmnError with prefixing <strong>Service</strong> to status code, e.g. Service404.</p><h3>3. Use Internal Transactions</h3><h4>Context</h4><p>You want to handle exceptions arising after activity executions.</p><h4>Problem</h4><p>In case of exceptions you don’t want to complete an activity but to roll back the transaction to a previously known state.</p><h4>Forces</h4><ul><li>You need to validate user inputs.</li><li>You need to validate the service response.</li></ul><h4>Solution</h4><p>The Flowable workflow engine executes the workflow steps in clearly identifiable database transactions. If in any step exception occurs, it rollbacks all executed activities and comes back to its original state. As this is well tested and guaranteed behavior from the engine, we can leverage it to handle scenarios like</p><ul><li>User uploads the file in <em>User task. </em>We need to check the contents of the files, and if they are not OK, we will show an error message to a user.</li><li>When a user submits data, we will persist that data to the database. If an error occurs we will ask users to retry.</li></ul><p>There is a very good blog post from Flowable about database transactions and <a href="https://blog.flowable.org/2018/07/03/demystifying-the-asynchronous-flag/">asynchronous flags</a>. You must check it out to get more insight about working.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/484/1*yCCOyGejS_wPS1DhxEti9Q.png" /><figcaption>Using Internal Transactions</figcaption></figure><p>Once a user submits the <em>Upload File </em>user task, the flowable engine will create the new transaction starting from the end of the user task and execute <em>the “Validate Output” service task. </em>The service task code is —</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/359e9370812ce2212e755d9fb0c997f1/href">https://medium.com/media/359e9370812ce2212e755d9fb0c997f1/href</a></iframe><p>Notice when the ExcelValidator#validate method returns false, we throw FlowableIllegalArgumentException which results in the rollback of the current transaction. The flowable engine is configured to display the exception message on the form as below —</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/930/1*p4FdCaiKcgYT6CG81eMIFg.png" /></figure><h4>Consequences</h4><p>This approach allows you to use internal transactions for rolling back to previous stages. But it does not do anything to handle the side effects of executed activities. E.g. You have a cash transfer process, wherein in the first step, you debit the amount and in the next step, you credit the amount. But at the second stage, if the transaction fails, you are left in the inconsistent stage as you have not credited the money back into the debitor’s account.</p><p>To handle side effects you need to use compensations.</p><h3>4. Compensation (BPMN 2.0)</h3><p>The BPMN 2.0 transactions and compensation allow for compensating already executed actions during rollbacks.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/197/1*jEBiDEOcyOA-i8LIMSSLPw.png" /></figure><h4>Context</h4><p>You are creating a transactional process, where activities produce side effects.</p><h4>Problem</h4><p>You need to compensate for the side effects of the failed activities in transactions in case of failure.</p><h4>Forces</h4><ul><li>The workflow is transactional.</li><li>Workflow steps create side effects in the system.</li><li>The workflow engine is BPMN 2.0 compliant.</li></ul><h4>Solution</h4><p>Compensation is concerned with undoing steps that were already successfully completed because their results and possible side effects are no longer desired and need to be reversed. If an Activity is still active, it cannot be compensated, but rather needs to be canceled. Cancellation in turn can result in compensation of already successfully completed portions of an active Activity, in case of a Sub-Process. Compensation is performed by a compensation handler. A compensation handler performs the steps necessary to reverse the effects of an Activity. In the case of a Sub-Process, the compensation handler has access to Sub-Process data at the time of its completion (“snapshot data”).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/62/1*NOxb6b1rQhUQrcfkDg2dpA.png" /><figcaption>Throw Compensation Event</figcaption></figure><p>Compensation is triggered by a <strong>Throw Compensation Event </strong>, which typically will be raised by an error handler, as part of cancellation, or recursively by another compensation handler. That Event specifies the Activity for which<br>compensation is to be performed, either explicitly or implicitly.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/54/1*GLmgPrQqRLmfT8OvHFDhpg.png" /><figcaption>Compensation Boundary Event</figcaption></figure><p>The compensation boundary event activates when the attached activity is finished. When a compensation event is thrown, it executes the attached logic.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/745/1*6xiPwqiAHi1xp4XHItqirw.png" /><figcaption>Transaction and Compensation Handling</figcaption></figure><p>In the example above, when the “<em>T</em>rigger Cancellation” event is thrown, the compensation activities namely “<em>Undo Book Hotel</em>” and “<em>Undo Book Flight</em>” get executed as many times as their host activities. This allows you to write to compensating logic to undo the work done by the host activities.</p><p>Covering all the details about compensation will require another blog post. I will add the link once I write one.</p><h3>5. Handling errors form child process</h3><h4>Context</h4><p>Your workflow contains multiple subprocesses which complete in an error state.</p><h4>Problem</h4><p>The subprocesses sometimes end with an Error end event and the callee process needs to take action based on the error state.</p><h4>Forces</h4><ul><li>Subprocesses end with “Error End Event”</li></ul><h4>Solution</h4><p>It’s always a good practice to denote all states of workflow. This approach is advocated while creating a re-usable process. E.g if you create the KYC process, it may complete in an error state, when documents are not correct. In this case, you want to propagate the message to the caller, and it needs to divert flow accordingly. To handle this scenario, you end the subprocess with “Error end event”.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/531/1*oj7ZW3h6Sngdivf4rOuoUQ.png" /><figcaption>Child Process ending with Error End Event</figcaption></figure><p>You need to use the same error code as the child process to configure the “Error Boundary Event” of <em>Call Activity.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/559/1*dhHFBgaItpOTVClZnJ-1wA.png" /><figcaption>Parent Process with Error Boundary Event</figcaption></figure><p>In this blog post, I tried to cover the most followed patterns of error handling with some examples. I hope you liked it. Let me know your favorite pattern in the comments.</p><p>The above patterns allow the modeler to choose the correct implementation of handling error. But what if you are a support engineer or a platform developer and you want to track exceptions coming out of the engine or jobs created in the workflow? If you are curious, wait for my next blog post, where I will write about how to monitor and manage the jobs.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c30025d9da2b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[BPMN, CMMN, and DMN — Triple Crown of Process Improvement Standards]]></title>
            <link>https://im-pratham.medium.com/bpmn-cmmn-and-dmn-triple-crown-of-process-improvement-standards-6254e9a083f8?source=rss-91da0a5c7c31------2</link>
            <guid isPermaLink="false">https://medium.com/p/6254e9a083f8</guid>
            <category><![CDATA[businessprocessautomation]]></category>
            <category><![CDATA[dmn]]></category>
            <category><![CDATA[flowable]]></category>
            <category><![CDATA[bpmn]]></category>
            <category><![CDATA[cmmn]]></category>
            <dc:creator><![CDATA[Prathamesh Mane]]></dc:creator>
            <pubDate>Sun, 06 Jun 2021 14:12:06 GMT</pubDate>
            <atom:updated>2021-06-07T07:00:30.960Z</atom:updated>
            <content:encoded><![CDATA[<h3>BPMN, CMMN, and DMN — Triple Crown of Process Improvement Standards</h3><p>In the previous post <a href="https://im-pratham.medium.com/business-process-automation-solution-then-and-now-2d3fbe05586f?source=your_stories_page-------------------------------------"><strong>Business Process Automation Solution — Then and now</strong></a>, we discussed briefly about the process automation history and what are the various modelling techniques available.</p><p>One of the widely used trio for process modeling is being BPMN, CMMN and DMN. They are often addressed as <a href="https://www.omg.org/intro/TripleCrown.pdf"><strong>Triple Crown of Process Improvement Standards</strong></a>.</p><p>In simple words, these standards can be termed as -</p><ul><li>BPMN — is about the processing</li><li>CMMN — is about managing</li><li>DMN — is about deciding</li></ul><p>When I started working in this field, the first question that came to mind is why there multiple standards for doing one thing? and how I can use them? Then I heard the same question from new modelers and professions out there. So let me clear out all the doubts here.</p><p>Let’s first discuss, why people ask these questions. As you can see in the Image: BPMN and CMMN Palette, there is clearly overlap between palettes such as user tasks, service tasks, etc. That adds the first seed of doubt in the user’s mind. The second is because a business process can be modeled using both CMMN and BPMN standards if you want so [2].</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*h88qx4litViDeTxuMayAxw.jpeg" /><figcaption>Image: BPMN and CMMN Palette.</figcaption></figure><p>Let’s now dig a bit deeper into each standard with an example. I will be presenting “Mutual Fund Investment Case”. The case starts when an investor approaches his/her Relation Manager (RM) and starts investing in AMC’s popular investment theme. I will explain each part in more detail with our 3 crowns.</p><h4><strong>BPMN</strong></h4><p>BPMN is used in scenarios where the business processes have a strict or a predefined flow. Every instance of a process differs from each other slightly. Consider below <strong><em>First Investment Process</em></strong>. When a client starts investing in a Mutual Fund (MF) solution, RM enters his/her details in the system. Based on whether the investore is a new customer or an existing one, we may need to consult the KYC officer for background checks, that is what I call a slight deviation in execution. But whatever might be the situation, we always follow predefined steps for the first investment, namely “Enter details” → “Verify” → “Allocate NAV”. We can’t directly allocate NAV without first entering user details in the system.</p><p>So if you have this kind of scenario, then you must go with BPMN.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/931/1*8hVjnY3ckvAE4eFmjT4jHw.png" /><figcaption>BPMN: First Investment Process</figcaption></figure><p>BPMN is a prescription-description model.</p><h4><strong>CMMN</strong></h4><p>CMMN aims to model things that are not fixed at the start of the situation. Hence you cannot define the work efforts when the case is initiated. The flow of the process largely depends upon the <em>knowledge workers</em>. As the name suggests, these are the participants in a case who possesses knowledge of underlying business use case. Knowledge workers can choose the path based upon information available in the case at a given moment.</p><p>CMMN typically allow you to model cases based upon Event (E) → Condition (C )→ Action (A) way e.g. you can model case when if particular events occur in context, calls some activities. Other options are also possible like E → A or C → A or simple A, which allows you to model how you react to the situation. In diagram below, when <em>Close Application (E) </em>event occurs, we <em>Close (A) </em>the case.</p><p>Let us see the bigger picture now. Our “Mutual Fund Case”.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/555/1*0Up6ksQskVs9Xx0JVDdizw.png" /><figcaption>CMMN: Mutual Fund Case</figcaption></figure><p>The outermost rectangle, with the little rectangle on top, that’s a <em>case plan model</em>, depicting the name of the case. It defines the boundary for all your plan items. Inside it, we have 3 smaller rectangles called stages — “Folio Creation”, “Folio Management” and “Folio Closure”. They roughly denote the 3 stages of our investor’s folio. Based upon which stage you are, you can do different things.</p><p><strong>Folio Creation — </strong>It contains a <em>Process Task, see </em><strong><em>BPMN: First Investment Process</em></strong><em>, </em>which is responsible for folio creation of investor. If suppose there is any issues with user’s account or KYC, a case participant can forcefully close the case. The double rounded circle enclosing human, <em>called User Event Listener, </em>connects to black filled diamond called as “<em>Exit Sentry</em>” to denote closure of the attached case.</p><p><strong>Folio Management — </strong>Now you will be in a position to tell, what this stage encloses. It has 3 <em>process tasks, SIP investment, Lumpsum investments, and Update nominee process. </em>Pay attention to retro styled icons similar to media controllers at bottom of each task😉. The <em>SIP Investment </em>task has one hollow diamond (<em>Entry Sentry</em>) defining this can only be activated in case of certain conditions holds. In our case, we want to allow to invest in SIP, only if he/she has chosen the same investment type at the time of onboarding. The same entry sentry is missing on lumpsum investment because it makes sense to allow the user to make lumpsum investment irrespective of investment type.</p><p>Coming back to our media controllers, the play icon ▶ tells that, the given task can be activated by knowledge workers if they want. and a ||| icon tells that a given task can be called multiple times. So combining our newfound knowledge, we can say that, <em>Update Nominee </em>process can be manually activated by the user if they want, multiple times.</p><p><strong>Folio Closure — </strong>So our user has made a lot of investments, encashed huge profit, and he wants to close his/her portfolio. Now we want to calculate the final amount, deduct taxes and other fees, and disburse cash to the client.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/932/1*7cVqs03xddp2Awy-xflAxA.png" /><figcaption>BPMN: Folio Closure Process</figcaption></figure><p>Look at the first activity, <em>Calculate Capital Gain Task. </em>This is our third crown, called <strong>Decision Task, </strong>using following <strong>DMN </strong>rules.</p><h4>DMN</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yDivzsSt7AxLzP-ECcNYuA.png" /><figcaption>DMN: Capital Gain Calculator</figcaption></figure><p>The DMN, or <em>Decision Model and Notation</em>, is for the precise specification of business decisions and rules. The blue left-hand side denotes inputs to the DMN model and the RHS side denotes output if a rule matches. The top-left side denotes a letter <strong>“F”, </strong>specifying <em>First Hit Policy, </em>where the output of the first satisfying rule is returned. The rules are read from top to bottom and left to right. First rules say if Capital gain is less than (&lt;) 100k, and the investment period is more than or equal to (≥) 12 months, then gain falls under LTCG (long-term capital gain) and the effective tax rate is nil. 2nd rule says, if you gain more than 100k for an investment horizon of more than 1 year, you need to pay an effective tax rate of 15%. And for scenarios, which do not satisfy former rules, must be considered as short-term gain, and you are taxed 20%.</p><h4>So what’s the conclusion?</h4><p>There is a great presentation[1] which I liked. Here is the excerpt from it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/638/0*Dr038wsjuJZkcbs3" /></figure><p>What it says,</p><ul><li>When you have only a slightly variable process use BPMN.</li><li>If unpredictable, mix BPMN with CMMN.</li><li>If emergent, use CMMN.</li><li>DMN can be used with both CMMN and BPMN to model decision tasks in all scenarios wherever applicable.</li></ul><p>If we now look back to <strong>Mutual Fund Investment Case, </strong>we can see why I modeled it as a case and not a process. The first check I do while deciding is, whether a whole workflow can be split into different lifecycle stages, and can the knowledge workers’ ability to manipulate workflow changes based upon which stage he/she is in. CMMN allows us to model such kinds of things very easily. Our case has 3 distinct stages and each stage gives different abilities to users like in the<em> Folio Creation </em>stage, you can forcefully terminate the case, and so.</p><p>The second guideline says if your flow is emergent, meaning the flow can be divided into smaller parts that follow a predefined structure (like in “<strong>Folio Closure Process</strong>”, you calculate gains, generate receipts and disburse funds) but some parts cannot be fixed into “Strict Flow”. Take an example of the 2nd stage, “<em>Folio Management</em>”, a user can choose to either do investment (SIP or Lumpsum) or he can update the folio nominees. But there is no precedence of steps. He can first update the nominee or then choose to do investment or vice versa. As again, this scenario can be modeled using BPMN, but case modeling makes it easier.</p><p>The 3rd guideline I always follow, when the case at the top level is, I don’t provide unnecessary details. All minute details must be handled by child subprocesses.</p><p>So, till now what we understood that these 3 standards are not competitors but they complement each other. As we got this right, let us look at when to intervene these standards.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/638/0*VHG5P8Jx_a7UEfC4" /></figure><p>The left-hand side of the + operation demonstrates the modeling standard you are using currently and the right-hand side of ➡ shows which standard to use to replace the right-hand side of the + operation.</p><ul><li>Rule 1 — When you are currently using BPMN and there are a lot of gateways for modeling the decision logic, then replace the gateways with DMN.</li><li>Rule 2 — If you are modeling a process with lots of events and exception handling, you should go with a CMMN as it is best used to design event handling.</li><li>Rule 3 — As a thumb of rule, if you are in BPMN, and you are using Ad-hoc subprocesses, replace ad-hoc tasks with CMMN. This is applicable also when you are modeling state transition scenarios,</li><li>Rule 4 — If there is a part of the case, where you are defining a scenario to call one task when the other completes and so, then you should probably chop off those parts into the BPMN process.</li></ul><p>Hope I am able to clear all you doubts and present how BPMN, CMMN and DMN can be used together to develop efficient bussiness processes.</p><h4>References</h4><ul><li>[1] Slide which I referred in conclusion —<a href="https://www.slideshare.net/dgagne/bpmncmmndmn-an-intro-to-the-triple-crown-of-process-improvement-standards-denis-gagne"> https://www.slideshare.net/dgagne/bpmncmmndmn-an-intro-to-the-triple-crown-of-process-improvement-standards-denis-gagne</a></li><li>[2] Great guide to learn more about BPMN and CMMN — <a href="https://methodandstyle.com/bpmn-cmmn-compared/">https://methodandstyle.com/bpmn-cmmn-compared/</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6254e9a083f8" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Business Process Automation Solution — Then and now.]]></title>
            <link>https://im-pratham.medium.com/business-process-automation-solution-then-and-now-2d3fbe05586f?source=rss-91da0a5c7c31------2</link>
            <guid isPermaLink="false">https://medium.com/p/2d3fbe05586f</guid>
            <category><![CDATA[businessprocessautomation]]></category>
            <category><![CDATA[bpmn]]></category>
            <category><![CDATA[workflow-automation]]></category>
            <category><![CDATA[flowable]]></category>
            <dc:creator><![CDATA[Prathamesh Mane]]></dc:creator>
            <pubDate>Sun, 30 May 2021 13:03:53 GMT</pubDate>
            <atom:updated>2022-02-28T07:37:25.132Z</atom:updated>
            <content:encoded><![CDATA[<h3>Business Process Automation Solution — Then and now.</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*aYCk1bHhq6MHRBb-.png" /></figure><p>I will be writing series of blog posts focused on Business Process automation, standards like BPMN, CMMN and DMN, and most importantly my experience about deploying one such solution in large organization using Flowable.</p><p>I will keep updating this index for easier navigation.</p><p>Part 1 — <a href="https://im-pratham.medium.com/business-process-automation-solution-then-and-now-2d3fbe05586f">Business Process Automation Solution — Then and now (This)</a></p><p>Part 2 — <a href="https://im-pratham.medium.com/bpmn-cmmn-and-dmn-triple-crown-of-process-improvement-standards-6254e9a083f8">BPMN, CMMN, and DMN — Triple Crown of Process Improvement Standards</a></p><h4>Why we need Business Process Automation Solution?</h4><p>The term “Process automation” dates long back to the industrial revolution when due to increased demand and competition company owners and managers were looking for a solution to minimize cost. We all know about the story of Henry Ford and how we revolutionized the auto industry by introducing assembly lines. Rather than one person is responsible for overall quality, the responsibility is shouldered upon a group of people who coordinate to create a quality product.</p><p>Fast forward to the so-called Digital era, when each business is coming online, they needed a similar solution to encode the business processes into code, so that rather than human manager looking over assembly line, some intelligent system will guide other system components. And that leads to multiple business process automation solutions.</p><p>Let’s take the example of the visitor management system. When you visit an industrial zone, you are required to present your id-card, your appointment letter, and to whom you want to meet. Based upon the information provided, the operator will hand over you security access, or entry pass. Once you do all your work and return your access will be revoked. If you want to develop a solution to address this, you need to write a fully functional application, but what your business tells you to modify your solution to handle visitor management of residential zone, then it becomes somewhat harder (it’s still possible to manage this use case) for you to reuse your custom build code. The intention is just let you give a sense about we need a solution to manage business use case which can handle a wide variety of scenarios in a consistent way.</p><p>One of the ways to handle the above use case is via Business Process Modeling Notation, a multi-vendor standard maintained by OMG (Object Modelling Group). As the name suggests, it’s a standard to model your business processes using graphical notations.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*knHx8nuLPpJ6pv-AjI00RA.png" /><figcaption>Visitor Management Process BPMN</figcaption></figure><h4>How to model business processes?</h4><p>There are different business process modeling techniques each focusing on one particular aspect of modeling.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Orh3x2jwqh4L8wE_nEYHuw.png" /><figcaption>Different Modeling Technique Perspectives</figcaption></figure><h4>Conclusion</h4><p>The workflow modeling techniques are present since the 19th century, while the newest additions being CMMN and BPMN in the first decades of the 20th century. These solutions came a long way from monoliths to becoming a low code platform, so that the technical team can focus on optimizing workflows, finding insights from data, and reporting rather than writing and maintaining the solution from scratch.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2d3fbe05586f" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>