<?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 Yashodha Samarawickrama on Medium]]></title>
        <description><![CDATA[Stories by Yashodha Samarawickrama on Medium]]></description>
        <link>https://medium.com/@yashodha.samarawickrama?source=rss-6ade3e5de331------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*Fjd8YYfKBB_7_KXj1XtxKQ.jpeg</url>
            <title>Stories by Yashodha Samarawickrama on Medium</title>
            <link>https://medium.com/@yashodha.samarawickrama?source=rss-6ade3e5de331------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 21:29:49 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@yashodha.samarawickrama/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[The 7 Nightmares of Platform Engineering, and How OpenChoreo Tackles Them]]></title>
            <link>https://medium.com/lets-code-future/the-7-nightmares-of-platform-engineering-and-how-openchoreo-tackles-them-d10d6237d4c6?source=rss-6ade3e5de331------2</link>
            <guid isPermaLink="false">https://medium.com/p/d10d6237d4c6</guid>
            <category><![CDATA[platform-engineering]]></category>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[idp]]></category>
            <category><![CDATA[openchoreo]]></category>
            <dc:creator><![CDATA[Yashodha Samarawickrama]]></dc:creator>
            <pubDate>Mon, 02 Nov 2026 13:30:13 GMT</pubDate>
            <atom:updated>2026-11-02T13:30:13.351Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OKkuPsZtg8sGg-Xc_EoYWg.png" /></figure><p>I’ve been reading <em>Platform Engineering: A Guide for Technical, Product, and People Leaders</em> by Camille Fournier and Ian Nowland (O’Reilly, 2024), and one thought kept coming back to me: the challenges described in this book aren’t hypothetical. They’re problems engineering teams deal with every day.</p><p>Around the same time, I was working hands-on with <a href="https://openchoreo.dev/"><strong>OpenChoreo</strong></a>, an open-source internal developer platform for Kubernetes. As I explored its capabilities, I started noticing something interesting: many of the problems discussed in the book were exactly the kinds of problems OpenChoreo aims to address.</p><p>Here are seven platform engineering nightmares I’ve encountered in day-to-day engineering work, customer requirements, and technical discussions — and how OpenChoreo approaches them.</p><h4><strong>Nightmare #1: </strong>Why Does Shipping a Simple API Require So Much Kubernetes Knowledge?</h4><p>Imagine a developer who just wants to ship a small API. Instead of focusing on the application itself, they first need to figure out Deployments, Services, Ingress, ConfigMaps, Secrets, and a whole lot of YAML.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WyEqBdq2JhuAXloyhktU8g.png" /></figure><p>None of these concepts is unnecessary. Kubernetes needs them to run applications reliably. But does every developer really need to understand all of them just to get their application running?</p><p>This is one of the problems platform engineering tries to solve: giving developers a simpler way to work with the infrastructure without taking away the flexibility Kubernetes provides.</p><p><strong>How OpenChoreo tackles it:</strong> OpenChoreo gives developers intent-driven abstractions so they can describe <em>what</em> they want to run rather than <em>how</em> Kubernetes should run it. The interesting part is what it doesn’t do. Many platforms try to hide Kubernetes behind proprietary layers. OpenChoreo augments it instead: developers get simpler abstractions, while platform teams keep full access to what’s underneath. Developers can still inspect the Kubernetes resources behind their apps when they need to.</p><h4><strong>Nightmare #2: </strong>When Building the Platform Becomes the Job</h4><p>Building an internal developer platform sounds straightforward at first. You need CI/CD, GitOps, observability, identity management, and a few other things. Surely, you can bring the right tools together and make them work.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/622/1*L--GcPa42LnzXf6I9JbLdg.png" /></figure><p>But integrating those tools is only the beginning. They need to work together reliably, stay compatible as they evolve, and be maintained as the organization’s needs change. Before long, the platform team can find itself spending more time maintaining integrations than improving the developer experience.</p><p><strong>How OpenChoreo tackles it:</strong> OpenChoreo ships with CI/CD, GitOps, observability, identity, audit logs, and delivery and cost insights out of the box. This gives teams a starting point without having to assemble every capability from scratch. If your organization already runs Argo, Jenkins, GitHub Actions, Flux, Okta, or Prometheus, <a href="https://openchoreo.dev/ecosystem/">you can plug those in</a> rather than ripping them out. You can also adopt OpenChoreo incrementally, which makes it far easier than a full platform rewrite.</p><h4><strong>Nightmare #3: </strong>Why Does Everything Need a Ticket?</h4><p>A developer needs a new environment, so they file a ticket. Then they wait. The platform team is buried under dozens of similar tickets, each one slightly different, each one done by hand.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/410/1*qXybq6_CmSXRvqvjIeCOqQ.jpeg" /></figure><p>This is the opposite of what a platform is supposed to be. If every request still needs a human on the platform team, you haven’t built a platform. You’ve built a queue.</p><p><strong>How OpenChoreo tackles it:</strong> OpenChoreo is built around <a href="https://openchoreo.dev/explore/backstage-powered-developer-portal/#:~:text=Developer%20Self%2DService%20Actions"><em>golden paths</em></a>: platform best practices packaged as reusable, governed, self-service workflows. Platform engineers define the paths once using OpenChoreo’s building blocks, such as environments, component types, gateways, pipelines, and workflows. Developers then use them on their own.</p><h4><strong>Nightmare #4: </strong>Why Do I Need Five Different Tools to Do One Job?</h4><p>One tool for builds, another for deployments, a third for logs, and a fourth for secrets. Each has its own UI, its own login, and its own idea of who can do what. Developers spend their day switching tabs in each of these UIs.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7uwmi6XNVyUJUxWSZ00uKg.png" /></figure><p><strong>How OpenChoreo tackles it:</strong> OpenChoreo uses one control plane with many interfaces. Developers can work through a <a href="https://openchoreo.dev/explore/backstage-powered-developer-portal/">Backstage-powered developer portal</a>, a CLI, APIs, or MCP servers for AI tools. Whichever way they come in, they get the same experience and the same access controls. Whether developers prefer the CLI or a web portal, they interact with the same platform capabilities and authorization model.</p><h4><strong>Nightmare #5: </strong>I Know My Application. Why Am I Looking at Pods?</h4><p>When an application breaks, the first thing a developer wants to know is what went wrong with their application. But investigating the issue can mean searching through logs, identifying the right pods, and figuring out which Kubernetes resources belong to the service.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/389/1*cZj8_in3TYGfWiY5m-6ofA.png" /></figure><p>The application might be called the “Payroll Service”, but the tools they’re using often expose it through infrastructure-level details. That’s a lot of context switching at a time when the developer is already trying to solve a problem.</p><p><strong>How OpenChoreo tackles it:</strong> OpenChoreo’s <a href="https://openchoreo.dev/explore/observability/">integrated observability</a> maps telemetry to the application model. Logs, metrics, traces, and alerts are organized around the things developers actually built, not the infrastructure underneath. Developers can view their own logs from the portal without asking for access to a separate tool.</p><h4><strong>Nightmare #6: </strong>Move Fast, But Don’t Break Anything</h4><p>Security and compliance teams want control. Developers want speed. Platform teams get stuck in the middle, either locking things down so tightly that nobody can move, or opening things up and hoping nothing goes wrong. Without the right guardrails, even a small configuration mistake or an overly permissive access policy can turn into a much bigger security or compliance issue.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/360/1*BbqHlJoCFK0NTMDkd8cIdQ.jpeg" /></figure><p>The challenge is finding a way to enforce policies consistently without making every deployment feel like navigating an approval maze.</p><p><strong>How OpenChoreo tackles it:</strong> OpenChoreo treats governance as part of self-service rather than its enemy. <a href="https://openchoreo.dev/docs/platform-engineer-guide/authorization/overview">RBAC and tenancy boundaries</a> give teams least-privilege access across projects, so developers can move fast inside a safe space. On top of that, both platform and application state can be <a href="https://openchoreo.dev/docs/platform-engineer-guide/gitops/overview">managed entirely through Git</a>. Git-managed changes are versioned and reviewable, giving auditors a clear history while allowing developers to work within predefined policies without unnecessary manual approval steps.</p><h4><strong>Nightmare #7: </strong>What Happens When the Platform Stops Fitting Your Needs?</h4><p>Buying a managed developer platform can feel like a shortcut, until you need to run somewhere the vendor doesn’t support, keep data inside a particular region, or customize something the product wasn’t designed for. At that point, the shortcut becomes a wall.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/360/1*ARw93pYj88bW2suj5QXP-g.jpeg" /></figure><p><strong>How OpenChoreo tackles it:</strong> OpenChoreo is open source and designed to be self-hosted across different Kubernetes environments: public cloud, on-premises, hybrid, or edge. You own the platform, your data, and where it runs. Its <a href="https://openchoreo.dev/docs/overview/architecture">modular, multi-plane architecture</a> splits the control, data, build, and observability planes, so it can grow from a single cluster to multi-cloud setups. And it’s a <a href="https://www.cncf.io/projects/openchoreo/">CNCF Sandbox project</a>, which means it’s developed in the open under a vendor-neutral foundation rather than inside a single company’s roadmap.</p><h4>Waking up from the nightmares</h4><p>No tool makes platform engineering easy. The hard parts, like understanding your developers, choosing the right abstractions, and treating the platform as a product, still belong to people. Fournier and Nowland’s book is a good reminder of that.</p><p>What a tool like OpenChoreo can do is remove the parts that shouldn’t be hard: the glue code, the fragmented tooling, and the fear of being locked in. That frees platform teams to spend their time on the problems only they can solve.</p><p>Want to explore OpenChoreo yourself? The <a href="https://openchoreo.dev/docs/getting-started/quick-start-guide/?utm_source=chatgpt.com">Quick Start Guide</a> gets you running locally with a single command in about ten minutes. <br>If you’d rather not install anything, there’s an <a href="https://demo.openchoreo.wso2.com/?utm_source=chatgpt.com">online playground</a>. <br>And if you have questions, come say hello in the #openchoreo channel on <a href="https://openchoreo.dev/slack/?utm_source=chatgpt.com">CNCF Slack</a></p><p><strong>Which of these nightmares keeps <em>you</em> up at night? </strong><br>I’d love to hear in the comments…</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/693/1*Lo1C7HmghKNp8UrsKqL1pA.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d10d6237d4c6" width="1" height="1" alt=""><hr><p><a href="https://medium.com/lets-code-future/the-7-nightmares-of-platform-engineering-and-how-openchoreo-tackles-them-d10d6237d4c6">The 7 Nightmares of Platform Engineering, and How OpenChoreo Tackles Them</a> was originally published in <a href="https://medium.com/lets-code-future">Let’s Code Future</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From Theory to TLS: Serving a Web App with Your Own ECC Certificate on OpenChoreo]]></title>
            <link>https://blog.stackademic.com/from-theory-to-tls-serving-a-web-app-with-your-own-ecc-certificate-on-openchoreo-3a3eae097828?source=rss-6ade3e5de331------2</link>
            <guid isPermaLink="false">https://medium.com/p/3a3eae097828</guid>
            <category><![CDATA[openchoreo]]></category>
            <category><![CDATA[web-app-development]]></category>
            <category><![CDATA[ecc]]></category>
            <category><![CDATA[custom-domain]]></category>
            <category><![CDATA[kgateway]]></category>
            <dc:creator><![CDATA[Yashodha Samarawickrama]]></dc:creator>
            <pubDate>Fri, 25 Sep 2026 10:48:43 GMT</pubDate>
            <atom:updated>2026-09-25T14:46:25.225Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ikypQJuYSGuKCxC5W_ECFA.png" /></figure><p>In the <a href="https://medium.com/stackademic/why-https-is-moving-from-rsa-to-ecc-understanding-modern-tls-af3c63bfc029">previous article</a>, we looked at what happens during a TLS handshake, including how ECDSA certificates authenticate a server and how ECDHE can be used to establish session keys.</p><p>In this article, we’ll put those concepts into practice by deploying a web application in <a href="https://openchoreo.dev/">OpenChoreo</a> ( a Kubernetes-native IDP and a CNCF sandbox project from WSO2), exposing it through a custom domain, and securing that domain with an ECC certificate generated using OpenSSL.</p><p>By the end, you’ll watch your own browser negotiate an ECDSA certificate and an ECDHE key exchange against a domain you set up yourself — the handshake from the last article, made real.</p><h3><strong>Prerequisites</strong></h3><ul><li>OpenChoreo running locally via the k3d quick start (Docker/Colima with <strong>8 GB RAM and 4 CPU</strong> allocated if you enable the Workflow/Observability planes)</li><li>kubectl, openssl, and dig (or nslookup) on your machine</li><li>A DNSExit account and a domain or subdomain you control, resolving to your local gateway</li></ul><h3><strong>What we’ll build</strong></h3><p>Before diving into the commands, here’s the shape of what we’re assembling. Four pieces have to line up:</p><ol><li>A <strong>web application</strong>, deployed to OpenChoreo and running on its default, auto-generated subdomain.</li><li>A <strong>custom domain</strong>, managed in DNSExit, whose DNS record points at OpenChoreo’s data-plane gateway.</li><li>An <strong>ECC certificate and private key</strong>, generated locally with OpenSSL — an ECDSA cert on the P-256 curve.</li><li>OpenChoreo configured to <strong>serve that domain over HTTPS using our certificate</strong>, so the gateway terminates TLS with ECC.</li></ol><h4><strong>Deploy the web app</strong></h4><p>To keep the focus on domains and certificates rather than on building an app from scratch, we’ll deploy the sample <a href="https://openchoreo.dev/docs/getting-started/quick-start-guide/"><strong>React starter</strong></a> web application that OpenChoreo ships with. There’s a helper script for exactly this:</p><pre>./deploy-react-starter.sh</pre><p>Behind the scenes, this creates a <strong>Component</strong> in OpenChoreo. Once it finishes, open OpenChoreo’s developer portal (the Backstage-based console) and head to <strong>Catalog → Default Project</strong>. <br>The new component, react-starter, now appears under the project&#39;s contents:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yotCRayvc7kJUsKo-0y7AQ.png" /><figcaption>Default Project overview — the react-starter component deployed to Development</figcaption></figure><p>Two details on this page matter for what comes later:</p><ul><li><strong>Kind: Component · Type: </strong><strong>deployment/web-application</strong> — OpenChoreo knows this is a web app meant to be exposed over HTTP(S). That&#39;s what makes the custom-domain and TLS options available to us further down.</li><li><strong>Environments</strong> — the component flows through a <strong>Development → Staging → Production</strong> pipeline. We’ll work in <strong>Development</strong>, where you can already see it’s deployed (the green check).</li></ul><p>At this point, the app is live, but only on an <strong>auto-generated hostname</strong> that OpenChoreo assigns from its data-plane gateway.</p><p>Open the react-starter component and grab its default URL. The React starter page should load over that hostname.</p><p>To find where it’s actually served, open the <strong>Deploy</strong> tab and expand the Development environment’s <strong>Endpoint URLs</strong>. OpenChoreo exposes an auto-generated <strong>External</strong> URL:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6l5sRi16t_J1nIjcuqHGYg.png" /><figcaption>The Endpoint URLs dialog showing the auto-generated External URL</figcaption></figure><p>Open it in your browser and the React starter page loads:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*Wo8o0bJAVBRbW8okfwknzQ.png" /><figcaption>The React starter app running on its default OpenChoreo URL</figcaption></figure><p>This is our baseline: a working web app, reachable over a hostname we didn’t choose. <br>Everything from here is about putting it behind a domain we <em>do</em> control — and securing that domain with our own ECC certificate.</p><h4><strong>Register the custom domain in DNSExit</strong></h4><p>Our app runs locally, so we don’t need a public server — but we <em>do</em> need a real domain name that resolves to our machine, because a TLS certificate is issued to a <strong>hostname</strong>, not to a raw IP or an auto-generated URL. For this walkthrough I’m using ecctest.work.gd, a domain I created in <a href="https://dnsexit.com/">DNSExit</a>.</p><p>In the DNSExit control panel, edit the A record for the domain and set its address to 127.0.0.1:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6QjtOBzi-FfxvRBtWz6l9A.png" /><figcaption>DNSExit A record for ecctest.work.gd -&gt; 127.0.0.1</figcaption></figure><p>Then confirm it resolves from your terminal:</p><pre>dig +short ecctest.work.gd<br>127.0.0.1</pre><p><strong>A note on what this does and doesn’t do.</strong> Because we’re pointing DNS at 127.0.0.1, this domain only reaches the app on your own machine. It isn&#39;t exposed to the public internet, and it will resolve to loopback rather than to a public server.</p><p>DNS has done only one small job here: it mapped a <strong>name</strong> to an <strong>IP</strong>. It hasn’t said anything about which app answers, or on which port. That routing is the gateway’s job, and we’ll configure it in OpenChoreo shortly.</p><h4><strong>Generate the ECC cert locally</strong></h4><p>This is where the theory from the <a href="https://medium.com/stackademic/why-https-is-moving-from-rsa-to-ecc-understanding-modern-tls-af3c63bfc029">last article</a> becomes something you can hold. We’ll generate an <strong>ECDSA certificate on the P-256 curve</strong> — the exact kind of certificate we discussed when we talked about how a server proves its identity during the handshake. And we’ll do it with nothing but OpenSSL.</p><p>Because this is a local demo, the certificate will be <strong>self-signed</strong> — we’re acting as our own certificate authority. A public CA like Let’s Encrypt would sign it for the whole internet to trust; here, we just need a valid ECC certificate bound to our hostname, and self-signing gives us that in one command.</p><p><strong>Step 1 — Generate the ECC private key.<br></strong>We’ll use prime256v1 — OpenSSL&#39;s name for the NIST P-256 curve, the most widely deployed curve in modern TLS:</p><pre>openssl ecparam -name prime256v1 -genkey -noout -out ecctest.key</pre><p><strong>Step 2 — Create a self-signed certificate for our hostname<br></strong>Now we wrap that key in a certificate that names our domain.</p><pre>openssl req -new -x509 \<br> -key ecctest.key \<br> -out ecctest.crt \<br> -days 365 \<br> -subj “/CN=ecctest.work.gd” \<br> -addext “subjectAltName=DNS:ecctest.work.gd”</pre><p><strong>Step 3 — Prove it’s actually ECC<br></strong>This is where we verify the result. Rather than simply trusting OpenSSL, inspect the certificate and confirm, line by line, that it has the characteristics we expect.</p><pre>openssl x509 -in ecctest.crt -text -noout</pre><p>In the output, look for three things: the Signature Algorithm, the Public Key Algorithm, and the curve.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ba_WArZ6VkYhNUO74r9MWA.png" /><figcaption>openssl x509 -text output, with id-ecPublicKey, prime256v1, and ecdsa-with-SHA256</figcaption></figure><p>We now have a genuine ECC certificate — ECDSA, P-256, bound to our domain. The next step is to hand it to OpenChoreo so the gateway presents it to browsers connecting to ecctest.work.gd.</p><h4><strong>Add the cert to OpenChoreo</strong></h4><p>We have a domain that resolves to our machine and an ECC certificate that names that domain. The last piece is telling OpenChoreo to serve our web app over HTTPS using that certificate.</p><p>The first thing to know is what <em>isn’t</em> here. OpenChoreo (at the version used here, v1.2.5) has no “upload a certificate” screen in the portal, and no custom-domain abstraction of its own — you won’t find a certificate resource among its CRDs. That isn’t so much a gap as a design choice: OpenChoreo is built on the <strong>Kubernetes Gateway API</strong>, and it expects TLS and routing to be expressed using those native Kubernetes resources.<br>So that’s the layer we’ll work at.</p><p>If you inspect the data plane, you’ll find a single Gateway named gateway-default, backed by kgateway. <br>Right now it has exactly one listener — plain HTTP on port 19080 — which is why our app has only ever been reachable over http://:</p><pre>kubectl get gateway gateway-default -n openchoreo-data-plane \<br> -o jsonpath=’{range .spec.listeners[*]}{.name}{“ “}{.protocol}{“ :”}{.port}{“\n”}{end}’</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cOqp2unDIjWBjS8T8m0RjQ.png" /></figure><p>There is no HTTPS at all yet. We’re about to add it. <br>This helps to hold the goal as three distinct pieces :</p><ul><li>a <strong>certificate</strong> the gateway can present (a Kubernetes TLS secret),</li><li>an <strong>HTTPS listener</strong> that serves our hostname and presents that certificate,</li><li>a <strong>route</strong> that forwards requests for our hostname to the web app.</li></ul><p>Now let’s create each.</p><p><strong>Step 1 — Store the ECC certificate as a Kubernetes secret</strong></p><p>The Gateway reads its certificate from a kubernetes.io/tls secret in its own namespace, so we create ours in openchoreo-data-plane from the two files we generated earlier:</p><pre>kubectl create secret tls ecctest-tls \<br> — cert=ecctest.crt — key=ecctest.key \<br> -n openchoreo-data-plane</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NFYHvxAI1VSoXZZwPww-Fg.png" /></figure><p>This is also the quiet answer to a question that worries people coming from RSA-only platforms: <em>will OpenChoreo accept an ECC cert? well </em>a Kubernetes TLS secret is just a certificate and a key, and the gateway serves ECDSA certificates without issue.</p><p><strong>Step 2 — Add an HTTPS listener for our domain</strong></p><p>Now we add a listener to gateway-default that serves our domain ecctest.work.gd over HTTPS and presents our secret. <br>We <em>add</em> it alongside the existing HTTP listener rather than replacing anything, so the platform&#39;s default routing keeps working untouched:</p><pre>kubectl patch gateway gateway-default -n openchoreo-data-plane — type=’json’ \<br> -p=’[{“op”:”add”,”path”:”/spec/listeners/-”,”value”:{<br> “name”:”https-ecctest”,<br> “port”:19443,<br> “protocol”:”HTTPS”,<br> “hostname”:”ecctest.work.gd”,<br> “tls”:{“mode”:”Terminate”,”certificateRefs”:[{“kind”:”Secret”,”name”:”ecctest-tls”}]},<br> “allowedRoutes”:{“namespaces”:{“from”:”All”}}<br> }}]’</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NYSIYytFGoCB4k95Kk1lgg.png" /></figure><p>A few of these fields carry the whole intent. <br>protocol: HTTPS with tls.mode: Terminate tells the gateway to <em>terminate</em> TLS here — decrypt at the edge and forward plain HTTP to the app behind it. <br>certificateRefs points at the ECC secret from Step 1, so this is the certificate the gateway presents during the handshake. <br>hostname: ecctest.work.gd scopes the listener to our domain: the gateway will present our certificate only for connections asking for that name. <br>Port 19443 is deliberate — on this local k3d setup that host port is already forwarded into the cluster, so we don&#39;t need to touch any port mapping.</p><p><strong>Step 3 — Route the domain to the web app</strong></p><p>The listener accepts the connection, but something still has to say <em>which app</em> a request for ecctest.work.gd belongs to. That&#39;s an HTTPRoute. <br>We create our own — leaving the auto-generated react-starter route (which OpenChoreo&#39;s controller owns and manages) alone — binding our hostname to that listener and pointing it at the react-starter service:</p><pre>kubectl apply -f — &lt;&lt;’EOF’<br>apiVersion: gateway.networking.k8s.io/v1<br>kind: HTTPRoute<br>metadata:<br> name: ecctest-route<br> namespace: dp-default-default-development-f8e58905<br>spec:<br> hostnames: [“ecctest.work.gd”]<br> parentRefs:<br> — group: gateway.networking.k8s.io<br> kind: Gateway<br> name: gateway-default<br> namespace: openchoreo-data-plane<br> sectionName: https-ecctest<br> rules:<br> — matches:<br> — path: { type: PathPrefix, value: / }<br> backendRefs:<br> — kind: Service<br> name: react-starter<br> port: 8080<br>EOF</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/826/1*aNbmQq3wjTMkGcuHLg-0og.png" /></figure><p>The sectionName: https-ecctest is the important link — it attaches this route specifically to the HTTPS listener we just added, not the HTTP one. The backendRefs entry is the react-starter Service on port 8080, in the environment namespace OpenChoreo created for it.</p><p>One check tells us the pieces connected correctly — that the listener came up and our route attached to it:</p><pre>kubectl get gateway gateway-default -n openchoreo-data-plane \<br> -o jsonpath=’{range .status.listeners[*]}{.name}{“ attachedRoutes=”}{.attachedRoutes}{“\n”}{end}’</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KIS5Rznph45e4F7uavSj2w.png" /></figure><p>https-ecctest attachedRoutes=1 is what we&#39;re after: the HTTPS listener exists, it&#39;s holding our ECC certificate, and exactly one route (ours) is bound to it. <br>The gateway is now ready to serve ecctest.work.gd over TLS.</p><h4><strong>Serve and verify</strong></h4><p>Everything is wired up. Now for the part that makes it real — watching a TLS handshake complete against our own domain, using the certificate we built by hand.</p><p>The most revealing way to see a handshake is curl with the -v (verbose) flag, which prints the TLS negotiation step by step. <br>We’ll add -k as well, because our certificate is self-signed -k tells curl to complete the connection even though no public authority vouches for the certificate.</p><pre>curl -vk https://ecctest.work.gd:19443</pre><p>The output is worth reading slowly, because almost every line maps to a concept from the previous article. Here are the parts that matter:</p><pre>*   Trying 127.0.0.1:19443...<br>* TLSv1.3 (OUT), TLS handshake, Client hello (1):<br>* TLSv1.3 (IN), TLS handshake, Server hello (2):<br>* TLSv1.3 (IN), TLS handshake, Certificate (11):<br>* TLSv1.3 (IN), TLS handshake, CERT verify (15):<br>* TLSv1.3 (IN), TLS handshake, Finished (20):<br>* SSL connection using TLSv1.3 / TLS_AES_256_GCM_SHA384 / x25519 / id-ecPublicKey<br>* Server certificate:<br>*   subject: CN=ecctest.work.gd<br>*   issuer: CN=ecctest.work.gd<br>*   Certificate level 0: Public key type EC/prime256v1 (256/128 Bits/secBits), signed using ecdsa-with-SHA256<br>* OpenSSL verify result: 12<br>*  SSL certificate verification failed, continuing anyway!<br>&lt; HTTP/2 200<br>&lt; server: envoy</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XlHPV_IrpxljS1in6BJwKg.png" /><figcaption>The TLS 1.3 handshake from our curl output, step by step</figcaption></figure><p><strong>Seeing it in the browser</strong></p><p>curl proves that everything works; the browser is where you get to see it come alive. Open https://ecctest.work.gd:19443. <br>Because the certificate is self-signed, the browser will warn you that the connection isn&#39;t trusted — choose <strong>Advanced → proceed</strong> to continue. <br>The React starter app then loads on your own domain, over HTTPS.</p><p>Click the “Not secure” warning indicator and view the certificate details. You’ll see it issued to ecctest.work.gd, using an <strong>Elliptic Curve</strong> public key on the <strong>P-256</strong> curve, signed with <strong>ECDSA with SHA-256</strong> — the certificate you generated, now securing a live connection.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QiJSjK2gpVIVzeT_UeVfXQ.png" /><figcaption>The connection is encrypted using our ECC certificate, and the React app is served on our custom domain</figcaption></figure><h3><strong>Gotchas</strong></h3><p>When you open https://ecctest.work.gd:19443 in a browser, you&#39;ll be greeted not by a padlock but by a warning — &quot;Not Secure,&quot; or a full interstitial you have to click through.</p><p>After all that work, it&#39;s a natural moment to wonder what went wrong …<br>Nothing went wrong. This warning is the expected outcome and understanding why is worth more than any padlock !</p><p><strong>Encryption and trust are two different things.</strong> The browser’s warning is a statement about <em>trust</em>, not <em>encryption</em>. Our curl output already proved the connection is genuinely encrypted: TLS 1.3, an ECDHE key exchange, our ECDSA certificate presented and used. That part works perfectly. What the browser objects to is that it cannot <em>trust</em> the certificate — it can&#39;t trace it back to any authority it recognizes.</p><p>The reason is that our certificate is <strong>self-signed</strong>. Recall the two identical lines from the handshake:</p><pre>subject: CN=ecctest.work.gd<br>issuer: CN=ecctest.work.gd</pre><p>The <strong>subject</strong> (who the certificate is <em>for</em>) and the <strong>issuer</strong> (who <em>vouches</em> for it) are the same entity — us. <br>When we generated the certificate with OpenSSL, we acted as our own certificate authority. Every browser ships with a built-in list of trusted root authorities (DigiCert, Let’s Encrypt, and around a hundred others), and it will only show a padlock for certificates that chain back to one of them. Ours doesn’t, so the browser does exactly what it should: <em>it encrypts the traffic, but warns that it can’t confirm who is on the other end.</em></p><p>That distinction is the whole reason the previous article separated the two jobs in a handshake. A certificate <em>authenticates</em> a server — but authentication only means something if a party you trust signed it. Self-signing gives us a valid ECC certificate and real encryption; it just skips the trusted third party. So the warning isn’t a failure of ECC or of our setup — it’s the missing trust link, made visible.</p><p>Click into the browser’s certificate viewer and you’ll see it:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/1*lQCiU3Q7hiJvkTBtfT4Y6w.png" /><figcaption>Elliptic Curve public key on P-256, signed with ECDSA with SHA-256 — issued to ecctest.work.gd</figcaption></figure><p>For this walkthrough, using the above self-signed certificate lets us generate, inspect, and serve a real ECC certificate end to end, and it made the trust-versus-encryption distinction impossible to miss.</p><h3>Wrapping up</h3><p>We started the previous article with a claim that was easy to state and hard to feel: that the web is moving from RSA to ECC, and that a modern TLS handshake leans on elliptic curves for both key exchange and identity. <br>This time, we made it concrete.</p><p>Along the way we deployed a web application to OpenChoreo, gave it a domain we control through DNSExit, generated an ECDSA certificate on the P-256 curve with nothing but OpenSSL, and configured OpenChoreo’s Gateway API layer to serve that domain over HTTPS with our certificate. Then we watched the handshake happen — curl showed us TLS 1.3 negotiating an ECDHE key exchange and presenting our ECDSA certificate in real time.</p><p><strong>A few ideas are worth carrying forward from this article :</strong></p><p>The certificate and the connection are not the same thing.<br>Encryption and trust are also separate.<br>Different IDP platforms expose these mechanics at different levels.</p><p>If you want to take this further, the natural next step is to swap the self-signed certificate for a publicly trusted ECDSA certificate using the same elliptic-curve handshake.</p><p>For now, though, we’ve taken the theory of modern TLS and made it real — a web application, on our own domain, secured by an elliptic-curve certificate we built and served ourselves.</p><h3>Before you go</h3><ul><li>Please take a moment to like the post and follow the writer!</li><li>Did you know that over 400,000 developers share what they’re building, learning, and discovering across our platforms every month? Learn how you can contribute <a href="https://plainenglish.io/write-for-us">here</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3a3eae097828" width="1" height="1" alt=""><hr><p><a href="https://blog.stackademic.com/from-theory-to-tls-serving-a-web-app-with-your-own-ecc-certificate-on-openchoreo-3a3eae097828">From Theory to TLS: Serving a Web App with Your Own ECC Certificate on OpenChoreo</a> was originally published in <a href="https://blog.stackademic.com/">Stackademic</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why HTTPS Is Moving from RSA to ECC: Understanding Modern TLS]]></title>
            <link>https://blog.stackademic.com/why-https-is-moving-from-rsa-to-ecc-understanding-modern-tls-af3c63bfc029?source=rss-6ade3e5de331------2</link>
            <guid isPermaLink="false">https://medium.com/p/af3c63bfc029</guid>
            <category><![CDATA[web-security]]></category>
            <category><![CDATA[tls-handshake]]></category>
            <category><![CDATA[ecc]]></category>
            <category><![CDATA[https]]></category>
            <category><![CDATA[rsa]]></category>
            <dc:creator><![CDATA[Yashodha Samarawickrama]]></dc:creator>
            <pubDate>Sat, 22 Aug 2026 11:19:47 GMT</pubDate>
            <atom:updated>2026-08-22T11:19:47.045Z</atom:updated>
            <content:encoded><![CDATA[<p>Every time you visit a website whose address starts with https, a tiny cryptographic handshake just happened in the background. Your browser and the website proved they were who they claimed to be, agreed on a secret code, and started talking privately — all in a fraction of a second.</p><p>For decades, the math behind that handshake was almost always the same: an algorithm called <strong>RSA</strong>. But over the last few years, a quieter, faster, more elegant approach has been taking over. It’s called <strong>ECC</strong> — Elliptic Curve Cryptography — and if you run a website, manage servers, or are just curious about how the web stays secure, it’s worth understanding.</p><p>This article is a beginner’s guide on what ECC certificates are, why they’re beating RSA, the TLS handshake, and what happens when quantum computers eventually enter the picture.</p><h3>First, what’s a certificate anyway?</h3><p>An SSL/TLS certificate is basically a digital ID card for a website. It does two jobs:</p><ol><li>Proves identity. It tells your browser, “Yes, this really is yourbank.com, verified by a trusted Certificate Authority” — not an impostor sitting in the middle.</li><li>Carries the server’s public key. In older TLS connections, this public key was also used to encrypt the session secret. In modern TLS, its primary role is to prove the server’s identity, while a separate mechanism establishes the encrypted session.</li></ol><p>Every certificate is built on a pair of mathematical keys: <strong>a <em>public</em> key</strong> everyone can see, and <strong>a <em>private</em> key</strong> the server guards closely.</p><p>The security of the whole system rests on one idea — it should be easy to do the math in one direction (locking) but practically impossible to reverse it (unlocking) without the private key.</p><p>The interesting question is: <em>what math</em> do you use to make that one-way street? That’s where <strong>RSA</strong> and <strong>ECC</strong> differ.</p><h3>What ECC actually is (no scary equations, I promise)</h3><p>RSA’s security comes from the difficulty of factoring enormous numbers. <br>If I multiply two huge prime numbers together, handing you the result and asking you to find the original primes is extremely hard. That’s the mathematical puzzle RSA relies on.</p><p>ECC relies on a completely different puzzle called the <strong>elliptic curve discrete logarithm</strong> problem. Instead of giant numbers and factorization, it uses special mathematical structures known as elliptic curves.</p><p>RSA and ECC are solving two entirely different problems.</p><ul><li>RSA’s puzzle: “Can you figure out which two giant primes I multiplied?”</li><li>ECC’s puzzle: “Can you solve this extremely difficult elliptic curve problem?”</li></ul><p>The important takeaway isn’t the mathematics — it’s the efficiency. The elliptic curve problem provides much more security for each bit of key size, allowing ECC to achieve security comparable to RSA while using dramatically smaller keys.</p><h3>A simple analogy</h3><p>Imagine protecting a treasure.</p><p><strong>RSA — </strong>Uses a <strong>2-ton steel door</strong>. Very secure, but heavy and slow to open.</p><p><strong>ECC — </strong>Uses a <strong>lightweight futuristic door</strong>. Much lighter, but just as difficult to break into.</p><p>Both protect the treasure, but ECC does it more efficiently.</p><p>ECC is the <strong>umbrella term</strong> for the whole approach. <br>When ECC is used to sign a certificate and prove identity, the specific algorithm is called <strong>ECDSA</strong> (Elliptic Curve Digital Signature Algorithm). When it’s used to agree on a session key, it’s called <strong>ECDHE (</strong>Elliptic Curve Diffie-Hellman Ephemeral).</p><h3>Why do smaller keys matter?</h3><p>The surprising part is that smaller doesn’t mean weaker. For roughly the same level of security, RSA needs keys that are thousands of bits long, while ECC can achieve it with just a few hundred bits. <br>Smaller keys mean smaller certificates, faster TLS handshakes, and less CPU work for both servers and browsers — especially valuable on high-traffic services and mobile devices.</p><h3><strong>The Handshake: </strong>What actually happens during an HTTPS connection?</h3><p>Every time you open an HTTPS website, your browser and the server have a very short conversation called the TLS handshake. Its job is to answer two questions:</p><ol><li>Is this really the website I intended to visit?</li><li>How can we create a secret key that only the two of us know?</li></ol><p>The certificate answers the first question by proving the server’s identity. The second is handled by the key exchange mechanism — and this is where the difference between traditional RSA and modern ECDHE becomes important.</p><p>Now let’s see how those two approaches differ.</p><p>A quick but important distinction: <em>an ECC certificate doesn’t automatically mean the connection uses ECC for everything</em>. <br>In modern TLS, the certificate usually uses ECDSA to prove the server’s identity, while ECDHE is the separate mechanism that creates the shared session key. They’re related, but they do different jobs.</p><h3>Traditional RSA: the browser delivers the secret</h3><p>In the classic RSA model, the browser is responsible for creating the session key. Let’s take an example where a browser is communicating with a bank. <br>The important idea here is simple: <em>The browser creates the secret, encrypts it with the server’s public key, and the server decrypts it with its private key.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*46Ms2Ni4tLV6wOyyD6Z0rg.png" /></figure><p>The browser generates the session secret and sends it encrypted with the server’s public key. Anyone intercepting the traffic sees only ciphertext.</p><h3>Modern ECDHE: nobody sends the secret</h3><p>This is where ECC becomes much more interesting. <em>Instead of the browser creating and sending the session key, each side generates a temporary private value, exchanges only the corresponding public key value, and independently arrives at the exact same shared secret.</em> The shared secret is never transmitted — only the public key values are — this is the magical part of ECDHE.</p><p><em>But wait… how do they both end up with the same secret </em>🤔<em>?</em></p><p>Here is the step-by-step process of how they do it.</p><p><strong>1. The Setup (Choosing the Curve)</strong></p><ul><li>Both the browser and the bank agree on the math rules.</li><li>They choose a specific <strong>Elliptic Curve</strong> (like X25519 or P-256) and a standard starting point on that curve, known as the <strong>Generator Point (G)</strong>.</li></ul><p><strong>2. Key Generation</strong></p><p>Both the browser and the bank generate their own temporary (ephemeral) keypairs:</p><ul><li><strong>The Browser</strong> picks a random secret number a (<strong>Browser Private Key</strong>) and calculates A = a × G (<strong>Browser Public Key</strong>).</li><li><strong>The Bank</strong> picks a random secret number b (<strong>Server Private Key</strong>) and calculates B = b × G (<strong>Server Public Key</strong>).</li></ul><p><strong>3. The Public Exchange</strong></p><ul><li>The browser sends its ephemeral public key (A) to the bank.</li><li>The bank sends its ephemeral public key (B) to the browser.</li></ul><p><em>Here anyone listening on the network can see A and B, but they cannot figure out the private secrets a or b.</em></p><p><strong>4. The Secret Calculation</strong></p><p>This is where the standard mathematical property of ECC comes into play. Because of the mathematical properties of elliptic curve scalar multiplication, both sides can independently calculate the exact same point on the curve:</p><ul><li><strong>The Browser</strong> takes the Server’s Public Key (B) and multiplies it by its own Private Key (a)</li><li><strong>The Server</strong> takes the Browser’s Public Key (A) and multiplies it by its own Private Key (b):</li></ul><p>Both calculations result in the exact same point on the curve (x, y) which is then used to derive the symmetric session key.</p><blockquote><em>a×B=b×A=(x,y)</em></blockquote><p><strong>5. Creating the Session Key</strong></p><ul><li>The shared (x, y) point is <strong>not</strong> used directly as the encryption key.</li><li>Both the browser and server extract the x-coordinate from that shared point.</li><li>They independently pass that value through a Key Derivation Function (HKDF), which uses a cryptographic hash such as SHA-256.</li><li>The output is the final symmetric session key, which is used by encryption algorithms like AES-GCM or ChaCha20-Poly1305 to protect the rest of the HTTPS connection.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0iw5vANy5_0U9kXyvWHYGA.png" /></figure><h3>What if my browser supports RSA, but the bank uses an ECC certificate?</h3><p>The good news is yes, they can still communicate.</p><p>Browsers don’t carry RSA or ECC certificates — they support cryptographic algorithms. During the TLS handshake, the browser tells the server which signature and key exchange algorithms it understands. <br>If it supports ECDSA and ECDHE, it can verify the bank’s ECC certificate and complete the connection normally.</p><p>The connection only fails if the browser is so old that it doesn’t support ECC at all. That’s now extremely rare, which is why most modern websites can safely deploy ECC certificates.</p><h3>Will quantum computers break HTTPS?</h3><p>Everything we’ve discussed so far — RSA, ECDSA, and ECDHE — depends on mathematical problems that are considered infeasible for today’s computers. <em>Quantum computers change that assumption</em>.</p><p>A sufficiently powerful quantum computer running <strong>Shor’s algorithm</strong> could solve both of these hard problems efficiently:</p><ul><li>RSA: Integer factorization</li><li>ECC: Elliptic curve discrete logarithms</li></ul><p>That means both RSA and ECC would eventually become vulnerable. ECC isn’t “quantum-safe” — it’s simply more efficient than RSA on classical computers.</p><h4>Does that mean HTTPS is doomed?</h4><p>Fortunately, no.</p><p>The cryptography community has been preparing for this for years through <strong>Post-Quantum Cryptography (PQC)</strong>. <br>Rather than replacing HTTPS overnight, modern TLS is gradually adopting hybrid key exchanges that combine ECC with a quantum-resistant algorithm.</p><p>Instead of relying on one mathematical puzzle, the browser and server derive the session key from both mechanisms. An attacker would need to break both ECC and the post-quantum algorithm to recover the secret, making the transition much safer.</p><p><strong>The bottom line: </strong><em>ECC is the present, not the future.</em> It’s the most efficient and widely deployed public-key cryptography for today’s web, while post-quantum algorithms are being introduced alongside it — not as an overnight replacement.</p><p>The remarkable thing about HTTPS isn’t that it became more complicated — it’s that it became more elegant. Modern TLS quietly replaced heavier cryptography with smaller keys, faster handshakes, and stronger forward secrecy, all without changing the little padlock we click every day. <br>The next evolution won’t replace that experience either; it’ll simply make it resilient against the quantum era.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=af3c63bfc029" width="1" height="1" alt=""><hr><p><a href="https://blog.stackademic.com/why-https-is-moving-from-rsa-to-ecc-understanding-modern-tls-af3c63bfc029">Why HTTPS Is Moving from RSA to ECC: Understanding Modern TLS</a> was originally published in <a href="https://blog.stackademic.com/">Stackademic</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[ADLC vs SDLC: The Moment I Realized Software Engineering Had Changed]]></title>
            <link>https://blog.stackademic.com/adlc-vs-sdlc-the-moment-i-realized-software-engineering-had-changed-35c8d124f845?source=rss-6ade3e5de331------2</link>
            <guid isPermaLink="false">https://medium.com/p/35c8d124f845</guid>
            <category><![CDATA[agentic-ai]]></category>
            <category><![CDATA[sdlc]]></category>
            <category><![CDATA[coding]]></category>
            <category><![CDATA[adlc]]></category>
            <category><![CDATA[ai-agent]]></category>
            <dc:creator><![CDATA[Yashodha Samarawickrama]]></dc:creator>
            <pubDate>Fri, 03 Jul 2026 10:27:00 GMT</pubDate>
            <atom:updated>2026-07-06T09:19:12.223Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*sB2_3a7tLZfcef4CuWt56w.png" /></figure><p>Ever since I was a little kid, software engineering felt structured to me. There was always a process. A flow. A lifecycle.</p><p>In university, in tutorials, in interviews, in my first job — <strong>SDLC</strong> was everywhere.</p><p>Requirements -&gt; Design -&gt;Development -&gt;Testing -&gt; Deployment -&gt; Maintenance</p><p>It almost felt sacred.</p><p>The idea that good software came from predictability was deeply wired into me as a developer. If something broke, there had to be a reason. If the logic was correct, the system should behave correctly too.</p><p>And honestly, for the longest time, that belief worked.</p><p>For decades, the Software Development Lifecycle (SDLC) has been the backbone of modern engineering. Requirement gathering, design, development, testing, deployment, and maintenance formed a predictable pipeline for building software systems.</p><p>AI agents are now changing the nature of software itself. And not just the software we ship.<strong> The way we <em>make</em> it.</strong></p><h4><strong>The moment it broke for me</strong></h4><p>The realization didn’t arrive as a headline. It arrived while I was staring at a pull request.</p><p>The code was good. Clean, idiomatic, well-structured. It handled edge cases I hadn’t even thought to mention. It was, in a few places, better than what I would have written. <em>And I hadn’t written a line of it </em>🤷🏻‍♀️</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/480/1*FD7DDh0MTDHv3Gahl_SszA.gif" /><figcaption>GIF credits : <a href="https://giphy.com/">https://giphy.com/</a></figcaption></figure><p>An agent had. I’d described what I wanted — the intent, the constraints, the shape of the thing — and it produced the implementation. My job, in that moment, wasn’t to <em>write</em>. It was to <em>read, judge, and decide whether to trust it.</em></p><p>My first feeling was excitement. This was fast. This was powerful.</p><p>My second feeling, arriving about ten seconds later : <strong><em>if I’m not the one writing the code anymore, what exactly am I? </em></strong>🤔</p><p>That’s the moment. A small, disorienting tilt in the floor.</p><p>For my entire career, “development” meant <em>me</em>, typing, translating logic into syntax. That act was the job. <strong><em>It was also, if I’m honest, the part of my identity I was proudest of.</em></strong></p><p>Now the act had moved. I was still responsible for the outcome — but I was no longer the author of it.</p><h4>Two things people call “ADLC” (and why the difference matters)</h4><p>Before I go further, a quick untangling, because the acronym is overloaded and it caused <em>me</em> real confusion.</p><p>Some people use “ADLC” to mean the <strong>Agent Development Lifecycle</strong> — the phases of building an agent <em>as your product</em>. There, the agent is the thing you ship, and the lifecycle changes because the product itself is non-deterministic.</p><p><strong>That’s not what this article is about.</strong></p><p>I’m talking about the other one: the <strong>Agent-Driven Development Lifecycle</strong> — where AI agents become active participants in <em>how software gets built</em>, rather than tools that merely autocomplete. The product might be perfectly ordinary software. What’s changed is <em>who does the building.</em></p><blockquote>In SDLC -&gt; the human executes and the tools assist. <br>In the agent-driven model -&gt; the human orchestrates and the agent executes. <br><strong>Humans move toward the <em>what</em> and the <em>why</em>. Agents increasingly own the <em>how</em>.</strong></blockquote><p>That inversion is small to describe and enormous to live inside.</p><h4><strong>How the lifecycle actually bends into the software development processes</strong></h4><p>Here’s the part I find genuinely interesting: the phases don’t disappear. They shift <em>who’s doing them</em> and <em>where the hard part lives.</em></p><ul><li><strong>Requirements stop being a document and start being a conversation with the machine.</strong> The clearer your intent, the better the output. Vague requirements used to produce delayed code; now they produce <em>confidently wrong</em> code, fast. The skill of specifying — precisely, unambiguously, with the right constraints — becomes the front-line engineering skill. Your prompt is your spec, and an incomplete spec is a sloppy build.</li><li><strong>Development becomes delegation and steering.</strong> You’re not writing the loop; you’re deciding whether the loop the agent wrote is the right one, in the right place, doing the right thing. The bottleneck moves off your keyboard. It’s no longer <em>how fast can I type</em> — it’s <em>how fast and how well can I direct, and then verify.</em></li><li><strong>Testing shifts from “did my code work” to “did the code I didn’t write work — and do I understand it well enough to sign off?”</strong> This is the uncomfortable one. Reviewing volume you didn’t author is a different cognitive load than reviewing your own work. You lose the built-in understanding that comes from having typed every line. You have to <em>reconstruct</em> comprehension after the fact.</li><li><strong>The bottleneck becomes review capacity and trust.</strong> When an agent can produce more code in an hour than you can carefully read in a day, the constraint on shipping isn’t generation anymore. It’s <em>verification.</em> The engineer becomes the rate limiter — and the quality gate.</li><li><strong>Maintenance gets stranger.</strong> You may end up maintaining systems no single human fully holds in their head, because no single human wrote them. The documentation, the intent capture, the “why is it like this” — those become survival tools, not nice-to-haves.</li></ul><p>Notice the pattern: <strong><em>almost every phase moves the human up a level of abstraction — from doing the work to directing and validating it.</em></strong></p><h4>The part I’m genuinely torn about</h4><p>I want to be honest, because pretending this is all upside wouldn’t be true.</p><p>The benefits are obvious. <br>I can ship faster than I ever could before. <br>I spend less time writing boilerplate and more time thinking about architecture, product decisions, and solving the problems that actually need human judgment. <br>That’s real, and it’s hard to ignore.</p><p>But there are still things that bother me.</p><p>I wonder what happens to our engineering instincts if we stop writing the hard parts ourselves. A lot of the judgment I use today — spotting edge cases, questioning implementations, knowing when something feels off — came from writing code. <em>If we skip that journey, where does that intuition come from?</em></p><p>I also find myself trusting code I didn’t write. Most of the time it’s fine, but reviewing agent-generated code isn’t the same as reviewing something I built line by line. <strong><em>That’s a different kind of responsibility.</em></strong></p><p>And if I’m being completely honest, I do miss writing code sometimes. <br>Not because AI can’t do it, but because I genuinely enjoyed it. <br>There’s something satisfying about building a clean solution yourself that prompting an agent doesn’t quite replace.</p><h3>What survives</h3><p>Here’s what steadies me when the unease gets loud.</p><p>The instincts that made me good didn’t come <em>from</em> typing. They came from <em>thinking</em> — about failure modes, about what “correct” really means, about what the user actually needs, about the difference between code that works and code that’s right.</p><p>Those instincts don’t get automated away by an agent writing the implementation. If anything, they become the <em>whole job.</em> <br>Taste, judgment, the ability to know what good looks like and catch what’s wrong at a glance —<strong><em> that’s exactly what you need when you’re reviewing more than you’re writing</em></strong>.</p><p>The craft didn’t vanish. It moved.<em> From writing the answer to knowing the right answer when you see it, and demanding it when you don’t.</em></p><h3>The pipeline, one more time</h3><p>I started with that sacred pipeline. <br>Requirements → Design → Development → Testing → Deployment → Maintenance. <br>Cause to effect. <br>Correct logic to correct behavior. <br>Me, commanding the machine, line by line.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/503/1*zDvR3_AIN1kmg6AiYJ4qLg.jpeg" /><figcaption>Image credits : <a href="https://imgflip.com/i/6pdgaz">https://imgflip.com/i/6pdgaz</a></figcaption></figure><p><strong><em>The pipeline is still there. But my place in it has moved.</em></strong></p><p>I used to be inside the “Development” box, hands on the keys. Now I’m standing over the whole thing — describing intent, steering the work, deciding what to trust, catching what’s wrong. <em>Less author, more director.</em></p><p>Some days that feels like a promotion. Some days it feels like a loss.<br>Most days, honestly, it feels like both.</p><p>And maybe that’s the real signal that software engineering has changed — the question has shifted from <em>“can I build this?”</em> to <em>“can I direct, and trust, something else to build it — and stay a good engineer while I do?”</em></p><p>I’m still figuring out the answer ….<br>I just no longer think the old lifecycle is going to give it to me.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*7t4EIqGkynz_Gx31" /><figcaption>Photo by <a href="https://unsplash.com/@kurniawann?utm_source=medium&amp;utm_medium=referral">Rifki Kurniawan</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=35c8d124f845" width="1" height="1" alt=""><hr><p><a href="https://blog.stackademic.com/adlc-vs-sdlc-the-moment-i-realized-software-engineering-had-changed-35c8d124f845">ADLC vs SDLC: The Moment I Realized Software Engineering Had Changed</a> was originally published in <a href="https://blog.stackademic.com/">Stackademic</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From Runtime to Build-Time: Injecting Environment Variables into Docker Builds]]></title>
            <link>https://blog.stackademic.com/from-runtime-to-build-time-injecting-environment-variables-into-docker-builds-000ab9577fcc?source=rss-6ade3e5de331------2</link>
            <guid isPermaLink="false">https://medium.com/p/000ab9577fcc</guid>
            <category><![CDATA[build]]></category>
            <category><![CDATA[build-time-variables]]></category>
            <category><![CDATA[docker-build]]></category>
            <category><![CDATA[dockerfiles]]></category>
            <dc:creator><![CDATA[Yashodha Samarawickrama]]></dc:creator>
            <pubDate>Tue, 05 May 2026 06:09:43 GMT</pubDate>
            <atom:updated>2026-06-01T06:40:08.910Z</atom:updated>
            <content:encoded><![CDATA[<p><strong>The Problem Nobody Talks About</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*M01QkSIFH-9YBwF9vv6MYw.png" /></figure><p>Most of us are comfortable with environment variables- at least at runtime. We spin up a container, inject a few values like API endpoints or database URLs, and everything works as expected.<br>But things start to get confusing when your application needs those same values <em>before it even runs</em>.</p><p>Think about modern applications — especially frontend builds or services that compile assets. During the build process, they often need environment-specific configuration:</p><ul><li>Where is the API hosted?</li><li>Which feature flags should be enabled?</li><li>Which environment am I building for?</li></ul><p>At this point, runtime variables don’t help anymore — because the container hasn’t even started yet. And this is where many developers quietly run into friction.</p><p>Instead of a clean solution, teams end up:</p><ul><li>Hardcoding values into the codebase</li><li>Maintaining separate builds for each environment</li><li>Writing custom scripts to inject values during CI/CD</li></ul><p>None of these approaches feel right — but they’re surprisingly common.</p><p>It’s a subtle gap in the workflow: <em>We treat configuration as something that happens at runtime, while ignoring that modern applications often need it </em>at build time too<em>.</em></p><p>And because this problem isn’t always obvious at first, it tends to show up later — when builds become harder to manage, less portable, and more fragile than they should be.</p><p><strong>Runtime vs Build-Time (The Subtle Difference That Breaks Things)</strong></p><p>At first glance, runtime and build-time configuration can feel like the same thing — just “environment variables in different places.” But in practice, they solve two very different problems.</p><p><strong>Runtime variables</strong> are available when your container starts. This is what most developers are used to:</p><ul><li>Inject a database URL</li><li>Set an API key</li><li>Configure service endpoints</li></ul><p>Everything happens <em>after</em> the image is built.</p><p><strong>Build-time variables </strong>on the other hand, exist much earlier — during the image creation itself. This is when your application is being compiled, bundled, or prepared for execution.</p><p>And that timing difference is where things quietly break.</p><p>Imagine a frontend application built with React or Angular. During the build step, it needs to know:</p><ul><li>What is the base API URL?</li><li>Which environment is this (dev, staging, prod)?</li><li>Should certain features be enabled or disabled?</li></ul><p>These values get baked directly into the generated files.</p><p>If you try to rely on runtime variables here, it’s already too late. The build has finished. The configuration is fixed.</p><p><strong>The Real Pain in Docker Workflows</strong></p><p>Docker promises consistency: <em>build once, run anywhere</em>. And in many cases, it delivers. But the moment your application needs environment-specific behavior during the build, that promise starts to crack.</p><p>In a typical workflow, you build a Docker image once and deploy it across environments. Clean, simple, predictable.</p><p>But then reality kicks in. Your app suddenly needs:</p><ul><li>A different API endpoint for staging vs production</li><li>Feature flags enabled only in certain environments</li><li>Build-time configuration for frontend assets</li></ul><p>Now a single “universal” image doesn’t quite work anymore.</p><p><strong>The Shift: Build-Time Environment Variables</strong></p><p>Once you clearly see the gap between runtime and build-time, the solution starts to feel almost obvious: <em>What if environment variables could be injected </em>during the build itself<em> — in a clean, first-class way?</em></p><p>This is the core idea behind build-time environment variables: <em>Give your application the configuration it needs </em>at the moment it’s being built<em>, not after it’s already packaged.</em></p><p>This shift simplifies a lot of the friction we saw earlier. You no longer need to:</p><ul><li>Maintain multiple Dockerfiles</li><li>Inject values through fragile CI/CD steps</li><li>Rebuild images just to fix configuration issues</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OOa6idjl1yTu4Pwz1ud2_w.png" /></figure><p><strong>A Simple Example</strong></p><p>Let’s make this concrete using the <a href="https://console.choreo.dev/">WSO2 Developer Platform</a>.</p><p>With the latest improvements, you can now define <strong>build-time environment variables</strong> directly within your component and have them injected during the Docker build — without modifying your Dockerfile for each environment.</p><p>Let’s start by creating a new project and a component.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4bVp8jHNMVVDzVKUGGtwaQ.png" /><figcaption>Step 1 — Create a new project</figcaption></figure><p>Now head over to the <a href="https://github.com/wso2/choreo-samples">samples repository</a> and fork it to your GitHub account.</p><p>Before creating the component, let’s update the Dockerfile to accept a build-time variable. We’ll introduce a simple variable called MESSAGE that will be passed during the build.</p><pre># Build-time variable<br>ARG MESSAGE<br>ENV MESSAGE=$MESSAGE<br># Use it during build (for visibility)<br>RUN echo &quot;Building with message: $MESSAGE&quot;</pre><p>Now, update the Go application to read the variable to print a dynamic message:</p><pre>message := os.Getenv(&quot;MESSAGE&quot;)<br>if message == &quot;&quot; {<br> message = &quot;Hello, World&quot;<br>}<br>fmt.Println(message)</pre><p>This ensures the value is available during the build process and also influences the application’s behavior at runtime.</p><p>Next, create a <strong>Manual Task</strong> component in the platform. This allows you to run Docker-based workloads on demand and is perfect for our example.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GUTRHRkkH15e96oyFZqwCA.png" /><figcaption>Step 2— Create a new component</figcaption></figure><p>Once the initial build completes, click Build Settings on the component build page. This opens a side panel where you can define your build-time environment variables.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uGaYUwDLM7k852z6gop2cg.png" /><figcaption>Step 3 — Add build-time env variables</figcaption></figure><p>After saving the build-time variables, trigger a new build so the updated configuration is applied during the Docker build process.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aUXvDW9brgcu-4UQ88g2TQ.png" /><figcaption>Step 4- Click on the Dockerbuild logs</figcaption></figure><p>The build has completed successfully 🎉 . <br>Now, let’s inspect the Docker build logs to verify that the build-time variable we provided was injected correctly during the build.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jmhkS7aV6COS4Bplz5CHgQ.png" /><figcaption>Step 5 - Check the build logs</figcaption></figure><p>And there it is. As shown in the Docker build logs, the build-time variable has been successfully injected during the image build:</p><blockquote>[1/2] STEP 11/12: RUN echo “Building with message: $MESSAGE”<br>Building with message: hello-from-build</blockquote><p>Next, navigate to the <strong>Execute</strong> page and trigger the <strong>Manual Task</strong> component we created earlier.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ac0k3jhsT57nTNjPPjsD-Q.png" /><figcaption>Step 6— Execute the created manual task</figcaption></figure><p>Once the task has been executed, navigate to the <strong>Runtime Logs</strong> page under <strong>Observability</strong> to verify the application output.<br>You should see the application reading the MESSAGE environment variable—or printing the default fallback value if no variable was provided.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gBOK4oUSVp0T_pw_N_bvXg.png" /><figcaption>Step 7 — Check the runtime logs</figcaption></figure><p><strong>Closing Thought</strong></p><p>Environment variables have always been a core part of application deployment — but as modern applications become more build-driven, runtime configuration alone is no longer enough.</p><p>By introducing build-time environment variable support in the <a href="https://console.choreo.dev/">WSO2 Developer Platform</a>, we’re making Docker-based workflows more flexible, predictable, and developer-friendly.</p><p>What once required custom scripts, multiple Dockerfiles, or environment-specific builds can now be handled directly within the platform — exactly where it belongs.</p><p>And honestly… <em>if you’ve ever spent two hours debugging a Docker build only to realize an environment variable was missing, you’re not alone..</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Onr-RP3WUm1zv7Tr" /><figcaption>Photo by <a href="https://unsplash.com/@vladimir_d?utm_source=medium&amp;utm_medium=referral">Volodymyr Dobrovolskyy</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=000ab9577fcc" width="1" height="1" alt=""><hr><p><a href="https://blog.stackademic.com/from-runtime-to-build-time-injecting-environment-variables-into-docker-builds-000ab9577fcc">From Runtime to Build-Time: Injecting Environment Variables into Docker Builds</a> was originally published in <a href="https://blog.stackademic.com/">Stackademic</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From Azure DevOps to Cloud with Choreo: 5 Steps]]></title>
            <link>https://medium.com/choreo-tech-blog/from-azure-devops-source-to-cloud-with-choreo-in-5-steps-087039ddef01?source=rss-6ade3e5de331------2</link>
            <guid isPermaLink="false">https://medium.com/p/087039ddef01</guid>
            <dc:creator><![CDATA[Yashodha Samarawickrama]]></dc:creator>
            <pubDate>Thu, 11 Dec 2025 10:32:28 GMT</pubDate>
            <atom:updated>2025-12-16T07:19:11.994Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DqhoJqT6j0DqXsV08aYK8Q.png" /></figure><h3>Introduction</h3><p>Azure DevOps is a robust platform for source code management, CI/CD pipelines, and project planning. In this article, we’ll show you how to <strong>connect your Azure DevOps repository to </strong><a href="https://choreo.dev/"><strong>Choreo</strong></a>, build a service from that repository, and deploy it to the cloud using automated workflows.</p><p>Whether you are onboarding an existing application or deploying a new service, this integration streamlines deployments directly from your Azure DevOps Git repository.</p><h3>Prerequisites</h3><p>Before you begin, make sure you have:</p><ol><li>A <a href="https://choreo.dev/"><strong>Choreo</strong></a> account</li><li>An <a href="https://dev.azure.com/"><strong>Azure DevOps</strong></a><strong> organization and project</strong></li><li>A <strong>repository in Azure DevOps</strong> containing your application source code</li></ol><p><strong>Step 1 — Generate a Personal Access Token (PAT) in Azure DevOps</strong></p><ul><li>Sign in to <strong>Azure DevOps</strong> (dev.azure.com).</li><li>In the top-right corner, next to your profile picture → <strong>User Settings</strong>.</li><li>Select <strong>Personal access tokens</strong> → <strong>New Token</strong>.</li><li>Give the token a name like <em>ChoreoAccessToken</em>.</li><li>Select <strong>Scopes</strong>: <strong>Code (Read)</strong>, <strong>Project (Read) and Team (Read)</strong></li><li>Set the expiration and create the token.</li><li>Copy the generated token and store it securely, as it cannot be viewed again.</li></ul><p><strong>Step 2 — Add Azure DevOps Credentials in Choreo</strong></p><ol><li>Log in to the <a href="https://choreo.dev/"><strong>Choreo</strong></a><strong> Console</strong>.</li><li>Open your organization from the sidebar.</li><li>Navigate to <strong>Settings → Credentials</strong>.</li><li>Click <strong>+ Add Credentials</strong>.</li><li>Fill in:</li></ol><ul><li><em>Credential Name</em>: e.g., AzureDevOpsCred</li><li><em>Service Provider</em>: <strong>Azure DevOps</strong></li><li><em>Access Token</em>: Paste the PAT generated earlier</li></ul><p>6. Click <strong>Save</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-1BKCvTmtS_3IHTjC8j6Ew.png" /></figure><p>You should now see your Azure DevOps credential listed in Choreo.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*z6nOZK50ZfHbWzklmpfGaw.png" /></figure><p><strong>Step 3 — Create a New Component Using Your Azure DevOps Repository</strong></p><ul><li>Navigate back to your Choreo Organization homepage.</li><li>Click <strong>+ Create Project</strong> and enter a project name.</li><li>Within the project, select <strong>a Component Type </strong>card.</li><li>Select ‘Try a Different Git Provider’ -&gt; Select ‘<strong>Authorize with</strong> <strong>Azure DevOps’</strong> and select the previously created credential.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/863/1*RUa9_tLZbJOtZJn34O3RfQ.png" /></figure><ul><li>Select: <em>Project, Repository and Branch</em></li><li>Enter the directory path</li><li>Choose the corresponding build preset</li><li>Click on Create and Deploy</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fhdju8yjiDZpZ1J5yV1APQ.png" /></figure><p><strong>Step 4 — Build the Component</strong></p><ul><li>When the component creation is successful, you will be redirected into the Component Overview page.</li><li>Navigate to the <strong>Build</strong> page from the left navigation menu.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zXVmwqt_XXrAgYPL9X32NA.png" /></figure><ul><li>Once you are in the Build page, Click on <strong>Build Latest (to build the latest commit) </strong>or select <strong>Show Commits -&gt; Select a commit from the commit list </strong>to start building your source code.</li><li>You will be able to see the status of the build once it is in-progress.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6UO2ipNJTuMyFtonII_V4Q.png" /></figure><p>Once the build is successful, navigate to the <strong>‘Deploy’</strong> page from the left menu.</p><p><strong>Step 5 — Deploy to Production</strong></p><ul><li>Click on ‘Configure &amp; Deploy’ in the Set Up card to deploy to your first environment.</li><li>To promote this service to the production environment, click <strong>‘Promote’</strong> and select the ‘<strong>Use Development configuration</strong>’ or <strong>‘Add New Configurations’</strong> option from the right drawer.</li></ul><p>Your source code should now be in production!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3Wgi4XfKqXQygrg37Sl7yQ.png" /></figure><p>To test the application, navigate to the <strong>Test</strong> -&gt; <strong>Console </strong>page from the left menu.</p><p><strong>Summary</strong></p><p>This article explains how to take your code from Azure DevOps to the cloud using Choreo. It covers generating a PAT, adding Azure DevOps credentials in Choreo, creating a component from your repo, building the service, and deploying it to production — all in a streamlined, automated workflow.</p><p><a href="https://choreo.dev/?utm_source=me&amp;utm_medium=orgpost&amp;utm_campaign=me_orgpost_gitlab_240812">Sign up to Choreo </a>for free to explore more cool features.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=087039ddef01" width="1" height="1" alt=""><hr><p><a href="https://medium.com/choreo-tech-blog/from-azure-devops-source-to-cloud-with-choreo-in-5-steps-087039ddef01">From Azure DevOps to Cloud with Choreo: 5 Steps</a> was originally published in <a href="https://medium.com/choreo-tech-blog">Choreo Tech Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Day ‘sh’ Became ‘dash’: Debugging a Sneaky CI/CD Failure]]></title>
            <link>https://blog.stackademic.com/the-day-sh-became-dash-debugging-a-sneaky-ci-cd-failure-fece3a8688e9?source=rss-6ade3e5de331------2</link>
            <guid isPermaLink="false">https://medium.com/p/fece3a8688e9</guid>
            <dc:creator><![CDATA[Yashodha Samarawickrama]]></dc:creator>
            <pubDate>Wed, 10 Dec 2025 13:52:00 GMT</pubDate>
            <atom:updated>2026-01-31T07:37:50.000Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nk-yVDNtWo0B-kj2JyrPCA.png" /></figure><p>There are days in engineering when the universe gently reminds you<br>that your assumptions are far more fragile than your code.</p><p>For me, that day started with a feature deadline, a customer waiting, and a Poya holiday I definitely wasn’t supposed to spend debugging.<br>But there I was — <strong>16 hours deep</strong>, chasing a failure that made absolutely no sense. With an ETA of “tomorrow” hanging over my head, I had no luxury to say, “Let’s look at this on Monday.”</p><p><strong>A bit of context:</strong></p><p><a href="https://choreo.dev/">Choreo</a> already supported GitHub, Bitbucket, and GitLab Server as Git providers for users to deploy their source code from. <br>My task was to extend this support to another provider — Azure DevOps. It sounded straightforward. Or so I thought.</p><p>To support multiple Git providers in our build workflows, we rely on separate shell scripts — each one written to handle the specific API and authentication patterns of its provider.<br>These scripts take arguments (like token, repo, ref, etc.), construct the correct Git URL, and perform a fetch before the rest of the pipeline runs.</p><p>The new script I wrote followed the exact same pattern used for the other providers.</p><p>The logic was sound. The inputs were correct.<br>But the moment the workflow ran, something felt off — the pipeline kept failing right at the checkout step.<em> </em>The error said:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Uj4TSHS-OC6Gh2KBBHEVfQ.png" /></figure><p>At first glance, it looked like the script wasn’t receiving the arguments, so just like any dev would do, I printed the arguments inside the pipeline logs, and I saw — <strong>with 100% certainty</strong> — that the correct values <em>were</em> being passed into the script.</p><p>So now the suspects were:<br>the new script, the CI/CD layer, or the Git provider itself.</p><p>But then I noticed something subtle when I scrolled a little up in the error log :</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/220/1*vTh2Q1i3BBwJux4NX_68kA.png" /></figure><p>Why was the shell complaining about <strong>basic things</strong> like [[ ]] and -z? <br>These are the most ordinary checks in every Bash script I’ve ever seen or written.</p><p>And then it hit me: <strong>“Wait… why doesn’t the shell understand them?”</strong></p><p>I assumed the script was running in Bash — just like every other time.<br>So Azure wasn’t to blame. The script wasn’t to blame.<br>The real culprit was hiding underneath: <strong>the shell executing it</strong>.</p><p>That’s where the real story begins.</p><p>Up until this point, all our Git provider checkout scripts had been happily running under <strong>sh </strong>without complaints.<br>But then I remembered something we had recently done:<br>our build environment image had been upgraded to Ubuntu 24.04.<br>A harmless update, right?</p><p>Except… hidden inside that upgrade was one tiny, crucial change::</p><p><strong>sh → now points to dash</strong></p><p>That’s it. <br>One invisible symlink switch.</p><p>One tiny difference that only matters if your scripts rely on <strong>Bash features</strong> like:</p><ul><li>-z used with Bash conditionals</li><li>pattern matching inside [[ ]]</li><li>extended argument parsing behavior</li></ul><p>For years, our scripts worked fine because <strong>sh</strong> used to point to <strong>Bash</strong> in our previous images.<br>So even though our scripts <em>looked</em> like POSIX-sh scripts, they were actually being executed by Bash.</p><p>But in Ubuntu 24.04, sh now points to <strong>dash</strong> — a much stricter, minimal shell that doesn’t understand any of those Bashisms.</p><p>So what happened?</p><p>Since Ubuntu 24.04, sh invokes dash, all the Bash-specific parts in our scripts quietly crumbled.</p><p>Variables weren’t being assigned.</p><p>Conditionals failed silently.</p><p>Arguments didn’t parse.</p><p>Which is how we ended up with checkout commands missing values entirely, like this:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Uj4TSHS-OC6Gh2KBBHEVfQ.png" /></figure><p><strong>And the fix? </strong>So simple it almost hurt.</p><p><strong>Change</strong>: sh source-checkout.sh<br><strong>To</strong>: bash source-checkout.sh</p><p>As soon as the script ran under Bash — the environment it was written for — everything worked perfectly with a clean fetch and checkout!</p><p>This debugging story wasn’t really about debugging a failing build pipeline. It was about something deeper we often forget:</p><p><strong>Software breaks at the boundaries we don’t pay attention to.</strong></p><p>One tiny environmental shift — a shell change, a symlink, a silent update — can redefine the rules you thought you were coding against.</p><p>And that’s the beauty — and chaos — of software engineering!</p><p>I’ll <em>never</em> forget to check what sh is pointing to again.</p><p>And hopefully — if you’re reading this — now you won’t either.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XSysPJDCyPvrrV3cRMiadA.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fece3a8688e9" width="1" height="1" alt=""><hr><p><a href="https://blog.stackademic.com/the-day-sh-became-dash-debugging-a-sneaky-ci-cd-failure-fece3a8688e9">The Day ‘sh’ Became ‘dash’: Debugging a Sneaky CI/CD Failure</a> was originally published in <a href="https://blog.stackademic.com/">Stackademic</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Deploying Code from Bitbucket Cloud to Production with Choreo]]></title>
            <link>https://medium.com/choreo-tech-blog/deploying-code-from-bitbucket-cloud-to-production-with-choreo-319887a80fab?source=rss-6ade3e5de331------2</link>
            <guid isPermaLink="false">https://medium.com/p/319887a80fab</guid>
            <dc:creator><![CDATA[Yashodha Samarawickrama]]></dc:creator>
            <pubDate>Tue, 26 Nov 2024 10:40:48 GMT</pubDate>
            <atom:updated>2024-11-28T05:59:36.340Z</atom:updated>
            <content:encoded><![CDATA[<p>Bitbucket stands out as one of the most popular Git providers, embraced by both enterprise organizations and individual developers alike. Choreo enhances this experience by allowing you to effortlessly connect your source repository. With Choreo, you can streamline your deployment process, ensuring that your code moves smoothly from development to production. This integration not only simplifies workflows but also accelerates the delivery of applications, empowering teams to bring their projects to life efficiently.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/433/0*_qCv4F1tXUQjyCHo" /></figure><p>In this article, we will walk you through how we can effectively use <a href="https://choreo.dev/">Choreo</a> to deploy a service written using Flask. We will be using <a href="https://github.com/wso2/choreo-samples/tree/main/python-flask-app">this sample</a> designed to showcase a restaurant reservation system. This API offers users the ability to effectively manage restaurant reservations. It supports various operations like creating, retrieving, updating, and deleting reservation entries.</p><h3>Pre requisites</h3><ol><li>A <a href="https://choreo.dev/">Choreo</a> user account</li><li>A <a href="https://bitbucket.org/">Bitbucket</a> account</li><li>Import this <a href="https://github.com/wso2/choreo-samples">repository</a> to create a new repository in your Bitbucket Workspace.</li></ol><p>Let’s get started with connecting your source code in Bitbucket to Choreo.</p><p><strong>Step 1 — Create a common credential in Choreo</strong></p><p><strong>1. </strong>Login to your Bitbucket account and navigate to <strong>Personal Bitbucket Settings</strong> under the <strong>User Settings </strong>section. From the left menu , select <strong>App passwords </strong>in the Access Management section. Click on <strong>Create App password </strong>and provide the following information.</p><p><strong>Label — </strong>Choreo console<br><strong>Scopes</strong> — <br> Account (Read), <br> Pull requests (Read/Write), <br> Repositories (Read/Write), <br> Webhooks (Read/Write)</p><p>Copy the generated app password and save it securely as you won’t be able to access it again.</p><p>2. Login to <a href="https://choreo.dev/">Choreo</a>.</p><p>From the left menu of the Organization home page navigate to <strong>Settings</strong> and then in the ‘Credentials’ tab, click on <strong>+ Add Git Credentials</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*bQ2NrCSydmcxV-B2" /></figure><p>Provide the following information to create a new credential and click on save.</p><p><strong>Credential Name</strong> — BitbucketCredentials<br><strong> Service Provider — </strong>Bitbucket<br><strong>Username </strong>— Username of your Bitbucket Account<br><strong>Access Token — </strong>Copy paste the app password generated earlier</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/531/0*uqdMPE5aVCAmZkS4" /></figure><p>The credential you created should be listed under the common credential tab as shown below.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*bEuunEv-ZCh_6TcO" /></figure><p><strong>Step 2 — Create a component</strong></p><p>From the Organization home page click the <strong>+ Create Project</strong> button to create a new project with the name <strong>‘Reservation Management’</strong>. <br>Once the project is successfully created, navigate to the ‘<strong>Reservation Management’</strong> project.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/521/0*wBP11hc7KV8Z_jRt" /></figure><p>Create a Service by providing the following information :<br><strong>Component Name — </strong>ReservationService<br><strong>Source Provider </strong>— Navigate to the Bitbucket tab<br><strong>Authorize with Bitbucket</strong> — Select the credential you created earlier</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*8r5ao6stMVpNGKZ1" /></figure><p><strong>User group — </strong>Select the workspace you created the repository under<br><strong>Repository — </strong>Select ‘choreo-samples’ or the repository name you provided<br><strong>Branch — </strong>Main<br><strong>Buildpack — </strong>Docker<br><strong>Docker Context — </strong>/python-flask-app<br><strong>Dockerfile — </strong>/python-flask-app/Dockerfile</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*EUSuGV5Vuu-fYZVN" /></figure><p><strong>Step 3 — Build an image</strong></p><p>Once the component is created, you will be directed to the <strong>Build</strong> page, where the initial build for the latest commit in your repository will be in progress.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Xt_H-aUpCbdotEk0" /></figure><p>Once the build is successful, click on the <strong>‘Deploy’ </strong>link to navigate to the Deploy page.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Or8SvTlDvtisTA_M" /></figure><p><strong>Step 4 — Deploy to production</strong></p><p>Click on ‘Configure &amp; Deploy’ in the Set Up card.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*N4fpIW5fflmCGApC" /></figure><p>The service we just created is now ready to be deployed to the development environment.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*6-jafkXO92ARAWiQ" /></figure><p>To promote this service to the production environment, click <strong>‘Promote’</strong> and select the ‘<strong>Use Development configuration</strong>’ option from the right drawer.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*JOsUYhJJ5qskC5pj" /></figure><p><strong>Step 5 — Test the service</strong></p><p>Once the service is successfully promoted to production, navigate to the <strong>Test</strong> -&gt; <strong>Console </strong>page from the left menu.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*gsnXwkJszKcqkexl" /></figure><p>Click on the <strong>POST</strong> request and enter the following schema to test the service we created.</p><p>{</p><p>“contact”: “011–123–1111”,</p><p>“reservationCreator”: “John Doe”,</p><p>“reservationId”: “1111”</p><p>}</p><p>Click on execute to add this new entry to the reservation management system and check if the response is successful.</p><p>Then, click on <strong>GET</strong> to send a request to retrieve the list of reservations and verify if the new reservation we just added is available.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*0QvXvOJZqSbmG7Vp" /></figure><p>You have successfully created a service and deployed it to production!</p><p><strong>Summary</strong></p><p>In this article, we demonstrated how to deploy a Python-based service for managing a list of reservations using Choreo. The API allows users to create, retrieve, update, and delete reservation entries. The process began with creating a new project in a Bitbucket workspace and connecting it to Choreo by creating a service component. We then built an image from the latest commit , deployed it to the development environment and promoted it to production to make it live. Finally, we tested the service to ensure everything was working as expected. Sign up to <a href="https://choreo.dev/">Choreo</a> for free to explore these features and unlock more possibilities!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=319887a80fab" width="1" height="1" alt=""><hr><p><a href="https://medium.com/choreo-tech-blog/deploying-code-from-bitbucket-cloud-to-production-with-choreo-319887a80fab">Deploying Code from Bitbucket Cloud to Production with Choreo</a> was originally published in <a href="https://medium.com/choreo-tech-blog">Choreo Tech Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Seamlessly Connecting Your Self-Managed GitLab Repository to Choreo]]></title>
            <link>https://medium.com/choreo-tech-blog/seamlessly-connecting-your-self-managed-gitlab-repository-to-choreo-94c8661d5442?source=rss-6ade3e5de331------2</link>
            <guid isPermaLink="false">https://medium.com/p/94c8661d5442</guid>
            <dc:creator><![CDATA[Yashodha Samarawickrama]]></dc:creator>
            <pubDate>Wed, 31 Jul 2024 13:49:56 GMT</pubDate>
            <atom:updated>2024-08-12T11:48:38.394Z</atom:updated>
            <content:encoded><![CDATA[<p>GitLab is a widely used version control system, similar to GitHub, known for its robust features and extensive community. Recognizing GitLab’s growing popularity, <a href="https://choreo.dev/?utm_source=me&amp;utm_medium=orgpost&amp;utm_campaign=me_orgpost_gitlab_240812">Choreo</a> has expanded its integration capabilities to include GitLab, alongside its existing support for GitHub, Bitbucket Cloud, and Bitbucket Server. This new integration enables users to seamlessly connect their self-managed GitLab repositories with Choreo for streamlined production deployments.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/810/0*-tq8xCZgN4mZnLs4" /></figure><p>In this article, we will walk you through how we can use the power of <a href="https://choreo.dev/?utm_source=me&amp;utm_medium=orgpost&amp;utm_campaign=me_orgpost_gitlab_240812">Choreo</a> to deploy a Service written using the Go programming language that manages a list of reading items. For this, we will be using the sample ‘<a href="https://github.com/wso2/choreo-samples/tree/main/go-reading-list-rest-api">go-reading-list-rest-api</a>’. This API allows users to manage a reading list, including creating, retrieving, updating, and deleting book entries.</p><h3>Pre requisites</h3><ol><li>A <a href="https://choreo.dev/?utm_source=me&amp;utm_medium=orgpost&amp;utm_campaign=me_orgpost_gitlab_240812">Choreo</a> User Account</li><li>A GitLab Self-Managed Server</li><li>Import this <a href="https://github.com/wso2/choreo-samples">repository</a> to create a new project in your server.</li></ol><p><strong>Step 1 — Create a common credential in Choreo</strong></p><p>1. Login to your GitLab Server and navigate to <strong>Edit profile</strong> under the <strong>User Settings </strong>section. From the left menu , select <strong>Access Tokens </strong>and click on <strong>Add new token. </strong><br>Provide the following information to generate a PAT token and click on <strong>Create Personal Token</strong>.</p><p><strong>Token name — </strong>Choreo console PAT<br> <strong>Expiration</strong> — Remove expiration date<br> <strong>Scopes</strong> — Select ‘API’ scope</p><p>Copy the generated PAT and save it securely as you won’t be able to access it again.</p><p>2. Login to <a href="https://choreo.dev/?utm_source=me&amp;utm_medium=orgpost&amp;utm_campaign=me_orgpost_gitlab_240812">Choreo</a>.</p><p>From the left menu of the Organization home page navigate to <strong>Settings</strong> and then in the ‘Credentials’ tab, click on <strong>+ Add new credential</strong>. <br>Provide the following information to create a new credential and click on save.</p><p><strong>Credential Name</strong> — GitLabServerCredentials<br><strong> Service Provider — </strong>GitLab<br><strong>Source</strong> — GitLab Self-Managed<strong> </strong>(selected by default)<br><strong>Server URL </strong>— URL of your GitLab Server<br><strong>Access Token — </strong>Copy paste the PAT generated earlier</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*NWLl9j4su66zd2QY" /></figure><p>The credential you created should be listed under the common credential tab as shown below.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*PFYeGEgwKgyxvrZ7" /></figure><p><strong>Step 2 — Create a component</strong></p><p>From the Organization home page , create a new project with the name ‘Reading List’ by clicking the <strong>+ Create Project</strong> button.Once the project is successfully created, navigate to the ‘<strong>Reading List’</strong> project.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*MQhWZMYpQNp43dKl" /></figure><p>Create a Service by providing the following information :<br><br><strong>Component Name — </strong>ReadingListService<br><strong>Source Provider </strong>— Navigate to the ‘GitLab’ tab<br><strong>Authorize with GitLab</strong> — Select the credential you created earlier</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Q75Gc4bnxiuKy0AE" /></figure><p><strong>User group — </strong>Select the user group you created the project under<br><strong>Project — </strong>Select ‘choreo-samples-new’ or the project name you provided<br><strong>Branch — </strong>Main<br><strong>Buildpack — </strong>Go<br><strong>Go Project Directory </strong>— go-reading-list-rest-api<br><strong>Language Version </strong>— 1.x</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*bgZXo3nb58LaKIvP" /></figure><p><strong>Step 3 — Build an image</strong></p><p>Once the component is created, navigate to the <strong>‘Build’</strong> page from the left menu. Click on ‘Build latest’ to build the component from the latest commit.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*pxjBO6uE4lttpJna" /></figure><p><strong>Step 4 — Deploy to production</strong></p><p>Once the build is successful, navigate to the <strong>‘Deploy’</strong> page from the left menu. Click on ‘Configure &amp; Deploy’ in the Set Up card.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*_VfLEt5DDItxETgH" /></figure><p>Our service is now ready to be deployed to the development environment.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*UBPOU_EmCZA8WvpQ" /></figure><p>To promote this service to the production environment, click <strong>‘Promote’</strong> and select the ‘<strong>Use Development configuration</strong>’ option from the right drawer.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*nEPR_WsqhSc2v0c2" /></figure><p><strong>Step 5 — Test the service</strong></p><p>Once the service is successfully promoted to production, navigate to the <strong>Test</strong> -&gt; <strong>Console </strong>page from the left menu.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*JrQehoAeuIKY9KSI" /></figure><p>Click on the POST request and enter the following schema to test the service we created.</p><pre>{<br>&quot;author&quot;: &quot;J.K. Rowling&quot;,<br>&quot;id&quot;: &quot;fe2594d0-ccea-42a2–97ac-0487458b5611&quot;,<br>&quot;status&quot;: &quot;to_read&quot;,<br>&quot;title&quot;: &quot;Harry Potter and the Chamber of Secrets&quot;<br>}</pre><p>Click on execute to add this new entry to the reading list and check if the response is 200.</p><p>Then, click on GET to send a request to retrieve the reading list and verify if the new entry we just added is available.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ozGHaDrnSn0ehM9o" /></figure><p><strong>Summary</strong></p><p>In this article, we demonstrated how to leverage Choreo to deploy a service written in Go, which manages a list of reading items. This API enables users to create, retrieve, update, and delete book entries. We created a new project on our GitLab server, connected it to Choreo by creating a service, built an image from the latest commit, deployed it to the development environment, and then promoted it to production. Finally, we tested the service. <a href="https://choreo.dev/?utm_source=me&amp;utm_medium=orgpost&amp;utm_campaign=me_orgpost_gitlab_240812">Sign up to Choreo </a>for free to explore more features.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=94c8661d5442" width="1" height="1" alt=""><hr><p><a href="https://medium.com/choreo-tech-blog/seamlessly-connecting-your-self-managed-gitlab-repository-to-choreo-94c8661d5442">Seamlessly Connecting Your Self-Managed GitLab Repository to Choreo</a> was originally published in <a href="https://medium.com/choreo-tech-blog">Choreo Tech Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Deploying React Apps with Choreo and Managed Databases]]></title>
            <link>https://medium.com/choreo-tech-blog/deploying-react-apps-with-choreo-and-managed-databases-c1b85eb0872a?source=rss-6ade3e5de331------2</link>
            <guid isPermaLink="false">https://medium.com/p/c1b85eb0872a</guid>
            <category><![CDATA[react-deployment]]></category>
            <category><![CDATA[react]]></category>
            <category><![CDATA[database]]></category>
            <category><![CDATA[deployment]]></category>
            <category><![CDATA[reactjs]]></category>
            <dc:creator><![CDATA[Yashodha Samarawickrama]]></dc:creator>
            <pubDate>Thu, 06 Jun 2024 10:56:05 GMT</pubDate>
            <atom:updated>2024-06-06T10:56:05.847Z</atom:updated>
            <content:encoded><![CDATA[<p>In today’s rapidly evolving digital landscape, creating a scalable, efficient, and responsive web application is a fundamental requirement for businesses and developers alike. Every developer dreams of an easy process to build a robust application and take their code to production smoothly.</p><p>In this article , we will walk you through how we can use the power of <a href="https://choreo.dev/?utm_source=me&amp;utm_medium=Medium&amp;utm_campaign=me_Medium_managed_databases_blog_240606">Choreo</a> to deploy a React application and connect it effortlessly to a managed database.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/463/1*7mvGaPDUhXSol1-EkQtNhg.png" /></figure><p>We will be using the example project ‘<a href="https://github.com/wso2con2024/choreo-tutorial">CareConnect: Medical Appointment Booking System</a>’ a medical appointment booking system designed to make scheduling healthcare visits easy. It features a user-friendly web interface for patients and a backend that manages appointments. CareConnect uses the Backend for Frontend (BFF) pattern to ensure smooth communication between the frontend web application and the backend services. The system is divided into two main parts: the Web Portal, which handles user interactions and provides a responsive interface for managing appointments, and the Appointment Management backend, which coordinates appointment scheduling and database operations.</p><p>Let us now explore how we can use the features in Choreo to deploy this application and connect a database seamlessly.</p><h3>Pre requisites</h3><ol><li>A <a href="https://console.choreo.dev/?utm_source=me&amp;utm_medium=Medium&amp;utm_campaign=me_Medium_managed_databases_blog_240606">Choreo</a> user account.</li><li>Fork and clone this<a href="https://github.com/wso2con2024/choreo-tutorial"> repository</a> to your local machine.</li></ol><p>Now let’s create our application and deploy it in Choreo.</p><h4><strong>Step 1 — Create a Database</strong></h4><p>From the left menu of the <strong>Organization</strong> home page select Dependencies → Databases and provide the following information.</p><p><strong>Storage type</strong> — My SQL<br><strong>Service Name</strong> — appointmentsdb<br><strong>Select Cloud Provider</strong> — Digital Ocean<br><strong>Select Region</strong> — United States<br><strong>Select Service Plan</strong> — Hobbyist</p><p>and then click ‘<strong>Create’</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*emQthH0t1nIhv8c_" /></figure><h4><strong>Step 2 — Create Components</strong></h4><p>From the Organization home page , create two projects ‘Web Portal’ and ‘Appointment Management’ by clicking the <strong>+ Create Project</strong> button.</p><p>Then navigate to the <strong>‘Appointment Management’ </strong>project.</p><h4><strong>Step 2.1 — Appointment Service</strong></h4><p>Create a Service by providing the following information :</p><p><strong>Component Name — </strong>Appointment Service<br><strong>Authorize with GitHub and Connect Your Repository -</strong>&lt;YOUR_FORKED_REPO&gt;<br><strong>Branch — </strong>Main<br><strong>Buildpack — </strong>NodeJS<br><strong>Project Directory — </strong>/appointment-management/appointment-service<br><strong>Language Version — </strong>20.x.x</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*K5CEnRREfB9Gx6bh" /></figure><p>Once the component is created, navigate to the ‘<strong>Build</strong>’ page from the left menu. Click on <strong>‘Build latest’ </strong>to build the component from the latest commit.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*2I9OMXguYD36nqiQ" /></figure><p>Once the build is successful , navigate to the ‘<strong>Deploy</strong>’ page from the left menu. Click on ‘<strong>Configure &amp; Deploy</strong>’ in the Set Up card.</p><p>Add the following key-value pairs in the <strong>Environment Configurations’ </strong>section.</p><p><strong>DB_HOST : </strong>&lt;your_db_host&gt;<strong><br>DB_PORT : </strong>&lt;your_db_port&gt;<strong><br>DB_NAME : </strong>&lt;your_db_name&gt;<strong><br>DB_USER : </strong>&lt;your_db_user&gt;<strong><br>DB_PASSWORD : </strong>&lt;your_db_password&gt;</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/282/1*m1wvrqwMz6PtIFDXnuolGA.png" /></figure><p>Navigate to Organization → Dependencies → Databases → appointmentdb to find the corresponding values from the database we created earlier. Complete the wizard and click ‘<strong>Deploy</strong>’.</p><p>To promote your app to the production environment, click ‘<strong>Promote’ </strong>and select the ‘<strong>Use Development configuration</strong>’ option from the right drawer. This will use the same configurations that were provided to the development environment.</p><h4><strong>Step 2.2 — Web Portal Backend</strong></h4><p>Let’s now create another component with the backend of the WebPortal . Navigate to the <strong>‘Web Portal</strong>’ project from the organization home and create a component for the Backend for Frontend(BFF) service by providing the following details :</p><p><strong>Component Name</strong> — BFF<br><strong>Authorize with GitHub and Connect Your Repository</strong> — &lt;YOUR_FORKED_REPO&gt;<br><strong>Branch — </strong>Main<br><strong>Buildpack</strong> — NodeJS<br><strong>Project Directory</strong> — /web-portal/backend<br><strong>Language Version</strong>- 20.x.x</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*v4ENKC6QgawmYVkr" /></figure><p>We will now create a connection to the appointment service. Navigate to the newly created component then go to Dependencies → Connections from the left menu and click ‘<strong>Create’</strong>. Select ‘Appoinment Service’.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*PJ6rP4Yx8GHZHSyP" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*YVxWyx0PTJWNRhpD" /></figure><p>Provide a name for the connection and click ‘<strong>Create</strong>’. Once the connection is created, copy and paste the connection configuration snippet into the <strong>component-config</strong> file to integrate the connection into our application.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*urqw3uchejEKVijH" /></figure><p>Now, open the cloned repository in your preferred IDE and add the connection configuration snippet to the &lt;YOUR_REPO&gt;/web-portal/backend/.choreo/<strong>component-config.yaml</strong> file and push the changes to the remote repository. Once the connection config is added to the config.yaml file, the changed file will look like this :</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*JpEB-EiVt2eLiF7B" /></figure><p>Once the changes are pushed, navigate to the <strong>Build </strong>page inside the component and build the latest commit.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*3PJf05bSW1Ih_GJV" /></figure><p>Once the build is successful, navigate to the <strong>Deploy </strong>page and select <strong>‘Configure and Deploy’</strong>. Once the deployment to the dev environment is completed, promote it to the production environment.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*0tDMkYlkbHEFtK8e" /></figure><h4><strong>Step 2.3 — Web Portal Frontend</strong></h4><p>Let’s now create a component for the Web Portal Frontend. Navigate to the ‘Web Portal’ project and create a ‘Web Application’ component by providing the following details :</p><p><strong>Component Name</strong> — Webportal Frontend<br><strong>Authorize with GitHub &amp; Connect Your Repository — </strong>&lt;YOUR_FORKED_REPO&gt;<br><strong>Branch</strong> — Main <br><strong>Buildpack</strong>- React<br><strong>Project Directory</strong> — /web-portal/frontend<br><strong>Build Command</strong> — npm run build<br><strong>Build Path</strong> — /build<br><strong>Node Version</strong> — 20</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*t42kMuC1TqAcZLZCcmqG0g.png" /></figure><p>Navigate to the newly created component then go to Dependencies → Connections from the left menu and click ‘<strong>Create’</strong>. Select the service ‘BFF’.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*5bJ_-W1dKU8vu5C1" /></figure><p>Once the connection is created, copy the code snippet under the ‘<strong>Add Connection Configuration</strong>’ section. This config will be required during deployment as this application uses <a href="https://wso2.com/library/blogs/choreos-managed-authentication-for-single-page-web-applications/">Choreo-managed authentication</a> to authenticate the backend.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*XFZDx8Iy-BltcJ65" /></figure><p>Navigate to the <strong>Build </strong>page and build the latest commit.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*pe5ABWqgt6oQBM2f" /></figure><p>Once the build is successful, navigate to the <strong>Deploy </strong>page and select the ‘<strong>Configure &amp; Deploy</strong>’ option. In the wizard , add the copied configuration as shown below and deploy the component.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/238/1*kg0LAuIS4vz9hCRNNvkRcA.png" /></figure><h4><strong>Step 3 — Configuring Choreo Built-in Identity Provider</strong></h4><p>For the last step, let’s configure the Choreo IDP. For this, navigate to the ‘Application Security’ section of the Organization settings page.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*o6zIaba6ejWmKboz" /></figure><p>Click on ‘<strong>Manage</strong>’. Under the ‘Manage IDP’ section , for the development environment, select the &lt;YOUR_FORKED_REPO&gt;/web-portal/frontend/<strong>userstore.csv </strong>file to create a user store and click on Upload.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*uRjstDOaumGneeDh" /></figure><p>Once the user store is created, usernames and groups will be visible under the Users section that you could use when trying out the application.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*5Rnj1l6bEBTNXdD9" /></figure><p>Navigate back to the Deploy page of the Webportal Frontend component and click on the WebApp URL to try out the application. Enter the following credentials to login to the portal : <br>Username — john<br>Password — user@1234</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*6f8qeTTX3lLlJOM0" /></figure><p>We have successfully deployed an application in Choreo with just a few clicks.</p><p>Visit <a href="https://choreo.dev/?utm_source=me&amp;utm_medium=Medium&amp;utm_campaign=me_Medium_managed_databases_blog_240606">Choreo</a> to explore everything you need to build apps on the cloud.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c1b85eb0872a" width="1" height="1" alt=""><hr><p><a href="https://medium.com/choreo-tech-blog/deploying-react-apps-with-choreo-and-managed-databases-c1b85eb0872a">Deploying React Apps with Choreo and Managed Databases</a> was originally published in <a href="https://medium.com/choreo-tech-blog">Choreo Tech Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>