<?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 Shivang Shandilya on Medium]]></title>
        <description><![CDATA[Stories by Shivang Shandilya on Medium]]></description>
        <link>https://medium.com/@shivangblogs?source=rss-2eb9381199cf------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*bRaK04EgcSGO7LOz1fv3TQ.jpeg</url>
            <title>Stories by Shivang Shandilya on Medium</title>
            <link>https://medium.com/@shivangblogs?source=rss-2eb9381199cf------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 08:51:23 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@shivangblogs/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[Everything you need to know about Prometheus as a Beginner]]></title>
            <link>https://medium.com/@shivangblogs/everything-you-need-to-know-about-prometheus-as-a-beginner-974ccbc5477c?source=rss-2eb9381199cf------2</link>
            <guid isPermaLink="false">https://medium.com/p/974ccbc5477c</guid>
            <dc:creator><![CDATA[Shivang Shandilya]]></dc:creator>
            <pubDate>Sun, 14 Dec 2025 05:32:36 GMT</pubDate>
            <atom:updated>2025-12-15T06:39:50.120Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VIILjtmqneSEbkNAMcMZpw.png" /></figure><p>This is my next entry in <strong>“Everything you need to know as a Beginner” series </strong>where today I’ll be talking (i mean writing) about <strong>Prometheus (and no I’m not talking about the Olympian Titan here). <br></strong>Before we dive in let’s quickly look at a few prerequisites. They’re good to know, but not strictly necessary for reading this blog.</p><h4>📍Prerequisites</h4><p>So according to me the only thing I would say you need is to really understand the concept of <strong>Observability</strong> and what are <strong>Signals</strong> especially <strong>Metrics </strong>in this case.</p><p>But fear not as always I’m here for the rescue, apologies in advance for the shameless plug but I recently uploaded a video on my <strong>YT channel</strong> talking in-depth about <strong>“What is Observability?”</strong> so I would like to urge complete newbies to this concept to first watch the video and then come back here.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FldfmhFtUxZM%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DldfmhFtUxZM&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FldfmhFtUxZM%2Fhqdefault.jpg&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/d0c5ee6a0bc4a130a8e9c14d90221f02/href">https://medium.com/media/d0c5ee6a0bc4a130a8e9c14d90221f02/href</a></iframe><p>But if you just wanna read this Blog and get it over with I totally understand that so I’ll briefly touch upon<strong> Observability</strong> and <strong>Metrics</strong> here as well.</p><h4>📍What exactly is Observability?</h4><p>Told ya! Its a really crucial and important topic so I can’t really start talking about <strong>Prometheus</strong> without talking about <strong>Observability.</strong></p><p>Observability in layperson terms lets you understand a system from the outside by letting you ask questions about that system without knowing its inner workings. This allows us to ask questions like<strong> “Why is this happening?”. </strong>Now in order to ask this question our application needs to be instrumented that is it must emit <strong>signals</strong> such as <strong>metrics, traces and logs.</strong></p><p>The more observable a system, the more quickly and accurately IT teams can shift from an identified performance issue to its root cause, without extra testing or coding.</p><p>Hopefully, you got the gist of Observability (<strong>please say you did!</strong>)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/352/0*b_JbhsvemivLCzFl.gif" /></figure><h4>📍What are Metrics?</h4><p><strong>Metrics</strong> capture the <strong>numeric measurements</strong> used to quantify the performance and health of services, these assist in analyzing performance across time, providing much-needed insight into your systems and performance.</p><p>Often, observability metrics are used for:</p><ul><li><em>Key performance indicators (KPIs)</em></li><li><em>CPU capacity insights</em></li><li><em>Memory monitoring</em></li><li><em>System health and behavior</em></li></ul><p>This empowers organizations to establish a baseline of what <strong>“normal”</strong> performance looks like and set goals for future performance so if our system ever deviates from our expectations we’ll know.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/860/0*rqhbYPKGEwXt5PYg" /><figcaption>Visualization of Metrics by Grafana</figcaption></figure><h4>🔥Prometheus</h4><p>Finally! Let’s see what Prometheus is all about.</p><p><strong>Prometheus</strong> is an open-source systems monitoring and alerting toolkit originally built at<strong> </strong><a href="http://soundcloud.com/"><strong>SoundCloud</strong></a>. Prometheus later joined <a href="https://www.cncf.io/"><strong>CNCF</strong></a> in 2016 as the second hosted project, after <a href="http://kubernetes.io/"><strong>Kubernetes </strong></a><strong>.</strong></p><p>Prometheus collects and stores its metrics as <a href="https://prometheus.io/docs/concepts/data_model/"><strong>time series</strong></a><strong> data, i.e. metrics</strong> information is stored with the timestamp at which it was recorded, alongside optional key-value pairs called <strong>labels</strong>.</p><h4>📍Why should we use Prometheus?</h4><p>Hmm, Shivang we’re still not sold on <strong>Prometheus</strong> like what makes it special that so many companies and organizations have adopted it?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/480/0*901hVuSVUQah3xmj.gif" /></figure><p>And I’m here to answer it. Let’s talk about some of the amazing features <strong>Prometheus</strong> has, that makes it stand out from the crowd:</p><ul><li><em>a </em><strong><em>multi-dimensional </em></strong><a href="https://prometheus.io/docs/concepts/data_model/"><strong><em>data model</em></strong></a><em> with time series data identified by metric name and key/value pairs</em></li><li><strong><em>PromQL</em></strong><em>, a </em><a href="https://prometheus.io/docs/prometheus/latest/querying/basics/"><em>flexible query language</em></a><em> to leverage this dimensionality</em></li><li><em>no reliance on </em><strong><em>distributed storage</em></strong><em>; single server nodes are autonomous</em></li><li><em>time series collection happens via a pull model over HTTP</em></li><li><a href="https://prometheus.io/docs/instrumenting/pushing/"><em>pushing </em><strong><em>time series</em></strong></a><em> is supported via an intermediary gateway</em></li><li><em>targets are discovered via service discovery or static configuration</em></li><li><em>multiple modes of graphing and dashboarding support</em></li></ul><p><strong>WOAH!</strong> I think these should be enough to answer your question, they were definitely for me.</p><h4>📍Architecture</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*d2b_Q2Y-lGZEMR31qmexSg.png" /><figcaption>Prometheus Architecture</figcaption></figure><p>Remember how in the start I talked about how your app must be <strong>instrumented</strong>, yup Prometheus scrapes metrics from these instrumented jobs via an<strong> intermediary push gateway for short-lived jobs.</strong> It stores all scraped samples locally and runs rules over this data to either aggregate and record new time series from existing data or generate alerts.</p><p>And as shown in a pic above we can use tools like <strong>Grafana</strong> to visualize our collected data. Some of the main components shown in architecture are as follows:</p><ul><li><em>the main </em><a href="https://github.com/prometheus/prometheus"><strong><em>Prometheus server</em></strong><em> </em></a><em>which scrapes and stores time series data</em></li><li><a href="https://prometheus.io/docs/instrumenting/clientlibs/"><strong><em>client libraries</em></strong></a><em> for instrumenting application code</em></li><li><em>a </em><a href="https://github.com/prometheus/pushgateway"><strong><em>push gateway</em></strong><em> </em></a><em>for supporting short-lived jobs</em></li><li><em>special-purpose </em><a href="https://prometheus.io/docs/instrumenting/exporters/"><strong><em>exporters</em></strong></a><em> for services like HAProxy, StatsD, Graphite, etc.</em></li><li><em>an </em><a href="https://github.com/prometheus/alertmanager"><strong><em>alertmanager</em></strong><em> </em></a><em>to handle alerts</em></li></ul><h4>📍PromQL</h4><p>Prometheus provides a functional query language called <strong>PromQL (Prometheus Query Language)</strong> that lets the user select and aggregate time series data in real time.</p><p>When you send a query request to Prometheus, it can be an <em>instant query</em>, evaluated at one point in time, or a <em>range query</em> at equally-spaced steps between a start and an end time. You can read more about PromQL in-depth <a href="https://prometheus.io/docs/prometheus/latest/querying/basics/"><strong>here</strong></a>.</p><p>An example of a PromQL query would look something like this:</p><pre>prometheus_http_requests_total{code=~&quot;2.*&quot;, job=&quot;prometheus&quot;}</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*RcCxvXWGyJcs5B3e.png" /></figure><h4>📍Installation and Setup</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/480/0*6IgJN9r_1uv_MgxV.gif" /></figure><p>Ok Ok calm down, I know you’re excited to <strong>instrument</strong> your app and use <strong>Prometheus</strong> ASAP but first let’s take a moment and see how we can Install and Setup it in our machine.</p><h4>Using pre-compiled binaries</h4><p>First, grab the latest version of Prometheus for your operating system from the <a href="https://prometheus.io/download/"><strong>Prometheus downloads page</strong></a><strong>.</strong> Unzip the <a href="https://prometheus.io/docs/guides/file-sd/"><strong>file</strong></a> and move the Prometheus program into a spot where your computer can find and run it, like <strong>/usr/local/bin.</strong></p><h4>Using Docker</h4><p>If you prefer using Docker, you can start Prometheus with a command like this:</p><pre>docker run -p 9090:9090 -v /path/to/prometheus.yml:/etc/prometheus/prometheus.yml prom/prometheus</pre><p>All Prometheus services are available as Docker images on <a href="https://quay.io/repository/prometheus/prometheus"><strong>Quay.io</strong> </a>or <a href="https://hub.docker.com/r/prom/prometheus/"><strong>Docker Hub</strong> </a>. The above command makes Prometheus available on port <strong>9090 </strong>and uses your config file.</p><ul><li><strong>Configure Prometheus:</strong> Prometheus needs a file (in YAML format) that tells it what to keep an eye on and how. You can learn how to set this up by checking the <a href="https://prometheus.io/docs/prometheus/latest/configuration/configuration/"><strong>Prometheus Configuration documentation</strong></a><strong>.</strong></li><li><strong>Set up storage:</strong> Prometheus collects lots of data over time, so it needs a place to store it. You can use <strong>local storage</strong> or look into options like <a href="https://thanos.io/"><strong>Thanos</strong></a> or<strong> </strong><a href="https://www.cortex.io/"><strong>Cortex</strong></a><strong> </strong>for keeping data longer.</li></ul><h4>📍Contributing</h4><p>Now wait did I tell y’all that <a href="https://github.com/prometheus">Prometheus</a> was <strong>Open Source</strong> (<strong>ofc I did</strong>) which means you can start contributing to it (<strong>Yipeee!</strong>)</p><p>But before you go creating new <strong>Issues and PRs</strong> in a <a href="https://github.com/prometheus">Prometheus</a> repository, it is my humble request to all readers (as a self-proclaimed <strong>Open Source Advocate</strong>) do go through the <strong>CONTRIBUTING.md</strong> file first in the respective Prometheus repository for instructions on how to submit changes to avoid any confusions later.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jWmWZj-hLAiNMAiFM8TrBg.png" /></figure><p>You can even hop in the community #prometheus-dev on <strong>CNCF </strong><a href="https://slack.cncf.io/"><strong>Slack </strong></a><strong>.</strong></p><h4>📍Conclusion</h4><p>In summary, Prometheus is designed for <strong>reliability,</strong> to be the system you go to during an outage to allow you to quickly <strong>diagnose problems</strong>. You can rely on it when other parts of your infrastructure are broken, and you do not need to setup <strong>extensive infrastructure</strong> to use it.</p><p>I hope you got the gist of what Prometheus is all about and I highly recommend checking out the <a href="https://prometheus.io/docs/introduction/overview/"><strong>official docs</strong></a> and testing out Prometheus yourself, try scraping metrics from your app and see the magic unfold.</p><p>That’s all for now but we’ll meet again soon in our next blog.<br>Till then you can follow me on <a href="https://www.linkedin.com/in/shivang-shandilya/"><strong>LinkedIn</strong></a><strong> and </strong><a href="https://x.com/shiryutwts"><strong>X</strong></a>. Adios!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/498/0*GvR9J-MuxwsvMe3r.gif" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=974ccbc5477c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Bhindi AI — Agentic Execution on Steroids]]></title>
            <link>https://medium.com/@shivangblogs/bhindi-ai-agentic-execution-on-steroids-7b5910b3acd6?source=rss-2eb9381199cf------2</link>
            <guid isPermaLink="false">https://medium.com/p/7b5910b3acd6</guid>
            <dc:creator><![CDATA[Shivang Shandilya]]></dc:creator>
            <pubDate>Tue, 02 Dec 2025 05:02:30 GMT</pubDate>
            <atom:updated>2025-12-05T04:46:07.212Z</atom:updated>
            <content:encoded><![CDATA[<h3>Bhindi AI — Agentic Execution on Steroids</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Rz-GemMWa9yYyVbzo5pKNQ.png" /></figure><p>We have all heard of the saying <em>“don’t step on two boats at once, or you’re bound to drown“</em> and yes it would make sense if you were using some other tool but that’s not the case with Bhindi. Bhindi lets you ride as many boats as you want at the same time, because it’s built to handle multiple apps, workflows, and tasks seamlessly so you can come out winning!</p><p><strong>Any SECRET SAUCE for this?</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/498/0*ktY57sBupsxqk8NM.gif" /></figure><p>Nah, Bhindi <strong>doesn’t just replace your tools</strong> — <strong>it helps you <em>use</em> them better.</strong> With Bhindi, you get a single place to connect with all your everyday tools, clear out the clutter, and finally focus on what matters.<br><strong>And here’s the fun part:</strong> it’s not just what Bhindi built for you, you yourself can build on top of Bhindi, going crazy and building something useful not just for yourself but also for the community with least friction possible.</p><p>But….let’s not get ahead of ourselves, let’s first understand what exactly Bhindi does?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/276/0*4nvsTAAy3zdYBAzi.gif" /></figure><h3>What’s Bhindi Anyway?</h3><p>Well Bhindi is not just another Chatbot, it’s the last app you need in your life before it all becomes a mess. Still a bit skeptical? I could go on writing pages about it, but at the end of the day, <strong>nothing beats seeing it in action</strong>.</p><p>Could we build a system that just needs one prompt to turn whatever’s trending on Reddit into a whole week of X posts? <strong>Bhindi can do that!</strong></p><iframe src="https://cdn.embedly.com/widgets/media.html?type=text%2Fhtml&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;schema=twitter&amp;url=https%3A//x.com/bhindiai/status/1940414101563592918%3Fs%3D20&amp;image=" width="500" height="281" frameborder="0" scrolling="no"><a href="https://medium.com/media/8d8073e2a1b317d877ac6b774f6f1856/href">https://medium.com/media/8d8073e2a1b317d877ac6b774f6f1856/href</a></iframe><p>But wouldn’t it be cool if some platform like Discord could handle everything in the background so you could just hang out? Yep, we think alike and that’s why <strong>Bhindi already runs Discord</strong> behind the scenes while you binge Netflix guilt-free.</p><iframe src="https://cdn.embedly.com/widgets/media.html?type=text%2Fhtml&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;schema=twitter&amp;url=https%3A//x.com/bhindiai/status/1955611644173943157%3Fs%3D20&amp;image=" width="500" height="281" frameborder="0" scrolling="no"><a href="https://medium.com/media/340c58e036a8ae4ae55671fc875cdbf0/href">https://medium.com/media/340c58e036a8ae4ae55671fc875cdbf0/href</a></iframe><p><strong>Bhindi is literally Agentic execution on Steroids!</strong></p><p><strong>How is Bhindi able to accomplish this?</strong> Bhindi gives you access to 200+ ready-to-use agents the moment you sign up . The agents are curated for various use-cases, so whatever your role is, you’ll find tools that click right away. And if you like to experiment, you can mix and match agents to design workflows that fit you perfectly.</p><p>Wanna know which agents Bhindi has available? Check out 📁<a href="https://directory.bhindi.io/"><strong>Bhindi Agents Directory</strong></a><strong>.</strong> You can check out the capabilities of each agent in the Bhindi Agents Directory. You don’t have to guess what Bhindi does and does not do. Here’s its <a href="https://directory.bhindi.io/google-gmail"><strong>Gmail agent</strong></a><strong> </strong>👇</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*lFeWzaIPbthnoPBI.png" /></figure><p>Remember I said how you can be your own chef and cook whatever you want aside from what Bhindi provides….well let’s talk about that now!</p><h3>Cook up your own Custom Agent</h3><h4>Still asking <a href="https://docs.bhindi.io/quickstart">Why Bhindi?</a>👇</h4><p>The first question that might arise is <em>“Why should we even build on Bhindi in the first place?”</em> And you know what it’s a <strong>fantastic question</strong> and I have got these <strong>4 fantastic reasons</strong> for you….(wait a min)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/498/0*hxtsMKgltkpGso9q.gif" /></figure><p>Alright, jokes aside — here are the reasons you’ll want to build on Bhindi:</p><ol><li>If you have ever written tools for LLMs, you will feel right in place!</li><li><strong>BCP — Bhindi Context Protocol </strong>is just that on steroids!</li><li>You connect with <strong>15+ OAuth apps</strong> out of the box.</li><li>You can focus on your idea and get it out before it becomes dead buried under other 99 dead ideas which you did not ship because some random setup issue took half of your day.</li></ol><h4><a href="https://docs.bhindi.io/development">Wanna build an agent but don’t know where to start?</a></h4><p>Worry not folks, as always Bhindi has got you covered, Bhindi has an entire <a href="https://docs.bhindi.io/development"><strong>documentation</strong></a> on how to create external agents that integrate with the system. Bhindi makes your tasks simpler, and its amazing documentation makes getting started even easier.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/500/0*4ORAF-LgLCAhOTHd" /></figure><h4><a href="https://docs.bhindi.io/connect">Bring your agent to Bhindi</a></h4><p>Once you’ve built and deployed your agent, you can easily integrate it with <a href="http://bhindi.io/"><strong>Bhindi.io</strong></a><strong> </strong>to make it accessible through the platform, as always Bhindi also has a detailed <a href="https://docs.bhindi.io/connect"><strong>documentation</strong></a> to guide you through the entire process.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/480/0*VEbfTPncHxbN6GUe" /></figure><h4>Integration Process</h4><ul><li>Start a new chat on <a href="http://bhindi.io/"><strong>Bhindi.io</strong></a> and just use the following message format:</li></ul><pre>Add my agent using Bhindi Agent Manager. The details are as follows:<br><br>id: my-special-calculator<br>name: Special Calculator<br>description: A powerful calculator that can perform complex mathematical operations and generate visualizations<br>endpoint: https://my-calculator-app-here.com</pre><ul><li>You can even add your agent with <a href="https://docs.bhindi.io/quickstart#available-oauth-integrations"><strong>OAuth Integration</strong></a>, for agents that need access to services like GitHub, Google, Discord, etc.</li></ul><pre>Add my agent using Bhindi Agent Manager. The details are as follows:<br><br>id: my-github-analyzer<br>name: GitHub Repository Analyzer<br>description: Analyzes GitHub repositories and provides insights<br>endpoint: https://my-github-analyzer.com<br>oauth: github, discord</pre><h4>Integration Support</h4><p>The <strong>Bhindi Agent Manager</strong> will guide you through the integration process and help resolve any issues during setup. <strong>With Variable Integration (Optional):</strong></p><ul><li>For agents that need access to variables like x-var-api-key or x-var, include variables in your agent registration:</li></ul><pre>Add my agent using Bhindi Agent Manager. The details are as follows:<br><br>id: my-app<br>name: My App Analyzer<br>description: Analyzes and provides insights for app<br>endpoint: https://my-app.com<br>variables: [{<br>   ref: “var-api-key”,<br>   name: “var Api Key”,<br>   description: “&lt;Your var API Key&gt;”,<br>   required: true<br>}],</pre><h3>Why do it all when <a href="http://bhindi.io/">Bhindi</a> can?</h3><iframe src="https://cdn.embedly.com/widgets/media.html?type=text%2Fhtml&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;schema=twitter&amp;url=https%3A//x.com/bhindiai/status/1963258163115045230%3Fs%3D20&amp;image=" width="500" height="281" frameborder="0" scrolling="no"><a href="https://medium.com/media/637a36cc80c72fad15a0f661e8cd94f5/href">https://medium.com/media/637a36cc80c72fad15a0f661e8cd94f5/href</a></iframe><h3>Wanna jam with Bhindi?</h3><ol><li><strong>Join the Community — </strong><a href="https://discord.gg/hSfTG33ymy"><strong>Discord</strong></a><strong> • </strong><a href="https://x.com/bhindiai"><strong>Twitter/X</strong></a><strong> </strong>— Bhindi is here to guide you in any way possible so that you can make the most out of it.</li><li><a href="https://github.com/upsurgeio/bhindi-agent-starter">🚀 <strong>Clone the Starter Kit</strong></a> — Build your first custom agent and Bhindi-Maxx your way out of boring stuff.</li><li>Chill! Bhindi has got your back!</li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7b5910b3acd6" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Everything you need to know about Kubernetes as a Beginner]]></title>
            <link>https://medium.com/@shivangblogs/unlocking-the-mysteries-of-kubernetes-cluster-architecture-0669f9e08b7c?source=rss-2eb9381199cf------2</link>
            <guid isPermaLink="false">https://medium.com/p/0669f9e08b7c</guid>
            <dc:creator><![CDATA[Shivang Shandilya]]></dc:creator>
            <pubDate>Sat, 01 Nov 2025 20:05:07 GMT</pubDate>
            <atom:updated>2025-12-04T17:24:21.622Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*MWdEdInjzIv4FiPt" /></figure><h4>📍Prerequisites</h4><p>Well before we begin with this blog on Kubernetes, you should at least know what Containers are, that according to me is an essential prerequisite cause if you’re learning about a Container Orchestration tool like Kubernetes and don’t have a good understanding of Containers then that doesn’t really make sense now does it?</p><p>Also don’t fret if you don’t know where to learn about Containers and all cause I have a dedicated <a href="https://medium.com/@shivangblogs/everything-you-need-to-know-about-docker-as-a-beginner-2fa928ed9a54"><strong>Blog on Docker</strong></a> that covers all these essential topics, you can first give that one read and then come back to this.</p><p>Also, one last thing before we begin, if you don’t like reading blogs and rather watch a video explaining all these concepts then fear not cause I have a YouTube video up on my channel on this very same topic that you can check out 🚀.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FqWOcXSYTq68%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DqWOcXSYTq68&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FqWOcXSYTq68%2Fhqdefault.jpg&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/2110554e9d55ac96254047f0f2d447ee/href">https://medium.com/media/2110554e9d55ac96254047f0f2d447ee/href</a></iframe><h4>📍What exactly is Kubernetes?</h4><p>Well Kubernetes is a <strong>“container-orchestration tool”</strong> and was created by Google in 2014, In simple terms, it makes it easier for us to manage containers by automating various tasks. As a matter of fact, K8s first created solely to help Docker. Docker was created way before Kubernetes or K8s was created, then K8s was created solely to orchestrate Docker but as K8s became popular other container runtimes such as rkt wanted to get involved.</p><h4>📍Why should we use Kubernetes in the first place?</h4><p>Well okay I get your point you’re reluctant on using Kubernetes, I would be too so let’s take two scenario.</p><p><strong>SCENARIO 1<br></strong>So if you read my <a href="https://medium.com/@shivangblogs/everything-you-need-to-know-about-docker-as-a-beginner-2fa928ed9a54"><strong>blog on Docker</strong></a>, then you must remember the <strong>Post Office example</strong> I gave to make you all understand what all Containers are. So now that we have our envelope ready with whatever application coded with any language. So now its the job of Post Office to deliver our envelope or container in a timely, effective and efficient manner to our destination right? Well while delivering our envelope there might be some cases such as flight got delayed or delivery partner faced some traffic while delivering but we don’t care about all those scenarios all we want is that my family and friends receive the envelope timely. Well the Post Office in this case is Kubernetes. Kubernetes makes it easier for us to manage containers and ensure that there is no downtime.</p><p><strong>SCENARIO 2<br></strong>Imagine a scenario where one of the containers in your operation experiences a shutdown. Restarting it manually is a simple task. However, envision a situation where a multitude of containers face downtime. Wouldn’t it be more convenient to have the system address this issue automatically? Kubernetes can manage such situations effortlessly. It offers various features, including scheduling, scaling, load balancing, fault tolerance, deployment, automated rollouts, rollbacks, and more.</p><p>So I hope you have got a pretty good idea on why we need Kubernetes.</p><h4>📍Let’s talk about Kubernetes Architecture now!</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/829/0*0FgYmKmE3HYkret3" /></figure><p>A master node in the Kubernetes architecture oversees other worker nodes. Worker nodes are nothing more than physical servers or virtual machines that operate in data centers. They make the application’s storage and network resources visible to it. Together, these nodes create a cluster that offers replication and fault tolerance.</p><p><strong>Master Node (Control Plane)</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*RYTumJXdPm7r93Py" /></figure><p>Let’s deep dive into Master Node: <br>In master node we have etcd cluster, kube-apiserver, Kube controller manager and kube-scheduler:</p><ul><li><strong>ETCD cluster</strong>: contains the info about the cluster.</li><li><strong>kube-scheduler:</strong> which is responsible for scheduling applications or containers on nodes.</li><li><strong>kube controller manager:</strong> kube Controller Manager is responsible for monitoring the state of the cluster and making necessary changes to ensure that the desired state is maintained. It includes controllers for nodes, endpoints, replication, and more. This ensures that the cluster is always running optimally and efficiently. It contains processes like node controller and replication controller.</li><li><strong>kube-api server: </strong>kube-api server acts like a gateway to K8s cluster. It receives requests from kubectl CLI tool or dashboard and communicates with etcd cluster to handle these requests. It also validates and authorizes these requests before processing them (basically orchestrates every action that take place in the cluster)</li></ul><p><strong>Worker Node</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/850/0*wq7msw540IdQ_j2c" /></figure><p>Let’s deep dive into Worker Node:</p><p>In worker nodes we have our kubelet, kube-proxy, pods and containers:</p><ul><li><strong>kubelet:</strong> listens to the instructions from the kube-api server and manages our containers.</li><li><strong>kube-proxy:</strong> enables communication between the services within the cluster.</li><li><strong>pods:</strong> A pod in Kubernetes (K8s) is the smallest and most basic unit of deployment. It represents a single instance of a running process in the cluster. A pod can contain one or more containers that share the same network and storage resources. Containers within a pod can communicate with each other using localhost, making it easier to manage and maintain dependencies between the containers. Pods are managed and scheduled by the K8s cluster, and they can be scaled horizontally to handle increased workload or traffic.</li></ul><p><strong>📍Installation of Kubernetes</strong></p><ul><li><strong>kubectl</strong></li></ul><p>The Kubernetes command-line tool, <a href="https://kubernetes.io/docs/reference/kubectl/kubectl/"><strong>kubectl</strong></a> allows you to run commands against Kubernetes clusters. You can use kubectl to deploy applications, inspect and manage cluster resources, and view logs. For more information including a complete list of kubectl operations, see the kubectl <a href="https://kubernetes.io/docs/reference/kubectl/"><strong>reference documentation.</strong></a></p><ul><li><strong>kind</strong></li></ul><p><a href="https://kind.sigs.k8s.io/"><strong>kind</strong></a> lets you run Kubernetes on your local computer. This tool requires that you have either <a href="https://www.docker.com/"><strong>Docker</strong></a> or <a href="https://podman.io/"><strong>Podman</strong> </a>installed. The kind <a href="https://kind.sigs.k8s.io/docs/user/quick-start/"><strong>Quick Start</strong></a> page shows you what you need to do to get up and running with kind.</p><ul><li><strong>minikube</strong></li></ul><p>Like <strong>kind, </strong><a href="https://minikube.sigs.k8s.io/"><strong>minikube</strong></a> is a tool that lets you run Kubernetes locally. <strong>minikube </strong>runs an all-in-one or a multi-node local Kubernetes cluster on your personal computer (including Windows, macOS and Linux PCs) so that you can try out Kubernetes, or for daily development work. You can follow the official <a href="https://minikube.sigs.k8s.io/docs/start/"><strong>Getting Started!</strong></a> guide if your focus is on getting the tool installed.</p><ul><li><strong>kubeadm</strong></li></ul><p>You can use the <a href="https://kubernetes.io/docs/reference/setup-tools/kubeadm/"><strong>kubeadm</strong> </a>tool to create and manage Kubernetes clusters. It performs the actions necessary to get a minimum viable, secure cluster up and running in a user friendly way. <a href="https://kubernetes.io/docs/setup/production-environment/tools/kubeadm/install-kubeadm/"><strong>Installing kubeadm</strong></a> shows you how to install kubeadm. Once installed, you can use it to <a href="https://kubernetes.io/docs/setup/production-environment/tools/kubeadm/create-cluster-kubeadm/"><strong>create a cluster</strong></a>.</p><h4>📍Conclusion</h4><p>In summary, <strong>Kubernetes, or K8s</strong>, is a powerful container orchestration platform essential for modern application management. Our exploration of its architecture, master and worker nodes, and installation process reveals a robust framework for automating and scaling containerized applications. With components like the kube api server and etcd cluster, Kubernetes streamlines deployment, making it a cornerstone in the realm of contemporary software development. <br>Whether you’re a seasoned DevOps professional or a newcomer, understanding Kubernetes is key to navigating the dynamic landscape of container orchestration. And I hope this blog helped you achieve that very same goal and gave you a bit of insight into what K8s is all about.</p><p>Well that’s all for now but we’ll meet again soon in our next blog. <br>Till then you can follow me on <a href="https://www.linkedin.com/in/shivang-shandilya/"><strong>LinkedIn</strong></a><strong> and </strong><a href="https://x.com/shiryutwts"><strong>X</strong></a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0669f9e08b7c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Everything you need to know about Helm as a Beginner]]></title>
            <link>https://medium.com/@shivangblogs/everything-you-need-to-know-about-helm-as-a-beginner-851124bc9f29?source=rss-2eb9381199cf------2</link>
            <guid isPermaLink="false">https://medium.com/p/851124bc9f29</guid>
            <dc:creator><![CDATA[Shivang Shandilya]]></dc:creator>
            <pubDate>Sat, 01 Nov 2025 19:46:01 GMT</pubDate>
            <atom:updated>2025-12-05T04:48:35.445Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MVDE63ePWoZNFMieO2hLDA.png" /></figure><h3>📌 Prerequisite</h3><p>Before we begin to understand what Helm is all about, I would recommend you to have basic understanding of what is Kubernetes. If you don’t have any idea about Kubernetes, you can go ahead and take a look at my <a href="https://mydevopsjourney.hashnode.dev/unlocking-the-mysteries-of-kubernetes-cluster-architecture">last blog</a> where I have explained about it in detail and if you don’t want read through all that then I also have a <a href="https://youtu.be/qWOcXSYTq68?si=z7xhnragmGiTrBmj">video</a> on the same on my <a href="https://www.youtube.com/@ShivangShandilyaa">YouTube channel</a> so do give that a watch!</p><h3>⚙️ So why do we need Helm?</h3><p>Well we all know how awesome Kubernetes is right? But let’s say we have to set up a WordPress site, then the deployment involves orchestrating various components, such as MySQL web servers, a persistent volume (PV) for database storage, PersistentVolumeClaim (PVC), a Service to expose the web server to the internet, and a Secret to store admin credentials, among other things like periodic backups and jobs.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*VYb4nvPzpjx0tyIR" /></figure><p><strong>P.S: I took the above image used in this blog from another blog post as it was so well created so props to the original creator for this.</strong></p><p>Each of these components requires a dedicated YAML file, and employing kubectl apply to create these objects can be a laborious process. Fast forward a few months, and if there&#39;s a need to upgrade components, meticulous editing of multiple YAML files becomes imperative. Similarly, uninstalling the application involves recalling and deleting each associated object individually—an undeniably tedious task.</p><p>What to do now??</p><h3>⚙️ Here comes HELM!!</h3><p>Helm makes the life so much easier for us. Well you might ask HOW? See Kubernetes doesn’t care about our application as a whole as even though we have created different objects for different components of our WordPress application, it considers them as a separate entity whole together.</p><p>The amazing thing is Helm is built from the ground up to know about such stuff. That’s why it’s sometimes called Package Manager for Kubernetes. It looks at those objects as a part of a big package as a group. Whenever we want to perform an action, we don’t tell Helm the objects it should look after rather we tell Helm it belongs to the WordPress package, and then on the package name, it then knows what object it should edit even if 100s of objects belong to that package!</p><p>So we don’t have to go around creating YAML files for every separate component of our application instead all we can do is this 👇🏼</p><pre>$ helm install wordpress</pre><p>Using Helm, we install our whole application using a single command even if it needs hundreds of objects. Helm proceeds to automatically add every necessary object to Kubernetes without bothering us about the details.</p><p>Obviously we can make changes to the default values but the thing is instead of making changes to hundreds of files we now have a everything at a single location making our job easier.</p><h3>⚙️ Helm 2 vs Helm 3</h3><h4>📌 Tiller and Helm 2</h4><p>Helm has a CLI client installed on your local machine that helps to perform Helm-specific actions against your Kubernetes cluster. When Helm 2 was launched, Kubernetes lacked features like RBAC(Role Based Access Control) and Custom Resource Definitions. To allow Helm to perform its actions, an extra component Tiller was installed in the K8s cluster. So, Whenever a user wanted to perform some Helm-specific action, It communicated with the tiller that was running on some server which in turn communicated with the K8s cluster and proceeded to take the action requested by the user. So, Tiller being the middleman added complexities to the cluster and gives rise to security concerns. By default, Tiller had the privilege to do whatever it wanted. This is good as it allows us to make all necessary changes in a K8s cluster to install charts. But this was also bad since anybody with Tiller access can do whatever they want.</p><h3>📌 How security concerns were resolved with Helm 3?</h3><p>After the introduction of Role Based Access Control (RBAC) and Custom Resource Definitions in Kubernetes, The need for Tiller decreased, so It was removed entirely in Helm 3. Now, nothing was sitting between the Cluster and Helm CLI, and security improved with RBAC as users can be limited with what they do with Helm. Before RBAC, we had to set these limits in Tiller which was not the best option but with RBAC built from the ground up to fine-tune permissions in K8s, it is pretty straightforward to do. As far as K8s is concerned, It doesn’t matter if you are trying to make changes by accessing the cluster with kubectl or with helm commands, The user requesting the changes has the same RBAC allowed permissions whatever tool they use.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/0*-bJC5oORH6l07HpB.png" /></figure><p>That’s a big difference between Helm 2 and 3 where Helm 2 uses Tiller while Helm 3 simplifies it by removing Tiller &amp; integrating it with Kubernetes.</p><h3>⚙️ Installing and Configuring Helm!</h3><p>Before installing helm, we must have a functional Kubernetes cluster and kubectl installed and configured on your local computer with the right login details set up in the kubeconfig file to work with the intended Kubernetes cluster.</p><p>Helm can be installed on Linux, Windows, or Mac OS systems. We will go over the instructions for installing Helm on Linux systems in this blog.</p><ul><li>Systems with snap can install helm using the snap install helm command. Use the classic option to install a more relaxed sandbox that gives the app a bit more access to the host system rather than strictly isolating it to its separate environment. This way Helm can easily access the <strong>kubeconfig file </strong>in your home directory so it knows how to connect to your Kubernetes cluster.</li></ul><pre>$ sudo snap install helm --classic</pre><ul><li>For APT-based systems such as Debian or Ubuntu, Follow the instructions to add the key and sources list before installing Helm.</li></ul><pre>$ curl https://baltocdn.com/helm/signing.asc | gpg --dearmor | sudo tee /usr/share/keyrings/helm.gpg &gt; /dev/null<br><br>$ sudo apt-get install apt-transport-https --yes<br><br>$ echo &quot;deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/helm.gpg] https://baltocdn.com/helm/stable/debian/ all main&quot; | sudo tee /etc/apt/sources.list.d/helm-stable-debian.list<br><br>$ sudo apt-get update<br>$ sudo apt-get install helm</pre><ul><li>And for PKG, run the package install helm command.</li></ul><pre>$ pkg install helm</pre><ul><li>For installing Helm on Windows and Mac OS Refer to the <a href="https://helm.sh/docs/intro/install/">Official Helm documentation</a></li></ul><h3>📌 Conclusion</h3><p>In conclusion, Helm proves to be an invaluable tool for streamlining and simplifying the deployment of applications in Kubernetes for beginners. Its user-friendly charts, easy-to-understand templates, and seamless package management make it an excellent choice for those just starting their journey with container orchestration. As you continue to explore Helm, remember that its vibrant community and extensive documentation are there to support you on your path to mastering application deployment in Kubernetes. Happy Helm charting!</p><p>Well that’s all for now but we’ll meet again soon in our next blog.<br>Till then you can follow me on <a href="https://www.linkedin.com/in/shivang-shandilya/">LinkedIn</a> and <a href="https://x.com/shiryutwts">X</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=851124bc9f29" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Unveiling the Agile Pipeline: My CI/CD Project Journey]]></title>
            <link>https://medium.com/@shivangblogs/unveiling-the-agile-pipeline-my-ci-cd-project-journey-e2e570f228e1?source=rss-2eb9381199cf------2</link>
            <guid isPermaLink="false">https://medium.com/p/e2e570f228e1</guid>
            <dc:creator><![CDATA[Shivang Shandilya]]></dc:creator>
            <pubDate>Sat, 01 Nov 2025 15:44:58 GMT</pubDate>
            <atom:updated>2025-11-01T15:44:58.448Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*nn3DB6Nz_bv8mPOl" /></figure><p>Before I start with this blog I would like to confess something, this project was not at all easy😂. This blog might make it seem like it was just a straight-forward project but trust me it wasn’t. It was quite a bit of a challenge but I overcame it and the fruit of this project i.e. the actual learnings were immense for which I’m grateful that I gave this project a go.</p><h3>📝 Laying out the plan</h3><p>So before starting with the project I always like to think about what I am going to do moving forward. In this case, I decided that the application that I’m going to make will be in the Go programming language (as I’m learning to Go side-by-side too so it would make sense to give myself another challenge). Now came to decide the tools I was gonna use for the CI (Continuous Integration) and CD (Continuous Deployment). For the CD part, I already decided to go for ArgoCD as I have already been learning about it for a while now. Also completed a small course recently by <a href="https://akuity.io/">Akuity</a> called <a href="https://www.credential.net/3e2169e1-c7e0-4625-adf4-52e5812a6e80">Introduction to Continuous Delivery and GitOps using ArgoCD.</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/400/0*_WaDRRMMI0z_pT0d" /></figure><h3>🚩 Problems with Gitlab CI</h3><p>I was really excited to use Gitlab CI and as we know Gitlab is also a version control system like GitHub so I decided to use Gitlab all the way. But things didn’t turn out quite well when I made a simple Hello World program in Go and tried to run a simple Build pipeline. Why? Because Gitlab has now started asking for credit cards to reduce abuse of Gitlab Infrastructure. I didn&#39;t have a credit card so I wasn&#39;t able to test my pipelines 😭</p><h3>🤔 Why didn’t you try Jenkins then?</h3><p>I know I know Jenkins is a pretty cool CI tool but I just can’t work with it and I don’t know why. After my Gitlab idea failed I tried giving Jenkins a try but generating and storing all those access tokens in Jenkins was a huge hassle. Also faced a lot of issues writing my Jenkinsfile too. Moreover, I don’t know why but the logs weren’t showing why my pipeline was failing so being frustrated I just dropped the idea of using Jenkins.</p><h3>⚙️ An underrated CI tool comes to the rescue</h3><p>Here’s a hint as to what it might be:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/280/0*JpO44zpHO0scy4zL" /></figure><p>If you still haven’t realized what tool this is let me tell you this is <strong>GITHUB ACTIONS.</strong><br>This is such an underrated platform that automates building and testing codes and deployment pipelines. Well, this is just a textbook definition of what CI tools are but Github Actions really was a lifesaver. I’ll tell you all about this more in detail later, let’s start with the project now, shall we?</p><h3>So did the layout of the plan change?</h3><p>Of course, it did, this is the updated layout of the plan:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*G45HIuev44wxQy9d" /></figure><h3>🔨 Building the Go Application</h3><p>So the first step was to build our very own Go Application, I could have just gone with the Hello World thing but nope where is the fun in that right? So I have also been studying APIs for a while now so I decided to make a simple API with GET, and POST requests.<br>Note: If you&#39;re building something with a tool always check the documentation</p><p>Why do I say this above Note thing? Cause as I was searching for a guide to help me with this API, I found a really simple one on <a href="https://go.dev/doc/tutorial/web-service-gin">Go Documentation</a>. While reading about the API, I also got to know about Gin Framework. So I started following the documentation step by step and VOILA !!!!</p><pre>package main<br><br>import (<br>    &quot;net/http&quot;<br>    &quot;github.com/gin-gonic/gin&quot;<br>)<br><br>// album represents data about a record album.<br>type album struct {<br>    ID     string  `json:&quot;id&quot;`<br>    Title  string  `json:&quot;title&quot;`<br>    Artist string  `json:&quot;artist&quot;`<br>    Price  float64 `json:&quot;price&quot;`<br>}<br><br>// albums slice to seed record album data.<br>var albums = []album{<br>    {ID: &quot;1&quot;, Title: &quot;Blue Train&quot;, Artist: &quot;John Coltrane&quot;, Price: 56.99},<br>    {ID: &quot;2&quot;, Title: &quot;Jeru&quot;, Artist: &quot;Gerry Mulligan&quot;, Price: 17.99},<br>    {ID: &quot;3&quot;, Title: &quot;Story of My Life&quot;, Artist: &quot;Shivang Shandilya&quot;, Price: 99.99},<br>    {ID: &quot;4&quot;, Title: &quot;Sarah Vaughan and Clifford Brown&quot;, Artist: &quot;Sarah Vaughan&quot;, Price: 39.99},<br>}<br><br>func main() {<br>    router := gin.Default()<br>    router.GET(&quot;/albums&quot;, getAlbums)<br>    router.GET(&quot;/albums/:id&quot;, getAlbumByID)<br>    router.POST(&quot;/albums&quot;, postAlbums)<br><br>    router.Run(&quot;localhost:8080&quot;)<br>}<br><br>// getAlbums responds with the list of all albums as JSON.<br>func getAlbums(c *gin.Context) {<br>    c.IndentedJSON(http.StatusOK, albums)<br>}<br><br>// postAlbums adds an album from JSON received in the request body.<br>func postAlbums(c *gin.Context) {<br>    var newAlbum album<br>    if err := c.BindJSON(&amp;newAlbum); err != nil {<br>        return<br>    }<br>    albums = append(albums, newAlbum)<br>    c.IndentedJSON(http.StatusCreated, newAlbum)<br>}</pre><p>But there was a problem they told us to keep all the functions in main.go file which made my API look crowded which I didn&#39;t like at all. So, I decided to make a separate folder for my <strong>GET and POST requests function</strong>, one for my struct and one called tests for my Unit Testing (this took really long and was so tough for me but I figured this out eventually)</p><p>So it all looked something like this:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/677/0*rg8yDNDJIViXt-wW" /></figure><p>Was able to run the app smoothly by running the command:</p><pre>go run .</pre><p>But in order to use the GET command to fetch all the albums, I had to run this command which was kind of annoying:</p><pre> curl http://localhost:8080/albums \<br>    --header &quot;Content-Type: application/json&quot; \<br>    --request &quot;GET&quot;</pre><p>So, that’s when I got to know about <a href="https://www.thunderclient.com/">Thunder Client</a> an extension on VS Code that lets you make API calls without writing all that code above (you can use other tools like Postman too but I didn’t wanted to switch again and again while working)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*NLILQfnXDs5tzsfm" /></figure><p>So it all worked out in the end, I was able to break down the code pretty easily but now came the hard part …… TESTING.</p><h3>🛠️ Testing the Go Application</h3><p>Ohh boy I didn’t know what I was jumping into, my habit of just taking a challenge every time backfired here. Testing took me around 8–9 hrs and I’m not even kidding. Well, a seasoned folk would be able to do this in 10 minutes but I who just learned Go, made just 2–3 projects and wrote unit tests for the first time, really had me screaming 😂</p><p>So, a blessing in disguise named <a href="https://twitter.com/pradumna_saraf">Pradumna Saraf</a> came to help me. I’m pretty sure most of the folks reading this blog have at least heard of him right? I messaged him and he without any question jumped on a Google Meet with me. I explained to him what my project was and how I’m stuck. But I didn’t know Pradumna also never wrote Unit tests before and this was going to be his first time debugging or rather creating unit tests with me.</p><p>He literally sat down with me for straight 4 hours and we finally wrote the unit tests for our app, it was just absolutely mind-blowing how much we both learned in such a short amount of time. Literally hats off to him without him I wouldn’t have been able to complete this project.</p><p>Well now that our Go App was finally completed and all the tests were running successfully, it was time to dockerize our app and test it out locally.</p><h3>🐳 Dockerizing my Go App</h3><p>So we did the obvious steps to create a docker image for my Go Application:</p><pre>docker build . -t golang-api</pre><p>And after this, I started the app from my Docker Desktop</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*raEUahNgNHxW_mzA" /></figure><p>Don’t pay attention to the name please 😂, Docker assigns names randomly if you don’t provide it with one, so now my app was working perfectly in the localhost too.</p><h3>🚀 Implementing Continuous Integration (CI)</h3><p>So believe it or not but apparently I found writing Github Actions much easier than a Jenkinsfile. I decided on creating two workflows for my CI pipeline. One named as CI which included building and testing of my Go Application and other was named as Publish Image to DockerHub. Publish Image to DockerHub workflow would only start when CI was executed successfully. This workflow basically included building my Docker Image and pushing the same to the DockerHub.</p><p>ci.yml file was as follows:</p><pre>name: CI<br><br>on:<br>  push:<br>    branches: [&quot;main&quot;]<br>  pull_request:<br>    branches: [&quot;main&quot;]<br><br>jobs:<br>  build-test:<br>    name: Build and Test<br>    runs-on: ubuntu-latest<br><br>    steps:<br>      - name: Checkout Code<br>        uses: actions/checkout@v3<br><br>      - name: Setup Go<br>        uses: actions/setup-go@v4<br>        with:<br>          go-version: 1.19<br><br>      - name: Build<br>        run: go build -v .<br><br>      - name: Test<br>        run: go test -v ./tests</pre><p>and publish-dockerhub.yml was as follows:</p><pre>name: Publish Image to DockerHub<br><br>on:<br>  workflow-run:<br>    workflows: [&quot;CI&quot;]<br>    types:<br>      - completed<br><br>jobs:<br>  build:<br>    runs-on: ubuntu-latest<br><br>    steps:<br>      - uses: actions/checkout@v3<br><br>      - name: DockerHub Login<br>        uses: docker/login-action@v2.1.0<br>        with:<br>          username: ${{ secrets.DOCKERHUB_USERNAME }}<br>          password: ${{ secrets.DOCKERHUB_PASSWORD }}<br><br>      - name: Build the Docker image<br>        run: docker build . --file Dockerfile --tag ${{ secrets.DOCKERHUB_USERNAME }}/golang-api<br><br>      - name: Docker Push<br>        run: docker push ${{ secrets.DOCKERHUB_USERNAME }}/golang-api</pre><p>Here, secrets.DOCKERHUB_USERNAME and secrets.DOCKERHUB_PASSWORD are the secrets that you store for a project in your GitHub repository. DOCKERHUB_USERNAME is the username you have on DockerHub and DOCKERHUB_PASSWORD can be your password for the same or an access token.</p><p>After both workflows were set up I tried running the workflow manually and VOILA!! my Docker Image was being pushed to the DockerHub which meant that it was now time to move to the CD part.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*KIg6PYvLhC7k-aY3" /></figure><h3>🚀 Implementing Continuous Deployment (CD)</h3><p>Implementing the CI part of the pipeline wasn’t that difficult, it was pretty easy but now came the fun part CD. As discussed earlier we were going to integrate ArgoCD with our Kubernetes cluster and connect our ArgoCD with our GitHub repository so if any changes occurred in the repository ArgoCD will automatically fetch those.<br>Now there are 2 ways to integrate ArgoCD with your K8s Cluster I’m going to show how I did it first and will then show the second way.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/827/0*uo-LwlY1ncwkYhzt" /></figure><p>So first things first we deploy our K8s Cluster, you can do this either locally or using any CSP (Cloud service provider). I deployed my cluster using the command:</p><pre>minikube start --memory=4098 --driver=docker</pre><p>So now we head on over to Operator Hub and search for ArgoCD there:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Qni-DDZ_15DhOMBT" /></figure><p>I already knew how you can integrate ArgoCD with your K8s cluster but this Operator Hub way was kinda new to me so I wanted to give this a shot.</p><p>So I didn’t have Operator Lifecycle Manager (OLM) installed, so I did that it’s just a 1-time install then after that you can use any operator that you wish to use.</p><pre>curl -sL https://github.com/operator-framework/operator-lifecycle-manager/releases/download/v0.25.0/install.sh | bash -s v0.25.0</pre><p>Now remember I told you above that there are 2 ways to integrate ArgoCD, one of the ways that I implemented was to open a Vim editor and make a file argocd-basic.yml.<br>And to add the following content:</p><pre>apiVersion: argoproj.io/v1alpha1<br>kind: ArgoCD<br>metadata:<br>  name: example-argocd<br>  labels:<br>    example: basic<br>spec: {}</pre><p>and then just basically apply this file with kubectl:</p><pre>kubectl apply -f argocd-basic.yml</pre><p>My pods started running and now all I had to do was to change example-argued-server’s Cluster IP to NodePort in order to access it externally.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*HPBMJ82MfdaC0dR5.png" /></figure><p>Now you would think, where is the integration with the project? So when you log into ArgoCD you are provided with the option to create a new application.<br>That’s when it asks for the GitHub repository where your project is, along with the PATH of the deployment.yml file for your K8s Cluster.</p><p>Once you provide all the necessary details, that’s when the MAGIC happens.</p><h3>🪄 Completion of the Project</h3><p>When I entered all the necessary details, VOILA!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ljQgo034FRQ69ymg" /></figure><p>My project was integrated with ArgoCD finally!!! ( took a few tries tho ) but the satisfaction I got when it showed APP HEALTH — 💚 Healthy was just unbelievable.</p><h3>🏁 Conclusion</h3><p>I’m pretty sure that after reading this blog you at least got the feeling this project wasn’t that easy but the learnings were immense. And as they say, you can learn all you want but you only get a better understanding of how things work when you apply that hands-on by yourself.<br>Hope you had a blast reading this blog 😃( not literally )</p><p>If you wanna check out my project, you can do that from <a href="https://github.com/ShivangShandilya/golang-api">here.</a><br>Also, this project is entirely open-source, so if you spot any errors in documentation or codebase or just wanna suggest an improvement in the project, feel free to raise an issue.</p><p>You can follow me on <a href="https://www.linkedin.com/in/shivang-shandilya/">LinkedIn</a> and <a href="https://x.com/shiryutwts">X</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e2e570f228e1" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Building a GO CRUD Rest API from Scratch]]></title>
            <link>https://medium.com/@shivangblogs/building-a-go-crud-rest-api-from-scratch-f1f901cedbcb?source=rss-2eb9381199cf------2</link>
            <guid isPermaLink="false">https://medium.com/p/f1f901cedbcb</guid>
            <dc:creator><![CDATA[Shivang Shandilya]]></dc:creator>
            <pubDate>Sun, 19 Oct 2025 15:35:39 GMT</pubDate>
            <atom:updated>2025-10-19T15:37:18.324Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*XZI6gCnv3NgudV9g" /></figure><p>Thanks to <a href="https://hashnode.com/@FrancescoCiulla">Francesco Ciulla</a> for making a detailed <a href="https://www.youtube.com/watch?v=aLVJY-1dKz8&amp;t=295s">video</a> on how to create this API which was really helpful to understand concepts.</p><p>I have created a GO CRUD Rest API which keeps account of Mens 100m Race using:</p><ul><li>Mux (Framework to build web servers in Go)</li><li>Postgres (relational database)</li><li>Docker (for containerization)</li><li>Docker Compose</li></ul><p>All the code is available in the GitHub repository (<a href="https://github.com/ShivangShandilya/go-api">go-api</a>)</p><h3>GAME PLAN</h3><p>Here is a schema of the architecture of the application we are going to create:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*q5p7VQvwxUYKKxp0" /></figure><p>We will create 5 endpoints for basic CRUD operations:</p><ul><li>Create</li><li>Read all</li><li>Read one</li><li>Update</li><li>Delete</li></ul><p>So, here are the steps we are gonna go through:</p><ol><li>Create a Go application using Mux as a framework</li><li>Dockerize the Go application by writing a Dockerfile and a docker-compose.yml file to run the application and the database.</li><li>Run the SQL database in a container using Docker Compose, and test it with TablePlus.</li><li>Build the Go App image and run it in a container using Docker Compose, then test it with Postman.</li></ol><h4>STEP BY STEP GUIDE is given below</h4><h3>Create a Go application using Mux as a framework</h3><ol><li>Create a new folder for your project</li><li>Initialize a go module using this command</li></ol><pre>go mod init api</pre><p>3. Install the dependencies:</p><pre>go get github.com/gorilla/mux github.com/lib/pq</pre><p>We now need 3 more files to start with our project, One of them is going to be our main.go file where our Golang code for API will go and the other too will be our Dockerfile and a Docker Compose file.</p><pre>touch main.go Dockerfile docker-compose.yml</pre><p>LET’S OPEN VS CODE AND START WORKING ON OUR API</p><pre>code .</pre><p>When your VS Code opens it should look like:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*08dBxPEvDcx83KDg.png" /></figure><h3>Working on our main.go file</h3><p>The main.go file is the main file of the application: it contains all the endpoints and the logic of the app.</p><p>Populate the main.go file as follows:</p><pre>package main<br><br>import (<br>    &quot;database/sql&quot;<br>    &quot;encoding/json&quot;<br>    &quot;log&quot;<br>    &quot;net/http&quot;<br>    &quot;os&quot;<br><br>    &quot;github.com/gorilla/mux&quot;<br>    _ &quot;github.com/lib/pq&quot;<br>)<br><br>type Men struct {<br>    Rank    int    `json:&quot;rank&quot;`<br>    Name    string `json:&quot;name&quot;`<br>    Country string `json:&quot;country&quot;`<br>}<br><br>func main() {<br>    //connection to database<br>    db, err := sql.Open(&quot;postgres&quot;, os.Getenv(&quot;DATABASE_URL&quot;))<br>    if err != nil {<br>        log.Fatal(err)<br>    }<br>    defer db.Close()<br><br>    //create table if it doesn&#39;t exist<br>    _, err = db.Exec(&quot;CREATE TABLE IF NOT EXISTS men(rank int, name text, country text);&quot;)<br>    if err != nil {<br>        log.Fatal(err)<br>    }<br><br>    //create router<br>    router := mux.NewRouter()<br>    router.HandleFunc(&quot;/men&quot;, getMen(db)).Methods(&quot;GET&quot;)<br>    router.HandleFunc(&quot;/men/{id}&quot;, getMenByID(db)).Methods(&quot;GET&quot;)<br>    router.HandleFunc(&quot;/men&quot;, createUser(db)).Methods(&quot;POST&quot;)<br>    router.HandleFunc(&quot;/men/{id}&quot;, updateUser(db)).Methods(&quot;PUT&quot;)<br>    router.HandleFunc(&quot;/men/{id}&quot;, deleteUser(db)).Methods(&quot;DELETE&quot;)<br><br>    //start server<br>    log.Fatal(http.ListenAndServe(&quot;:8000&quot;, jsonContentTypeMiddleware(router)))<br><br>}<br><br>func jsonContentTypeMiddleware(next http.Handler) http.Handler {<br>    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {<br>        w.Header().Set(&quot;Content-Type&quot;, &quot;application/json&quot;)<br>        next.ServeHTTP(w, r)<br>    })<br>}<br><br>// get all mens<br>func getMen(db *sql.DB) func(w http.ResponseWriter, r *http.Request) {<br>    return func(w http.ResponseWriter, r *http.Request) {<br>        rows, err := db.Query(&quot;SELECT rank, name, country FROM men&quot;)<br>        if err != nil {<br>            log.Fatal(err)<br>        }<br>        defer rows.Close()<br><br>        var men Men<br>        for rows.Next() {<br>            err := rows.Scan(&amp;men.Rank, &amp;men.Name, &amp;men.Country)<br>            if err != nil {<br>                log.Fatal(err)<br>            }<br>        }<br><br>        if err := rows.Err(); err != nil {<br>            log.Fatal(err)<br>        }<br><br>        json.NewEncoder(w).Encode(men)<br>    }<br>}<br><br>// get user by id<br>func getMenByID(db *sql.DB) http.HandlerFunc {<br>    return func(w http.ResponseWriter, r *http.Request) {<br>        id := mux.Vars(r)[&quot;id&quot;]<br>        row := db.QueryRow(&quot;SELECT rank, name, country FROM men WHERE id = $1&quot;, id)<br>        var men Men<br>        err := row.Scan(&amp;men.Rank, &amp;men.Name, &amp;men.Country)<br>        if err != nil {<br>            log.Fatal(err)<br>        }<br><br>        json.NewEncoder(w).Encode(men)<br>    }<br>}<br><br>// create user<br>func createUser(db *sql.DB) http.HandlerFunc {<br>    return func(w http.ResponseWriter, r *http.Request) {<br>        var men Men<br>        err := json.NewDecoder(r.Body).Decode(&amp;men)<br>        if err != nil {<br>            log.Fatal(err)<br>        }<br><br>        _, err = db.Exec(&quot;INSERT INTO men (name, country) VALUES ($1, $2)&quot;, men.Name, men.Country)<br>        if err != nil {<br>            log.Fatal(err)<br>        }<br><br>        json.NewEncoder(w).Encode(men)<br>    }<br>}<br><br>// update user<br>func updateUser(db *sql.DB) http.HandlerFunc {<br>    return func(w http.ResponseWriter, r *http.Request) {<br>        id := mux.Vars(r)[&quot;id&quot;]<br>        var men Men<br>        err := json.NewDecoder(r.Body).Decode(&amp;men)<br>        if err != nil {<br>            log.Fatal(err)<br>        }<br><br>        _, err = db.Exec(&quot;UPDATE men SET name = $1, country = $2 WHERE id = $3&quot;, men.Name, men.Country, id)<br>        if err != nil {<br>            log.Fatal(err)<br>        }<br><br>        json.NewEncoder(w).Encode(men)<br>    }<br>}<br><br>// delete user<br>func deleteUser(db *sql.DB) http.HandlerFunc {<br>    return func(w http.ResponseWriter, r *http.Request) {<br>        id := mux.Vars(r)[&quot;id&quot;]<br>        _, err := db.Exec(&quot;DELETE FROM men WHERE id = $1&quot;, id)<br>        if err != nil {<br>            log.Fatal(err)<br>        }<br><br>        json.NewEncoder(w).Encode(id)<br>    }<br>}</pre><p>So there are some of the things we are doing in our main function:</p><ul><li>We are connecting to Postgres DB setting an environment variable.</li><li>We are creating a table if it doesn’t already exist</li><li>We use Mux to handle 5 endpoints</li><li>We are listening to the server on port 8000</li></ul><h3>🐳 Dockerizing our GO Application</h3><p>Let’s populate the Dockerfile :</p><pre># use official Golang image<br>FROM golang:1.16.3-alpine3.13<br><br># set working directory<br>WORKDIR /app<br><br># Copy the source code<br>COPY . . <br><br># Download and install the dependencies<br>RUN go get -d -v ./...<br><br># Build the Go app<br>RUN go build -o api .<br><br>#EXPOSE the port<br>EXPOSE 8000<br><br># Run the executable<br>CMD [&quot;./api&quot;]</pre><p>Explanation:</p><p>FROM sets the base image to use. In this case, we are using the golang:1.16.3-alpine3.13 image, a lightweight version</p><p>WORKDIR sets the working directory inside the image</p><p>COPY . . copies all the files in the current directory to the working directory</p><p>RUN go get -d -v ./... Is a command to install the dependencies before building the image</p><p>RUN go build -o api . build the Go app inside the Image filesystem</p><p>EXPOSE 8000 exposes the port 8000</p><p>CMD [&quot;./api&quot;] sets the command to run when the container starts</p><h3>🐳 Setting up Docker Compose</h3><p>The term “Docker compose” might be a bit confusing because it’s referred to both to a file and to a set of CLI commands. Here we will use the term to refer to the file.</p><p>Populate the docker-compose.yml file:</p><pre>version: &#39;3.9&#39;<br><br>services:<br>  go-app:<br>    container_name: go-app<br>    image: shivangshandilya/go-app:1.0.0<br>    build: .<br>    environment:<br>      DATABASE_URL: &quot;host=go_db user=postgres password=postgres dbname=postgres sslmode=disable&quot;<br>    ports:<br>      - &quot;8000:8000&quot;<br>    depends_on:<br>      - go_db<br>  go_db:<br>    container_name: go_db<br>    image: postgres:12<br>    environment:<br>      POSTGRES_PASSWORD: postgres<br>      POSTGRES_USER: postgres<br>      POSTGRES_DB: postgres<br>    ports:<br>      - &quot;5432:5432&quot;<br>    volumes:<br>      - pgdata:/var/lib/postgresql/data<br><br>volumes:  <br>  pgdata: {}</pre><p>Explanation: we just defined 2 services, go-app and go_db</p><p>go-app is the Go application we just Dockerized writing the Dockerfile</p><p>go_db is a Postgres container, to store the data. We will use the official Postgres image</p><p>version is the version of the docker-compose file. We are using version 3.9</p><p>services is the list of services (containers) we want to run. In this case, we have 2 services: &quot;go-app&quot; and &quot;go_db&quot;</p><p>container_name is the name of the container. Containers find each other by their name, so it&#39;s important to have a name for the containers we want to communicate with.</p><p>image is the name of the image we want to use. I recommend replacing &quot;dockerhub-&quot; with YOUR Dockerhub account.</p><p>build is the path to the Dockerfile. In this case, it&#39;s the current directory, so we are using .</p><p>ports are the list of ports we want to expose. In this case, we are exposing the port 8000 of the go-app container, and the port 5432 of the go_db container. The format is &quot;host_port:container_port&quot;</p><p>depends_on is the list of services we want to start before this one. In this case, we want to start the Postgres container before the app container.</p><p>environment is to define the environment variables. for the go-app, we will have a database url to configure the configuration. For the go_db container, we will have the environment variables we have to define when we want to use the Postgres container (we can&#39;t change the keys here, because we are using the Postgres image, defined by the Postgres team).</p><p>volumes in the go_db define a named volume we will use for persistence. Containers are ephemeral by definition, so we need this additional feature to make our data persist when the container will be removed (a container is just a process).</p><p>volumes at the end of the file is the list of volumes we want to create. In this case, we are creating a volume called pgdata. The format is volume_name: {}</p><h3>Running our Postgres container and testing it with TablePlus</h3><p>To run the Postgres container, type:</p><pre>docker compose up -d go_db</pre><p>The -d flag is to run the container in detached mode, so it will run in the background.</p><p>Now that the Postgres container is up and running, we can check the db connection via TablePlus.</p><p>Use the following configuration:</p><p>Host: <a href="http://localhost/">localhost</a></p><p>Port: 5432</p><p>User: postgres</p><p>Password: postgres</p><p>Database: postgres</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/667/0*HC4-V0JeODEZfjNr.png" /></figure><p>Then hit “Test” (at the bottom-right).</p><p>If you get the message “connection is OK” you are good to go.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/658/0*obGl9kwftMj1k_qQ.png" /></figure><p>You can also click “Connect” and you will see an empty database. This is correct.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*UchtGkh0b8F1uqbz.png" /></figure><h3>Building the GO Application</h3><p>Now, let’s build and run the GO application.</p><p>Let’s go back to the folder where the docker-compose.yml is located and type:</p><pre>docker compose build</pre><p>This should BUILD the go-app image, with the name defined in the “image” value. In my case, it’s shivangshandilya/go-app:1.0.0 because that’s my Dockerhub username. You should replace “shivangshandilya” with your Dockerhub username.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*YzNDCUqj94iJ9r73" /></figure><h3>Running the go-app service</h3><p>We are almost done, but one last step is to run a container based on the image we just built.</p><p>To do that, we can just type:</p><pre>docker compose up go-app</pre><p>In this case we don’t use the -d flag, because we want to see the logs in the terminal.</p><p>We should see something like this:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*bf_gdZPz56ihMHgK" /></figure><h3>Testing the application</h3><p>Let’s test our application. First of all, let’s see if the application is responding. To do this, make a GET request to <a href="http://localhost:8000/men">localhost:8000/men</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*VrEeoTlfpL975Yxw" /></figure><h3>📝 Creating an entry</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*rvcihZtZVqFnTSxZ" /></figure><p>If you create some more entries and then take a look at TablePlus it will look kinda like this:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*cG1kJSfzNTGI6rhn.png" /></figure><h3>🏁 Conclusion</h3><p>So if you have been following along your CRUD rest API in Go, using Mux, Postgres, Docker and Docker compose is created.</p><p>I hope you had fun creating this API as much as I had. That is all for today but you can follow me on <a href="https://www.linkedin.com/in/shivang-shandilya/">LinkedIn</a> and <a href="https://x.com/shiryutwts">Twitter </a>to be updated on any blogs I might push out.<br>Would love to hear your views down below!!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f1f901cedbcb" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[My Journey of DevRel Cohort at Keploy]]></title>
            <link>https://medium.com/@shivangblogs/my-journey-of-devrel-cohort-at-keploy-47f1331fd2e8?source=rss-2eb9381199cf------2</link>
            <guid isPermaLink="false">https://medium.com/p/47f1331fd2e8</guid>
            <dc:creator><![CDATA[Shivang Shandilya]]></dc:creator>
            <pubDate>Sun, 19 Oct 2025 15:03:41 GMT</pubDate>
            <atom:updated>2025-10-19T15:03:41.848Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*5DwyFM3PVL2IbDfK" /></figure><p>In the vast world of technology, there’s a constant need for individuals who not only possess technical expertise but also excel in building meaningful connections with the developer community. These individuals are often referred to as Developer Relations (DevRel) professionals, and their role is crucial in bridging the gap between developers and the products or services they use. Join me as I share my journey of how I discovered the captivating world of APIs and being a candidate DevRel at Keploy.</p><h3>The Untouched Realm of APIs</h3><p>As I’m currently learning DevOps, my primary focus is on the operational aspects of software development and deployment. I had always been aware of the concept of APIs (Application Programming Interfaces) and their significance in enabling communication between different software systems. However, I must admit that I had never delved deep into exploring the potential they held or fully understood their transformative power.</p><h4>The Journey Begins…</h4><p>So, the cohort started officially began on the 15th of May when all my fellow candidates introduced themselves, It was so fun seeing people from different fields of technology enthusiastic about DevRel.</p><p>So, our first session which was an introductory one was held on 15th May itself by none other than current DevRel’s at Keploy — <a href="https://twitter.com/sonichigo1219">Animesh Pathak</a> and <a href="https://twitter.com/banik_diganta">Diganta Kr Banik.</a><br>All the candidates had a lot of fun discussing random stuff as we all got to know and network with each other.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*q3_uUbb_exS-1Aj0" /></figure><p>We were then informed of the tasks we were meant to carry out in order to make this cohort a successful one and let me tell you when I say this all the tasks that were given to us were amazing.</p><h3>Building my first API</h3><p>After the introductory session, I was so hyped up that I began building my first API, I didn’t know the first thing about building APIs but I just wanted to give it a try and so I did.<br>As I told above I’m currently learning DevOps so with that I favor Go programming language so I decided to make one on it. I built a GO CRUD Rest API using Mux, Postgres, Docker, and Docker Compose.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*AmhHHM5tSt860LM3.png" /></figure><p>I had lots of fun when I was building my very first API and the learnings were immense, if you wanna check out my API — <a href="https://github.com/ShivangShandilya/go-api">This is the Github repo for it</a>.</p><h3>More Keploy sessions</h3><p>I loved the fact that the DevRels at Keploy were considerate of the fact that not everybody in the cohort knew about APIs so to push that hurdle aside they conducted sessions where they taught us about APIs and how you can integrate them with Keploy.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*F3o8G--2ud6BQmrK" /></figure><p>PS: Diganta and Animesh both explain concepts really well.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*VXO7H2cjgaXUtsCd" /></figure><h3>Blogs on APIs</h3><p>As I was learning APIs I wanted to share that knowledge with everyone around me, so I started writing blogs on various API-related stuff and I’m glad to share with you that my blogs also got published on the <a href="https://student.keploy.io/?isDarkTheme=true&amp;deviceType=desktop">Keploy Student Blog</a> page.</p><p>The blogs I wrote were:</p><ul><li><a href="https://student.keploy.io/soap-vs-rest-choosing-the-right-api-protocol">SOAP vs REST: Choosing the right API protocol</a></li><li><a href="https://community.keploy.io/building-a-crud-application-from-scratch-using-golang">Building GO CRUD Rest API from scratch</a></li><li><a href="https://community.keploy.io/exploring-graphql-api-development">Exploring GraphQL: A Modern Approach to API Development</a></li></ul><h3>Sessions I took on APIs</h3><p>The cohort was nearing the end and the DevRels encouraged us to take some sessions on APIs and testing.<br>So I along with my other candidate Shashwat decided on an event on the topic: E2E testing with Keploy where the speaker was one of the DevRel at Keploy, Animesh.</p><p>For my first session, we partnered up with GDG ( Google Developer Groups ) Bhilai and the society at my college — Tech Shuttle. And needless to say, the session went flawlessly and I was so amazed to see folks eager to learn a lot more.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*jAvB02nbwK3kZ7vy" /></figure><p>I then took another session in which I collaborated with a tech community named DevsInTech in which I talked about APIs and their testing with Keploy alongside Diganta, loved the enthusiasm of people who joined as they were eager to learn a lot more.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Q5xUzMdcESysR0SM" /></figure><h3>Conclusion</h3><p>The experience at the DevRel cohort organized by Keploy was just absolutely mind-blowing and the connections I made along the way are always gonna be close to my heart. The learnings were immense from this cohort from always hating to know about APIs to building and loving one, I have seriously come a long way all thanks to DevRels who oversaw the whole cohort — Thanks to Animesh and Diganta.<br>Feel free to connect with me on <a href="https://www.linkedin.com/in/shivang-shandilya/">LinkedIn</a> and<a href="https://x.com/shiryutwts"> Twitter.</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=47f1331fd2e8" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Armada : Multi-Kubernetes Cluster Batch Job Meta-Scheduler]]></title>
            <link>https://medium.com/@shivangblogs/armada-multi-kubernetes-cluster-batch-job-meta-scheduler-523e92c6919b?source=rss-2eb9381199cf------2</link>
            <guid isPermaLink="false">https://medium.com/p/523e92c6919b</guid>
            <dc:creator><![CDATA[Shivang Shandilya]]></dc:creator>
            <pubDate>Sat, 18 Oct 2025 05:40:55 GMT</pubDate>
            <atom:updated>2025-10-18T05:40:55.561Z</atom:updated>
            <content:encoded><![CDATA[<h3>Armada : Multi-Kubernetes Cluster Batch Job Meta-Scheduler</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*2xvaRysxb6y24oKp" /></figure><p>We all have worked around the Kubernetes clusters, right? Managing multiple Helm charts and Kubernetes manifests across those clusters is such a hassle but not anymore with the help of ARMADA. Let’s understand why I’m saying this a bit more in detail…</p><h3>So exactly What is Armada?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/365/1*VI3cQRwgzn3WLW5iE5dCmw.png" /></figure><p>I think you can already guess what it is about just from the title of this blog and yes Armada is a multi-Kubernetes-cluster batch job meta-scheduler. But all those who weren’t able to guess this must be wondering what are all these batch jobs and meta-scheduler things.</p><p>Ok ok let me explain this word by word:</p><ul><li><strong>Multi Kubernetes Cluster</strong> — Armada is designed to work with multiple Kubernetes clusters simultaneously. It enables organizations to utilize resources from multiple clusters to execute their batch jobs, providing enhanced scalability and resource utilization.</li><li><strong>Batch Job Scheduling</strong> — Armada acts as a meta-scheduler, meaning it provides an additional layer of scheduling and coordination on top of the underlying Kubernetes cluster schedulers.</li><li>It allows users to define and submit batch jobs to Armada, which then intelligently schedules and distributes these jobs across the connected clusters based on predefined policies, resource availability, and optimization strategies.</li></ul><p>I think now you got an idea of what Armada is and what it does but now the question arrives, how did you get to know about this CNCF project? Let’s talk about this now…</p><h3>How did I got to know about Armada?</h3><p>So, I first got to know about Armada while searching for organizations to contribute to under GSoC’23(Google Summer Of Code). While searching I stumbled across Armada which is a sandbox project under CNCF(Cloud Native Computing Foundation) ecosystem.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/920/0*bdebVocmRLjJwRem.png" /></figure><p>The Armada project came under my skillset and I applied for the same and I’m glad to share that I also got selected woohoo!!!!<br>This summer I’ll be focusing on creating a Krew plugin for armadactl (a command-line utility tool for Armada).</p><h3>Armada’s Architecture</h3><p>Armada consists of two main components</p><ul><li>The Armada server is responsible for accepting jobs from users and deciding in what order, and on which Kubernetes cluster, jobs should run. Users submit jobs to the Armada server through the armadactl command-line utility or via a gRPC or REST API.</li><li>The Armada executor, of which there is one instance running in each Kubernetes cluster that Armada is connected to. Each Armada executor instance regularly notifies the server of how much spare capacity it has available and requests jobs to run. Users of Armada never interact with the executor directly.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/733/1*pI7PNI_eEmYzSN-sLq8ACA.png" /></figure><p>Now that we know how I got to know about Armada and its architecture, let’s talk about Why Armada?</p><h3>Why Armada?</h3><ul><li><strong>FAIR-USE SCHEDULING</strong></li></ul><p>Armada maintains fair resource share over time (inspired by HTCondor priority)</p><ul><li><strong>HIGH THROUGHPUT</strong></li></ul><p>Armada can handle large amounts of queued jobs (million+).</p><ul><li><strong>UNINTERRUPTED</strong></li></ul><p>Armada allows adding and removing clusters from the system without disruption</p><ul><li><strong>MASSIVE SCALE</strong></li></ul><p>By utilizing multiple Kubernetes clusters, the system can scale beyond the limits of a single Kubernetes cluster<br>Wanna know more, <a href="https://armadaproject.io/design">click here</a>.</p><p>Well, I have been talking about jobs, queues, job sets and all that but what exactly are these? Let’s take a look…</p><h3>Key Concepts of Armada</h3><h3>Queues:</h3><ul><li>Queues in Armada represent logical entities that act as containers for batch jobs. They help organize and categorize jobs based on their characteristics or priorities.</li><li>Jobs are submitted to queues, and Armada ensures the appropriate scheduling and execution of jobs within each queue, considering factors like resource availability and priority.</li></ul><h3>Jobs:</h3><ul><li>Jobs in Armada represent individual units of work or tasks that need to be executed on a Kubernetes cluster.</li><li>Users define jobs with specific attributes like resource requirements, input data, command or script to be executed, and any dependencies.</li><li>Job status, execution progress, and results can be monitored and tracked through Armada.</li></ul><h3>Job Set:</h3><ul><li>Job sets in Armada provide a way to group related jobs together. They allow users to define dependencies and relationships between jobs.</li><li>A job set can consist of multiple jobs that need to be executed in a specific order or have interdependencies.</li><li>Armada ensures that job sets are executed in a coordinated manner, respecting the defined dependencies and relationships.</li></ul><p>Excited yet to learn more about Armada? Then what better way to contribute towards it and learn from professionals.</p><h3>Contribute to Armada</h3><p>Whether you have an idea to share, a feature to add, an issue to report, or a pull request of the finest, most scintillating code ever, I want you to participate and contribute to Armada!</p><p>You can check out Armada’s main project fork <a href="https://github.com/armadaproject/armada">here</a>.</p><p>Do make sure to take a look at Contributing Guide before contributing to the project.<br>Wanna connect with everyone in Armada? Then follow the steps below:</p><ul><li>Join the CNCF Slack, if you’re not already in it you can get your invitation from <a href="https://communityinviter.com/apps/cloud-native/cncf">here</a>.</li><li>Once inside search for #armada channel and voila!</li></ul><p>Looking forward to building Armada with you!</p><h3>Conclusion</h3><p>So I think now you have a pretty good idea of how powerful of a tool Armada is. Really makes managing all those helm charts and manifests look easy. But Armada is still in the sandbox stage and we have a lot of work to do so feel free to contribute towards Armada.<br>Wanna connect with me, you can find me on <a href="https://x.com/shiryutwts">Twitter</a> and <a href="https://www.linkedin.com/in/shivang-shandilya/">LinkedIn</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=523e92c6919b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Everything you need to know about Docker as a Beginner]]></title>
            <link>https://medium.com/@shivangblogs/everything-you-need-to-know-about-docker-as-a-beginner-2fa928ed9a54?source=rss-2eb9381199cf------2</link>
            <guid isPermaLink="false">https://medium.com/p/2fa928ed9a54</guid>
            <dc:creator><![CDATA[Shivang Shandilya]]></dc:creator>
            <pubDate>Fri, 17 Oct 2025 13:00:54 GMT</pubDate>
            <atom:updated>2025-10-17T13:00:54.713Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*QGXSyPbVIxcIlkf8" /></figure><p>In this blog, we’ll dive deep into what Docker is and the various services it offers. But before we get there, let’s first understand what containers are.</p><p>Also, if you don’t wanna read the blog and rather watch a video explaining all these concepts then fear not cause I have a YouTube video up on my channel on this very same topic that you can check out 🚀.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2Fbx6O1hrsoaA%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3Dbx6O1hrsoaA&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2Fbx6O1hrsoaA%2Fhqdefault.jpg&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/4883d549ceab6c215194ebddbe146bc7/href">https://medium.com/media/4883d549ceab6c215194ebddbe146bc7/href</a></iframe><h3>📦 What are Containers?</h3><p>To understand what Containers are let’s take a real-world example (this is my favorite example as this was given by Kelsey Hightower and it made concepts clear).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*lSmYTrhxzGtzHvud.png" /></figure><p>So, let’s say the holidays are approaching and you want to send some gifts to your loved ones. Here, let’s create a scenario of a post office now. They say we can ship your stuff but we don’t want you to bring loose stuff like loose books and jewellery rather what you can do is put it all in a box together. So, the box in this case let’s say is an envelope.<br>So depending on how much my envelope weighs and how far I have to send it, the charges are applied and we also add the receiver address on it (i.e. ports in this case).<br>Now we can fit anything in our envelope it’s up to us, you can store applications made in any programming language be it Java, Golang, Ruby etc.<br>THESE ARE WHAT WE CALL CONTAINERS !!!</p><h3>🐳 So how does Docker fit into all this?</h3><p>Docker is a software platform that allows you to build, test, and deploy applications quickly. Docker packages software into standardized units called containers that we discussed above. Using Docker, you can quickly deploy and scale applications into any environment and know your code will run.</p><h3>📍Docker Objects</h3><p>When you use Docker, you are creating and using images, containers, networks, volumes, plugins, and other objects. This section is a brief overview of some of those objects.</p><h4>Images</h4><p>An <em>image</em> is a read-only template with instructions for creating a Docker container. Often, an image is <em>based on</em> another image, with some additional customization. For example, you may build an image that is based on the ubuntu image, but installs the Apache web server and your application, as well as the configuration details needed to make your application run.</p><h4>Containers</h4><p>A container is a runnable instance of an image. You can create, start, stop, move, or delete a container using the Docker API or CLI. You can connect a container to one or more networks, attach storage to it, or even create a new image based on its current state. ( I think we have learned enough about Containers now 😂 )</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/691/0*vCADwY58wMpRhjKR" /></figure><p>As this is the first blog that is beginner-friendly in our little Docker Blog series we won’t jump into volumes and networks, we will cover these objects later.</p><h3>🐳 Let’s dive into Docker Architecture</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/433/0*BUjSzBPnEkx_nVdb" /></figure><p>So, Docker Engine is nothing but a host with Docker installed on it and whenever we install Docker Engine on our host we are installing the 3 components that are within the Docker Engine:</p><h4>Docker Deamon</h4><p>Docker Deamon works in the background and manages Docker objects such as images, containers, volumes, networks etc.</p><h4>REST API</h4><p>The REST API server is an API interface through which users interact with Docker Deamon and provide instructions to it.</p><h4>Docker CLI</h4><p>Docker CLI as the name goes means the command-line interface for the Docker that we usually use to run, stop or delete containers, images etc.</p><h3>😮 Fun Fact</h3><p>Docker CLI need not be on the same system as Docker Engine, we could have Docker CLI on a whole other system and work with Docker Engine that is on another system remotely.<br>All we have to do is use this command to connect our CLI with the engine 👇</p><pre>docker -H=remote-docker-engine:2375</pre><p>We just use the -H option followed by the remote address of the engine and a port and Voila!! 🚀</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/834/0*yJYLaksB4_T1qF-4" /></figure><h3>🤔 Hmm, we are making all these images and containers but where are they being stored?</h3><p>Have you ever wondered when you build and run all these images and containers, where and how they are stored on your Docker Host?<br>Docker supports several storage drivers, using a pluggable architecture. The storage driver controls how images and containers are stored and managed on your Docker host.<br>Different storage drivers available are as follows👇:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/855/0*AUu3FZ_1Yz9xBYOB" /></figure><p>Well in Docker all the info related to images, volumes, containers etc is stored in /var/lib/docker directory on your machine.<br>Also to see what storage driver your OS is using you can use this command:</p><pre>docker info</pre><p>Like in my case my OS uses an “overlay2” storage driver.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/338/0*zAeG1MAWoegqoP2h" /></figure><p>If you’re interested in learning more about Docker Storage Drivers, check out their official documentation <a href="https://docs.docker.com/storage/storagedriver/select-storage-driver/">here.</a></p><h3>📁 What is Docker Registry?</h3><p>The Registry is a stateless, highly scalable server-side application that stores and lets you distribute Docker images. The Registry is open-source, under the permissive <a href="https://en.wikipedia.org/wiki/Apache_License">Apache license</a>. You can find the source code on <a href="https://github.com/distribution/distribution">GitHub</a>.</p><h3>Why should I use this registry?</h3><p>You should use the Registry if you want to:</p><ul><li>tightly control where your images are being stored</li><li>fully own your images distribution pipeline</li><li>integrate image storage and distribution tightly into your in-house development workflow.</li></ul><h3>🐋 Install Docker on your machine</h3><p>I’m pretty sure you’re eager to get your hands dirty doing some Docker now after reading this amazing blog 😂. Ahm…Ahm enough flattering myself.<br>Installation of Docker is pretty easy and Docker themselves have a detailed guide on it, make sure to check it out from <a href="https://docs.docker.com/engine/install/">here</a> and GET STARTED !!!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/601/0*r0OWa2oiB1qwxKh9.png" /></figure><p>Now that you have installed Docker on your machine, let’s try some commands so you can get familiar with Docker.</p><h3>⚒️ Trying out some Docker Commands</h3><ul><li>To see all images that are present on your local machine.</li></ul><pre>docker images</pre><ul><li>To find out an image on the Docker Hub.</li></ul><pre>docker search hello-world</pre><ul><li>To download the images from the Docker Hub to your local machine.</li></ul><pre>docker pull hello-world</pre><ul><li>To give a name to a container.</li></ul><pre>docker run -it --name &lt;container name&gt; hello-world /bin/bash</pre><ul><li>To start the container.</li></ul><pre>docker start &lt;container name&gt;</pre><ul><li>To go inside the container.</li></ul><pre>docker attach &lt;container name&gt;</pre><ul><li>To see all containers.</li></ul><pre>docker ps -a</pre><ul><li>To see only running containers.</li></ul><pre>docker ps</pre><ul><li>To stop the container.</li></ul><pre>docker stop &lt;container name&gt;</pre><ul><li>To delete the container.</li></ul><pre>docker rm &lt;container name&gt;</pre><p>Now don’t go thinking these are all the commands for Docker cause that would be too easy alright 😂. We have only touched the tip of the iceberg here.</p><h3>🤷‍♂️ What now?</h3><p>Try installing Docker on your machine, pull some images, run some containers and get your hands dirty.</p><p>You can follow me on <a href="https://www.linkedin.com/in/shivang-shandilya/">LinkedIn</a> and <a href="https://x.com/shiryutwts">Twitter.</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2fa928ed9a54" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Streamlining Your Development Process with Continuous Delivery on Napptive]]></title>
            <link>https://medium.com/@shivangblogs/streamlining-your-development-process-with-continuous-delivery-on-napptive-38de4e78b278?source=rss-2eb9381199cf------2</link>
            <guid isPermaLink="false">https://medium.com/p/38de4e78b278</guid>
            <dc:creator><![CDATA[Shivang Shandilya]]></dc:creator>
            <pubDate>Fri, 17 Oct 2025 03:41:48 GMT</pubDate>
            <atom:updated>2025-10-17T03:41:48.557Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*01VlVIfRwtiGbwnO" /></figure><p>In today’s fast-paced app development world, time-to-market is crucial. Businesses and developers are under immense pressure to release high-quality apps at a rapid pace. To meet these demands, many are turning to Continuous Delivery (CD) on Napptive. CD can streamline the development process and produce better apps in less time.</p><p>In this blog post, we’ll take a closer look at how using Continuous Delivery through NAPPTIVE can maximize the efficiency and quality of your Cloud-Native apps, and that too VERY EASILY!</p><h3>What is Continuous Delivery?</h3><p>Before moving forward with implementing Continuous Delivery using Napptive, let’s understand what exactly “Continuous Delivery” means.</p><p>Continuous Delivery is a software development approach that emphasizes the need to automate and streamline the entire software delivery pipeline. This pipeline includes all the stages involved in delivering a software product, from initial coding and testing to final deployment and ongoing monitoring.</p><p>Below is an image that depicts a typical Continuous Delivery workflow:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*HYXQ87ksj_COB5mp" /></figure><p>The key benefit of continuous delivery is that it enables software teams to release small and frequent updates with confidence, knowing that they have a robust set of automated tests in place to catch any errors or bugs before they are released to users.</p><p>Overall, Continuous Delivery is a powerful approach that helps software teams to improve the speed, quality, and reliability of their software development process. It allows them to deliver software more quickly and with greater confidence, ultimately resulting in happier users and more successful products.</p><h3>What is NAPPTIVE?</h3><p>Napptive is a platform that helps your organization create and use cloud-based applications. With Napptive, anyone in your team, whether they are developers or not, can easily deploy applications on modern infrastructure.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/640/0*qg1Jbk7o6U-FGMx0.gif" /></figure><p>Save time for your DevOps and Developers by making infrastructure operations more efficient:</p><ul><li>No more waiting for clusters to become available, which means less time wasted.</li><li>Team members won’t have to spend as much time installing and managing infrastructure for one-time use.</li><li>Avoid reusing Kubernetes namespaces.</li><li>Integrate with CI/CD tools easily.</li><li>Work in separate environments to handle different tasks such as testing, development, staging, and production.</li></ul><h3>Why use Continuous Delivery (CD) on Napptive?</h3><p>Continuous delivery via Napptive can prove to be a reliable solution for your DevOps workflows due to the following reasons:</p><ul><li><strong>Faster Release Cycles:</strong> CD enables developers to release smaller updates more frequently, reducing the time between releases and accelerating the feedback loop.</li><li><strong>Improved Quality:</strong> Automated testing ensures that each release is thoroughly tested before being deployed, resulting in higher-quality apps with fewer bugs.</li><li><strong>Better Collaboration:</strong> CD can foster better collaboration among developers, testers, and stakeholders by providing a standardized, automated process for deployment.</li><li><strong>Reduced Risk:</strong> CD minimizes the risk of introducing errors or bugs by automating the entire deployment pipeline and catching issues early in the process.</li></ul><h3>Implementing Continuous Delivery through Napptive with Ease</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*DGGjl7AKFJpUw38d" /></figure><p>To implement Continuous Delivery on Napptive’s web platform, follow these steps to take advantage of its powerful features:</p><ul><li><strong>Define the Process:</strong> Use Napptive’s intuitive interface to identify the stages of your development process, and easily create a customized pipeline that fits your team’s specific needs.</li><li><strong>Automate Testing: </strong>Napptive provides you with the ability to integrate CI tools such as Jenkins, Travis CI, etc In order to automate the process of running tests. This makes your application more production ready and the overall workflow more reliable.</li><li><strong>Automate Deployment:</strong> Napptive’s CI/CD tool makes it easy to automate your deployment process from end to end, with support for a wide range of deployment targets and environments.</li><li><strong>Monitor and Analyze:</strong> With Napptive’s advanced monitoring and analytics capabilities, you can gain valuable insights into your application’s performance and user behavior, and use this information to optimize your app and plan future updates.</li></ul><p>By using Napptive’s web platform for Continuous Delivery, you can streamline your development process, improve app quality, and reduce time to market. Plus, with Napptive’s flexible and customizable approach, you can easily tailor your CD pipeline to meet the unique needs of your team and your business.</p><p>To learn more about implementing a Continuous Delivery workflow for your apps, <a href="https://docs.napptive.com/?_gl=1*1iz2gbz*_ga*OTQwMzY4MzMwLjE2ODA5MzI1NzE.*_ga_8T324NDLY6*MTY4MTY1ODQ3Mi4xMy4wLjE2ODE2NTg0NzIuMC4wLjA.">get started with NAPPTIVE today!</a></p><h3>Conclusion</h3><p>Continuous delivery on Napptive can help businesses and developers produce better apps in less time. Automating the entire deployment pipeline minimizes the risk of errors or bugs and accelerates the feedback loop.</p><p>With the right tools and strategies, Continuous Delivery can maximize the efficiency and quality of your overall app development workflow.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=38de4e78b278" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>