<?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 Christoph C. Richter on Medium]]></title>
        <description><![CDATA[Stories by Christoph C. Richter on Medium]]></description>
        <link>https://medium.com/@christoph.c.richter?source=rss-583f6a231693------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*FO5piJV4-Tb8X_A7OVu2-g.jpeg</url>
            <title>Stories by Christoph C. Richter on Medium</title>
            <link>https://medium.com/@christoph.c.richter?source=rss-583f6a231693------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 20:01:03 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@christoph.c.richter/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[Environment variables: Unlock the full potential of Kubernetes by storing configuration in the…]]></title>
            <link>https://medium.com/humanitec-developers/environment-variables-unlock-the-full-potential-of-kubernetes-by-storing-configuration-in-the-795b0a1fc30?source=rss-583f6a231693------2</link>
            <guid isPermaLink="false">https://medium.com/p/795b0a1fc30</guid>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[ci-cd-pipeline]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[Christoph C. Richter]]></dc:creator>
            <pubDate>Mon, 08 Jun 2020 07:34:08 GMT</pubDate>
            <atom:updated>2020-06-08T08:12:36.260Z</atom:updated>
            <content:encoded><![CDATA[<h3>Environment variables: Unlock the full potential of Kubernetes by storing configuration in the environment</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*sReuDnpEWI8indY5.png" /></figure><h3>The promise of the public cloud</h3><p>Public cloud infrastructure comes with a big promise: to stop worrying about hardware infrastructure and rely on the infinite ad-hoc scalability of shared public resources. Gone are the days when developers needed to wait for sysadmins to configure or purchase new servers and to configure them so that they could run their applications. Public cloud providers like AWS, GCP, and Azure remove this constraint and offer almost unlimited scalability whenever needed.</p><p>This not only allows teams to cope with events like Black Friday but also enables them to spin up new environments whenever needed; e.g., to validate a super important hotfix that needs to go to production asap or to test functionality in a feature branch. As of today, this can all be done without blocking shared environments like dev and staging for the rest of the team.</p><h3>Current situation: Many teams are stuck with dev and staging</h3><p>Are teams prepared to leverage the potential of flexible scaling when it comes to the ad-hoc creation of environments? We talked to about 500 developer teams in Europe and the US over the last 12 months and we found a significant number of teams that are not. The main reason for this is environment-specific configs that are built into the code. We saw two different kinds of implementations.</p><p>The most problematic approach that we observed is to build different containers for each environment, with all the environment-specific config hardcoded into a specific container. First of all, this approach violates the integrity of any testing setup. For example, tests that have been performed on the container for the staging environments do not prove that the container for production is also working as expected. The test would need to be repeated for the production version; a step that is too often skipped since it adds additional complexity and takes time. Secondly, any new additional environment would require a new container with the specific environment-specific config built into it. None of the teams we talked to went through this effort. Instead, they limited themselves to 2 to 3 environments and struggled with blocked or broken environments in many situations.</p><p>Another approach we saw is to hardwire the environment-specific configuration in one large config file and switch configurations with environment variables. While this approach ensures the integrity of tests along the entire process, it also limits the number of environments to the ones that are listed in the configuration file. Spinning up new environments requires changes to the overall config file which — in practice — leads to the same result as in the approach mentioned above: teams limit themselves to a finite number of environments.</p><p>Looking at it from a theoretical point of view, this is known to be a problem for a while already. The manifesto of The Twelve Factor App ( <a href="https://12factor.net/">https://12factor.net/</a>) — that many developers have at least heard of — states this problem in factor <a href="https://12factor.net/config">III. Config</a>.</p><h3>Environment variables: A simple solution</h3><p>The solution to unlock the full potential of ad-hoc environments is straightforward: all environment-specific configs need to be externalized, e.g. through <strong>environment variables</strong>. This externalized configuration can easily be manipulated whenever a new environment is needed.</p><p>Wikipedia provides a good overview article about <a href="https://en.wikipedia.org/wiki/Environment_variable">environment variables</a>. Environment variables are part of the environment a specific process is running in. They can be referenced in the code and are defined on the environment level. A typical example is the definition of a logging level that defines how much information is written to standard output. The level is typically defined in the specific environments of the application with more logging in development and staging environments and less logging in production environments. Environment variables can also be used to point to specific resources (e.g., databases, DNS) that differ across environments.</p><p>When following the approach of externalizing all environment-specific configs, creating a new environment ad-hoc is very simple: just define the required <strong>environment variables</strong> and spin everything up.</p><p>We are following this approach for some time and enjoy the flexibility it brings (e.g., when working with feature branches). It is also useful for us to see how much more efficiently teams work that onboarded to Humanitec with externalized environment specific configs. Our Continuous Delivery-as-a-Service solution enables these teams to create and spin up new environments in Kubernetes with the click of a button. These teams leverage the full potential of scalable public cloud infrastructure for the one thing that really matters: a better developer experience.</p><h3>Summary: Why environment variables matter</h3><p>Environment variables help you keep important configuration external from your application code. This is an important step to take if your team uses or wants to use container-based applications, or continuous delivery as effectively as possible. If you’re using continuous delivery with containers, environments for developing, testing, staging, and production are in constant flux, and this separation keeps your team and application flexible.</p><p>If you’re interested in finding out how to use environment variables with Kubernetes, read our <a href="https://humanitec.com/blog/handling-environment-variables-with-kubernetes">hands-on guide</a>, or find out how Humanitec can simplify managing environment variables for you.</p><p><em>Originally published at </em><a href="https://humanitec.com/blog/environment-configs-kubernetes"><em>https://humanitec.com</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=795b0a1fc30" width="1" height="1" alt=""><hr><p><a href="https://medium.com/humanitec-developers/environment-variables-unlock-the-full-potential-of-kubernetes-by-storing-configuration-in-the-795b0a1fc30">Environment variables: Unlock the full potential of Kubernetes by storing configuration in the…</a> was originally published in <a href="https://medium.com/humanitec-developers">Humanitec</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Setting up service-oriented teams in a microservice environment]]></title>
            <link>https://medium.com/humanitec-developers/setting-up-service-oriented-teams-in-a-microservice-environment-16e59dd8fd83?source=rss-583f6a231693------2</link>
            <guid isPermaLink="false">https://medium.com/p/16e59dd8fd83</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[management]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[team]]></category>
            <category><![CDATA[microservices]]></category>
            <dc:creator><![CDATA[Christoph C. Richter]]></dc:creator>
            <pubDate>Tue, 29 Jan 2019 14:48:42 GMT</pubDate>
            <atom:updated>2019-01-29T14:49:11.982Z</atom:updated>
            <content:encoded><![CDATA[<h3>What we do at Humanitec</h3><p>Even in 2019, the development of customized enterprise applications is a highly individual process. In most cases, either the IT department itself or — even more common especially in Germany — an external software development agency is building a one-off solution to satisfy individual business requirements. This process is vastly redundant and both, costly and resource-intensive. As corporates step into the next level of digitization, demand is growing by 42% CAGR¹ and we are at least 500k short in engineers by 2020 on a global scale². After years of experience as a consultant at McKinsey and as a former Senior Vice President at XING, I am happy to fully dive into this opportunity as CPO of Humanitec. Our vision can be summarized by the 5–5–5 foresight: In 5 years, 5 computer science students will be able to build a fully fledged ERP enterprise-grade in 5 weeks. Exactly, how the business wants and needs it.</p><p>Wondering how are we going to achieve this? Our approach is a combination of a revolutionary new IP model that allows developers to reuse and monetize microservices on our marketplace, Core-APIs that auto-detect and fuse these services, and deployment automation to mount them to an infrastructure. From thought to app in seconds.</p><p>Our deployment platform Walhall is using a scalable open-source microservice architecture and state-of-the-art automated deployment processes to make customized enterprise software development much faster, more reliable, and easier to maintain while keeping the intellectual property where it should be, with the developer and the customer.</p><h3>How product management evolved at Humanitec</h3><p>Humanitec started off in a camp in Afghanistan, where our CTO Greg Lind hacked together a project management software for NGOs, called TolaData. TolaData’s open source version is rolled out in 35+ countries and has a paid solution on our platform. This microservice-based software helps NGOs to keep track of their initiatives and — even more important — the results for each of them. We built this software using a standard approach to modern software development: a dedicated developer team and 2-week sprints in a standard SCRUM approach.</p><p>From this 1st software product, we expanded into a second use case, field-force management software for a German corporation. While the two use cases seem to be quite different, they are using a very similar set of microservices in the backend. Like many other software companies, we started to reuse our existing microservices from the project management use case and modified them for the CRM use case. We ended up with two teams both working in 2-week sprints. Right from the beginning, we used the same core service in our backend setup and established frequent knowledge exchange sessions. But still, code reuse was nowhere close to where it could be and we struggled to align the two teams on a day-to-day basis.</p><p>The shared set of backend services and the inefficiencies in reusing our own microservices were the starting point to invest into a platform that would significantly increase reuse and could help to significantly speed up development time by providing automated deployment and a central approach to code management for individual microservices. By now, we are close to providing this platform, namely Walhall, to other software development teams in a closed beta.</p><h3>The challenge</h3><p>We truly believe in the strategy to “eat your own dog food”, i.e., we are in the process of moving our existing software products to Walhall and the respective standardized microservices. By doing so we needed to fundamentally re-think our approach to product development and team setup. We used to work in a very common setup, with dedicated teams for each of our products (i.e., project management, field-force management, and the platform). Each team had its own set of meetings and tools, from the backlog all the way to sprint reviews and post-mortems. I quickly realized that this approach has a number of significant drawbacks:</p><ul><li><strong>Alignment issues </strong>— aligning three teams working on a very similar set of microservices is a real challenge. Over and over again, individual developers were not well informed about what the other teams were doing and we developed very similar functionality in different places (mostly driven by high pressure to implement new features for our direct customers). Also, people started to feel isolated working in any of the individual teams. Sure, there are methods to tackle this challenge (e.g., SCRUM of SCRUMs) but they tend to further increase complexity and are not designed for relatively small organizations like ours (currently, we are about 50 developers in two offices).</li><li><strong>Individual experts </strong>— with resources spread across three individual teams, we started to see a growing number of individual experts for certain topics: individual backend developers with deep expertise for certain microservices, individual frontend developers with deep expertise on specific architectural questions, individual backend developers with deep expertise on the deployment process, etc. This is quite dangerous especially in a small company by introducing a significant risk in the case of any of these individual experts leaving the team and by leading to mediocre solutions due to the lack of ideas/concepts being discussed/sparred.</li><li><strong>Narrow product solutions</strong> — this is a typical problem in individual software development: the tendency to develop solutions that fit the needs of just one customer. We are facing the same issue and it is a real problem for us since we want to develop a platform that can support a wide range of use cases and must not think too narrow.</li><li><strong>Lack of overview</strong> — from a product management point of view, another significant drawback became quickly visible: the difficulty for any individual product manager to get a quick overview of topics in development/research. We organized each team in a separate JIRA project with an individual backlog and individual sprints. Being aware of each topic across all three projects was almost impossible. Especially, with the many other day-to-day topics in each individual team.</li></ul><h3>Humanitec’s solution</h3><p>There are a lot of interesting and partly well-tested concepts out there how to set up and manage a service-oriented development organization. The most interesting are matrix organizations and setups with tribes and squads. Unfortunately, we are lacking two important elements to easily implement solutions like that: (a) scale and (b) a large enough number of experienced senior tech leads. It will take us a while to develop these two elements but I am sure we will get there.</p><p>Meanwhile, we are in the process of implementing our own solution to a service-oriented approach that we believe will overcome the challenges mentioned earlier:</p><ul><li><strong>Stable frontend teams for individual UIs </strong>— we will continue to have dedicated stable frontend teams to develop individual UIs. Those UIs are composed of a set of frontend microservices and some customization based on the specific needs of the customer.</li><li><strong>Stable team for core modules </strong>— we will continue to have a dedicated stable team to develop the core elements of our platform, namely the core backend module (BiFrost) and the core frontend module (Midgard). This team also defines a lot of the standards that we are using throughout the platform. It combines frontend and backend engineers with QA engineers and a technical writer.</li><li><strong>Virtual service teams</strong> — we are introducing virtual service teams. These teams are composed out of one frontend engineer from one of the frontend teams (and a backup), one frontend engineer from the team for core modules, one backend engineer (and a backup), one QA engineer, and a product manager. Each of these teams is responsible for one logic module.</li></ul><p>Especially the virtual service teams are very important for us. Combining engineers from the team developing the core modules with engineers that work on customer-specific UIs and making these teams responsible for generic microservices offers a lot of advantages: (1) it brings the frontend engineers working for any individual UI much closer to the platform, (2) it ensures that the product manager and the teams need to consider much broader use cases when developing a new feature, and (3) it significantly increases the re-use of designs across different teams.</p><p>Furthermore, we implemented some other changes to become more agile (e.g., one-week sprints) and allow for more focus on the most important topics. We try to keep complexity to a minimum. 1st results from this new structure are already looking very promising and we are eager to learn more over the next weeks and months to come. Please do not hesitate to reach out to me (<a href="/service/mailto:christoph.richter@humanitec.com">christoph.richter@humanitec.com</a>) in case of any questions or recommendations and stay tuned.</p><p>1) <a href="https://blog.7mileadvisors.com/dissecting-the-custom-software-market-161b4208c1ec">https://blog.7mileadvisors.com/dissecting-the-custom-software-market-161b4208c1ec</a> and <a href="https://www2.deloitte.com/content/dam/insights/us/articles/3767_Signals-for-Strategists_Feb2017/DUP_Software-development-beyond-IT.pdf">https://www2.deloitte.com/content/dam/insights/us/articles/3767_Signals-for-Strategists_Feb2017/DUP_Software-development-beyond-IT.pdf</a><br>2) <a href="https://www2.deloitte.com/content/dam/insights/us/articles/3767_Signals-for-Strategists_Feb2017/DUP_Software-development-beyond-IT.pdf">https://www2.deloitte.com/content/dam/insights/us/articles/3767_Signals-for-Strategists_Feb2017/DUP_Software-development-beyond-IT.pdf</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=16e59dd8fd83" width="1" height="1" alt=""><hr><p><a href="https://medium.com/humanitec-developers/setting-up-service-oriented-teams-in-a-microservice-environment-16e59dd8fd83">Setting up service-oriented teams in a microservice environment</a> was originally published in <a href="https://medium.com/humanitec-developers">Humanitec</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>