<?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 Andreas Leicher on Medium]]></title>
        <description><![CDATA[Stories by Andreas Leicher on Medium]]></description>
        <link>https://medium.com/@aleicher?source=rss-b26d6e4fa84e------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*fYQz7vThHW5nPLrglr-Gsg.jpeg</url>
            <title>Stories by Andreas Leicher on Medium</title>
            <link>https://medium.com/@aleicher?source=rss-b26d6e4fa84e------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 07:03:40 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@aleicher/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[AI-Assisted Coding: The Tip of the Iceberg in Software Development]]></title>
            <link>https://medium.com/kotaicode/ai-assisted-coding-the-tip-of-the-iceberg-in-software-development-13948d12a0d3?source=rss-b26d6e4fa84e------2</link>
            <guid isPermaLink="false">https://medium.com/p/13948d12a0d3</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[startup]]></category>
            <category><![CDATA[enterprise-technology]]></category>
            <dc:creator><![CDATA[Andreas Leicher]]></dc:creator>
            <pubDate>Wed, 24 Sep 2025 06:46:25 GMT</pubDate>
            <atom:updated>2025-09-24T06:47:50.136Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*WCjXUBDTrIKz9t01" /><figcaption>The iceberg of software development: the visible tip (functional app) is supported by a massive, hidden base of work beneath the surface. Photo by <a href="https://unsplash.com/@jagilo?utm_source=medium&amp;utm_medium=referral">Javier Gil</a> on <a href="https://unsplash.com?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>Introduction: The Illusion of Simplicity</h3><p>Everywhere you look, headlines and LinkedIn posts boast how <strong>AI has made software development fast, simple, and cheap.</strong> There’s some truth to the hype — AI coding assistants can dramatically accelerate the creation of a <strong>Minimum Viable Product (MVP)</strong>. For example, tools like GitHub Copilot or GPT-4 can generate code on the fly, relieving developers from writing boilerplate and helping non-coders <a href="https://devops.com/why-ai-based-code-generation-falls-short/">prototype ideas quickly</a>. There are real <a href="https://sakkyb.medium.com/how-i-built-a-saas-product-with-100-ai-generated-code-5728e0c97c8d">stories of entrepreneurs building fully functional SaaS products</a> in days or weeks using AI, even with little prior coding experience. This ease and speed are <strong>enticing business decision-makers</strong>, who see an opportunity to validate ideas at a fraction of the usual cost and time.</p><p>Yet, this apparent simplicity is <strong>the tip of the iceberg</strong>. Seasoned engineers know that a working app or feature is only the visible part of a much larger body of work. <em>“What looks like clean and elegant code rests upon an iceberg of setup, config, boilerplate code, error handling, knowledge, testing and hard-won experience,”</em> as <a href="https://medium.com/@tsecretdeveloper/the-tip-of-the-software-developer-iceberg-9c29fa91aa57">one developer put it</a>. In other words, an MVP built by AI might look done — it may even solve the core problem — but it leaves <strong>vast complexities hidden below the surface</strong>. Rushing into production with an AI-generated prototype can be like steering a ship toward an iceberg: the unseen bulk can wreak havoc if you’re not prepared. This essay provides a reality check on the AI development boom, explaining why the initial 30% of work that AI delivers is great for quick validation, but the remaining 70% of the effort (the “iceberg” below the waterline) is where projects truly succeed or fail.</p><h3>The Visible Tip: Rapid MVPs with AI Are Game-Changers</h3><p>There’s a reason AI-assisted development has everyone excited. On the <strong>surface level</strong>, AI coding tools offer tangible benefits for speed and cost-efficiency in building software:</p><ul><li><strong>Accelerated Development:</strong> AI can generate code in moments, compressing what might be weeks of manual work into hours. Optimists claim that with these tools, <a href="https://research.aimultiple.com/vibe-coding/"><em>“one month’s worth of work can be done in one day”</em>.</a> While that may be an extreme case, there’s no doubt that prototyping is much faster. Teams can iterate rapidly, trying out features without spending big budgets upfront. This is ideal for an MVP, where getting a working app to market quickly to test an idea is often more valuable than perfecting every detail.</li><li><strong>Lower Barrier to Entry:</strong> Non-developers or less experienced coders can create basic applications with the help of AI. For instance, a product designer with no prior coding experience built an <a href="https://sakkyb.medium.com/how-i-built-a-saas-product-with-100-ai-generated-code-5728e0c97c8d">entire B2B web app in two weeks using AI pair-programming assistants.</a> Such examples show how AI can <strong>democratize software prototyping</strong> — a founder with a vision can have AI write the initial code, skipping the need to immediately hire a full development team. The result is a functional prototype that <em>looks and feels</em> like a real product, achieved with minimal cost.</li><li><strong>Feature Completeness (at a glance):</strong> Modern AI coding agents can generate front-end interfaces, backend logic, database schemas, and even connect APIs when given good prompts. One panel of experts noted you can build <em>“</em><a href="https://honeycombsoft.com/expert-insight/building-a-2-day-mvp-insights-tools-and-strategies/"><em>surprisingly advanced applications, even 60–70% of a full product,</em></a><em>”</em> with skilled use of AI tools. In other words, <strong>AI can deliver the core feature set</strong> and polish of an app to a point that impresses stakeholders. The user interface might be slick, basic functionalities work, and the product demo convinces people that the idea is viable. To a business decision-maker, it may appear that the software is nearly complete — and indeed, the visible tip <em>is</em> there, functioning and user-facing.</li></ul><p>These advantages make AI coding extremely valuable in the <strong>MVP stage</strong>. It’s now feasible to <strong>validate market demand</strong> or secure investor buy-in with a prototype built at a fraction of the traditional cost. As Paul Graham famously advised startups to <em>“do things that don’t scale”</em> early on, using AI to hack together an MVP is the 2025 version of that adage — do it quick and dirty to prove your concept. <strong>However, once that concept is proven, the real work begins.</strong> The closer you look at those AI-generated MVPs, the more cracks and unfinished business you start to see beneath the glossy surface.</p><h3>The Hidden Depths: Challenges in Scaling AI-Generated Code</h3><p>If an MVP is the tip of the iceberg, then the <strong>enterprise-ready, scalable product</strong> is the enormous mass below water. Transitioning from the former to the latter reveals the many facets of software engineering that <em>AI alone cannot handle</em>. Here are the key areas where hidden complexity lurks:</p><ol><li><strong>Software Architecture and Technical Debt:</strong></li></ol><p>AI code generators don’t architect systems — they solve prompts. An MVP built by prompting an AI to “build X feature” tends to be very <em>ad hoc</em>. It lacks the coherent design that comes from a human architect planning modules, data flow, error handling, and maintainability from day one. As a result, the prototype may work in isolation but falls apart when extended. Developers find that the AI introduced duplicate code and clunky workarounds rather than adhering to a clean design. <em>“Many AI-powered tools can generate source code for you, but they seldom consider the design and architecture of your application or how components are related,”</em> notes a <a href="https://devops.com/why-ai-based-code-generation-falls-short/#:~:text=Although%20many%20AI,are%20related%20to%20one%20another">DevOps.com analysis</a>. This often leads to significant <strong>technical debt</strong> — messy code that might function now but will cause problems to fix later. In fact, AI seldom refactors code; it may not realize that a piece of logic it wrote in Module A is similar to something in Module B that could be abstracted. Human developers must eventually go in and <strong>restructure or rewrite</strong> chunks of the AI-written code to create a robust, scalable architecture. It’s not unusual that <em>after</em> proving the concept with an AI-assisted MVP, teams decide to <strong>“</strong><a href="https://reeaglobal.com/when-do-you-scrap-the-mvp-and-rewrite-the-platform/"><strong>scrap the MVP and rewrite the platform</strong></a><strong>”</strong> properly once they hit a certain scale or complexity. The first 90% of functionality might have come easy, but as the old programming joke goes, <em>“the remaining 10% of the code accounts for the other 90% of the development time.”</em> In enterprise software, <strong>the polish and architecture often take far more effort</strong> than the initial feature coding.</p><p><strong>2. Quality, Debugging, and Maintainability:</strong></p><p>AI-generated code is not magically bug-free or maintainable. It often <em>only</em> guarantees that the code syntactically works for the given example — not that it’s the best approach or even logically correct in all cases. As the volume of AI-written code grows, engineers frequently encounter strange bugs or edge cases that weren’t considered. <strong>Debugging AI code can be surprisingly challenging</strong>, because you (the human) didn’t write it and might not immediately understand its logic. One developer quipped on an online forum, <em>“</em><a href="https://www.reddit.com/r/ChatGPTCoding/comments/1h4epwm/ai_is_great_for_mvps_trash_once_things_get_complex/#:~:text=%E2%80%A2%20%209mo%20ago"><em>The problem with AI is that it allows you to produce code faster than you’re capable of understanding and maintaining it.</em></a><em>”</em> When you let the AI do too much, <em>“you end up feeling like you’re poking around in someone else’s project trying to understand how things fit together,”</em> the commenter added. This resonates with many who have tried large codebase generation — it’s fast, but <strong>the comprehension lags behind</strong>. Empirical evidence backs this up: in a <a href="https://www.turintech.ai/blog/the-hidden-cost-of-ai-generated-code-what-research-and-industry-trends-are-revealing">recent survey</a>, <strong>67% of developers reported spending more time debugging AI-generated code</strong>, and <strong>68% noted increased time fixing security issues</strong> in AI-written code. In theory, AI can also produce unit tests or help with debugging, but in practice it might fix one issue while introducing another if not guided carefully. Ultimately, human developers must invest substantial effort in <strong>code reviews, refactoring, and testing</strong> AI outputs. The MVP that <em>“looked done”</em> at first pass may require sweeping clean-ups to be maintainable by a team long-term. This hidden work isn’t visible in the demo, but it’s essential to prevent accumulating maintenance headaches.</p><p><strong>3. Scalability and Performance:</strong></p><p>The quick solution that works for 5 or 50 users can fall apart under 5,000. AI doesn’t inherently plan for scalability — it’s not figuring out how to distribute load across servers, how to partition a database, or how to optimize a critical algorithm for performance. If you prompted an AI to build a chat app, it might pick a simple polling mechanism or a single-threaded server because that suffices for an example. In production with high usage, such choices can become bottlenecks. Thus, to go from <strong>MVP to a product that handles real-world load</strong>, engineers must evaluate and often overhaul what the AI built. One expert panel emphasized <strong>reviewing an AI-built MVP before scaling</strong>, to check what was <em>“assumed or skipped in the early phase”</em>. Common tasks at this stage include: restructuring the code to remove hard-coded limits, upgrading the infrastructure (e.g. moving from a SQLite file to a distributed database), adding caching, and redesigning modules to run in parallel or in the cloud. Perhaps the AI was never asked to optimize for speed, so the initial code might be inefficient. All these improvements can consume considerable time and budget. As a tech blog noted, <em>“code generated using AI-powered tools will have defects and constraints, thereby requiring human intervention to refine the generated code and make it error-free and usable.”</em> In short, <strong>AI might get you a prototype architecture in days, but scaling that architecture to production-grade often means redoing or enhancing much of it</strong>, which is the bulk of the iceberg below.</p><p><strong>4. Security and Compliance:</strong></p><p>This is a big one for enterprise readiness. An AI doesn’t naturally understand your company’s security policies, regulatory compliance requirements (like GDPR, HIPAA), or industry best practices unless you specifically prompt for each aspect — and even then, it may not get everything right. An MVP is typically focused on proving a concept, so it might use <em>development shortcuts</em> that are unacceptable in a real product. For example, the AI might hard-code an API key or skip input validation or use an insecure authentication method just to get it working. We’ve seen instances where an AI, told to integrate a database, left default credentials or didn’t encrypt sensitive data — issues a junior programmer might also overlook. Once you decide to go to production, <strong>all these gaps must be addressed</strong>. That means implementing proper user authentication, error handling, encryption, compliance checks, etc., often largely by human effort. A panel of AI developers noted that quick MVP builds often <strong>forget about security</strong> — <em>“you might accidentally leave API keys in your code, skip authentication, or expose your database”</em> in the rush. It takes a thorough audit and additional development to bring security up to par. Moreover, enterprise buyers will require compliance certifications, threat modeling, and rigorous testing that AI is not equipped to perform on its own. If AI wrote a chunk of code, you have to ask: did it introduce a vulnerability? In many cases, the answer is yes — security researchers have found that <strong>AI-generated code can be insecure and must be corrected by humans</strong>. It’s telling that 68% of developers (from the survey above) had to spend extra time on security fixes for AI code. In highly regulated sectors (finance, healthcare, etc.), you might end up rewriting the AI’s code entirely to meet compliance, which again is part of the “invisible” effort below the waterline.</p><p><strong>5. Integration and Infrastructure:</strong></p><p>An MVP usually operates in a vacuum or a simplified environment: e.g., a demo app running on a single cloud instance with a local database. Real-world software needs to integrate with a host of other systems and follow robust deployment practices. <strong>Enterprise integration</strong> — connecting your new AI-generated app with legacy systems, third-party services, or proprietary APIs — can be extremely complex. AI might help generate some adapter code, but understanding the nuances of a 20-year-old ERP system or a bespoke API is often beyond what a general AI model can do. Human engineers must step in to write glue code, transform data between formats, and handle errors gracefully across system boundaries. Similarly, setting up a proper cloud infrastructure (with load balancers, CDNs, container orchestration, etc.) is not something today’s code generators handle. One case study pointed out that some AI-coded apps <em>“hit a ceiling”</em> because <em>“their infrastructure lacks security and flexibility”</em> or they <em>“can’t handle high traffic”</em> without significant re-engineering. Deployment pipelines (CI/CD), monitoring, and failover mechanisms all need to be built — often from scratch — when turning an MVP into a production service. These tasks might not produce any visible change in the application’s features, but they are absolutely essential for an enterprise-ready product. <strong>Ignoring them is not an option</strong>: it’s like ignoring the iceberg beneath the water; you do so at your peril.</p><p>In short, AI can rapidly produce the <em>skeleton</em> of an application, but <strong>fleshing it out with muscle, nerves, and skin is mostly a human endeavor</strong>. As one AI research firm summarized, <em>“while AI can accelerate code production, it often introduces new inefficiencies in validation, security, and maintainability”</em>. Instead of eliminating work, it <strong>shifts the work</strong> into later stages: what you save in initial coding you pay for in extended testing, reviews, and re-architecture. It’s not that AI-written code is useless — far from it. It gives us a huge head start. But <strong>the head start can be misleading</strong> if interpreted as the finish line.</p><h3>From Prototype to Production: Navigating the Iceberg</h3><p>Given the above, how should business leaders approach AI-assisted development? The key is to <strong>leverage AI for what it does best (speed and creativity in the early stages)</strong> while <strong>planning for the follow-through</strong> needed to make software truly production-grade. Here are some recommendations and realities to consider:</p><ul><li><strong>Treat the MVP as Disposable (Plan for Rewrite):</strong> It may sound counterintuitive, but one should <em>design for change</em>. Many experienced founders and engineers will build an MVP fully expecting to <strong>throw it away</strong> later once it has served its purpose. The MVP’s job is to test assumptions and get user feedback — it’s <strong>not</strong> to be a perfect foundation. If the MVP (possibly built with heavy AI assistance) proves the concept, don’t be afraid when your development team says a rewrite or major refactor is needed for the next phase. This isn’t wasted work; it’s the natural progression from figuring out <em>what to build</em> to building it <em>right</em>. By setting this expectation upfront, you avoid the sunk cost fallacy of clinging to brittle AI-generated code. One best practice is to <strong>prototype quickly and cheaply with AI</strong>, but allocate the majority of the project budget for hardening and scaling after initial validation. It might be 30% of effort to get the first demo, and 70% to finish the product — that ratio is normal.</li><li><strong>Involve Experienced Engineers Early:</strong> Even if AI is doing the coding, have a senior developer or architect oversee the process. Their guidance can prevent some AI missteps (for example, they might spot that the AI’s suggested architecture won’t scale and adjust the approach). Skilled developers can also set up a proper framework and ask the AI to fill in the blanks, rather than letting the AI set the structure. Think of it as a human architect drawing the blueprint, and using AI as a very fast junior developer to draft pieces of it. This way, <strong>you combine AI’s speed with human foresight</strong>. As one article put it, <em>“use a combination of AI-generated and human-written code in your projects… blend AI-powered tools with manual effort and intelligence to build high quality applications faster”</em>. The human expertise ensures the iceberg under the water is solid, not just the shiny tip.</li><li><strong>Enforce Standards and Best Practices:</strong> If you do incorporate AI-generated modules, subject them to the same rigor you would human code. That means static analysis, code review, style enforcement, and writing additional tests. Many AI coding tools allow you to prompt for certain standards (e.g. “follow OWASP security guidelines” or “use our internal API style for this”). Use those features. Also, modern development workflows can integrate AI in CI pipelines — for instance, having AI suggest optimizations or catch obvious bugs — but always with a human in the loop to validate. <strong>Don’t blindly trust</strong> that AI code is production-ready. Make sure it passes all your organization’s quality gates. If it doesn’t, refactor it until it does.</li><li><strong>Focus on the “Below the Surface” Requirements:</strong> As a decision-maker, ask your team not just <em>“does it work?”</em> but also <em>“is it built to last?”</em> Encourage documentation of what the AI-built MVP lacks — maybe it has no logging, or minimal security, or it won’t scale past one server. Identifying these gaps is crucial. Create a <strong>checklist of enterprise requirements</strong> (security, compliance, scalability, maintainability, etc.) and evaluate the AI-generated product against it. This is essentially shining a light under the water to see how big the iceberg is. In many cases, teams discover that <strong>AI’s output introduces vulnerabilities or inefficiencies that require extensive human intervention to fix</strong>. Knowing that, you can prioritize those fixes. Maybe compliance and security are a must before any public launch, whereas some performance tuning can wait until you have more users — context will dictate the order. But nothing on that checklist should be ignored indefinitely.</li><li><strong>Leverage AI in Later Stages, Carefully:</strong> Just because the heavy lifting in later stages is mostly human, don’t ignore AI entirely after MVP. AI can still assist in tasks like <strong>code optimization, writing unit tests, or generating migration scripts</strong>. In fact, some emerging tools focus on <em>AI-based code optimization and validation</em> — essentially using AI to review or improve the output of other AI-generated code. For example, an AI could scan the code for security flaws or suggest performance improvements (there are research efforts into this). This is a promising area: using AI <em>with guardrails</em> to handle parts of the below-the-surface work. However, these tools are in their infancy. For now, <strong>the safest course is AI augmentation coupled with human review</strong>. The goal is to let AI speed things up without letting it drive unsupervised. As a pithy summary: <em>AI can </em><strong><em>assist</em></strong><em> you in building software, but it’s not a </em><strong><em>replacement</em></strong><em> for understanding software engineering.</em> Your team’s expertise remains the cornerstone.</li></ul><h3>Conclusion: Seeing the Whole Iceberg</h3><p>AI-assisted development is a powerful new tool in the software industry. It offers a tantalizing vision of building products faster and cheaper — and indeed, it delivers on that promise for the early stages of development. Business leaders would be wise to take advantage of these capabilities to <strong>get innovations to market quickly</strong> and outpace competitors in the prototype phase. <strong>However, wisdom is also knowing the limitations.</strong> An MVP generated by AI is not a final product; it’s an experiment, a starting point. The true effort lies in everything that comes next: making that software reliable, secure, scalable, and maintainable. These qualities require planning, craftsmanship, and often significant additional coding beyond what the AI initially produced.</p><p>Ignoring the submerged part of the iceberg can lead to nasty surprises — projects that stall, budgets that balloon unexpectedly, or systems that fail at the worst time. By contrast, acknowledging the hidden work from the outset leads to better decisions: you’ll allocate resources for proper engineering, set realistic timelines, and avoid the trap of thinking <em>“the app is basically done, the AI built it!”</em> when in reality, you might be only one-third done. As the evidence has shown, <strong>AI often shifts work rather than removing it</strong> — you trade writing boilerplate code for debugging and fortifying the code. The net productivity gain is real, but not as dramatic as the hype might suggest once you account for the full development lifecycle.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*BneX8_ISWD0iVT3s" /><figcaption>Photo by <a href="https://unsplash.com/@shaahshahidh?utm_source=medium&amp;utm_medium=referral">Shaah Shahidh</a> on <a href="https://unsplash.com?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>In nautical terms, using AI in development is like deploying a powerful speedboat to scout ahead and chart a quick path through the waters of innovation. You’ll reach the visible goals faster. Just remember that you’re still captaining an ocean liner of a project, and when that speedboat flags an iceberg ahead, you must still do the hard work of navigation to avoid it or break it down. <strong>AI will accelerate your journey, but you must still mind the icebergs.</strong> The winners in this new era will be those who embrace the acceleration <strong>and</strong> invest in the unseen but critical work that truly completes a software product. In the end, a balanced approach — leveraging AI’s speed with human judgment and expertise — will yield the best results: software that not only <em>arrives</em> quickly, but also <em>stays afloat</em> and succeeds in the long run.</p><p>Reading about AI is inspiring — but planning an actual implementation requires clarity. Our <a href="https://aistimate.kotaicode.solutions/">AI Estimator</a> bridges that gap by giving you tailored guidance on cost and feasibility for your AI project. Take the survey today, and get the insights you need to start your AI journey with confidence.</p><h4><strong>References:</strong></h4><ol><li>DevOps.com — <em>“Why AI-based Code Generation Falls Short” — </em><a href="https://devops.com/why-ai-based-code-generation-falls-short/#:~:text=Although%20many%20AI,are%20related%20to%20one%20another">devops.com</a><a href="https://devops.com/why-ai-based-code-generation-falls-short/#:~:text=While%20it%20is%20excellent%20at,then%20test%20the%20code%20thoroughly">devops.com</a></li><li>Reddit (r/ChatGPTCoding) — Discussion <em>“AI is great for MVPs, trash once things get complex”</em>, user comment on code understanding — <a href="https://www.reddit.com/r/ChatGPTCoding/comments/1h4epwm/ai_is_great_for_mvps_trash_once_things_get_complex/#:~:text=%E2%80%A2%20%209mo%20ago">reddit.com</a></li><li>AIMultiple — <em>“Vibe coding: Great for MVP But Not Ready for Production”</em>, noting that scaling AI-written code <em>“requires an experienced developer”. — </em><a href="https://research.aimultiple.com/vibe-coding/#:~:text=Is%20AI,use">research.aimultiple.com</a></li><li>The Secret Developer (Medium) — <em>“The Tip of the Software Developer Iceberg”</em>, on hidden complexity in clean code — <a href="https://medium.com/@tsecretdeveloper/the-tip-of-the-software-developer-iceberg-9c29fa91aa57#:~:text=What%20looks%20like%20clean%20and,won%20experience">medium.com</a></li><li>TurinTech AI — <em>“The Hidden Cost of AI-Generated Code”</em>, reporting industry research on debugging and security overheads — <a href="https://www.turintech.ai/blog/the-hidden-cost-of-ai-generated-code-what-research-and-industry-trends-are-revealing#:~:text=More%20Code%2C%20More%20Review%20%E2%80%93,equate%20to%20faster%20software%20delivery">turintech.ai</a><a href="https://www.turintech.ai/blog/the-hidden-cost-of-ai-generated-code-what-research-and-industry-trends-are-revealing#:~:text=,coding%20increases%20the%20number%20of">turintech.ai</a></li><li>Honeycomb Software — <em>“Building a 2-day MVP with AI… What’s required to go from MVP to scale?”</em>, listing post-MVP tasks (refactor, security, architecture shifts) — <a href="https://honeycombsoft.com/expert-insight/building-a-2-day-mvp-insights-tools-and-strategies/#:~:text=Here%27s%20what%20often%20needs%20to,happen%20next">honeycombsoft.com</a><a href="https://honeycombsoft.com/expert-insight/building-a-2-day-mvp-insights-tools-and-strategies/#:~:text=generate%20APIs%2C%20and%20handle%20logic">honeycombsoft.com</a></li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=13948d12a0d3" width="1" height="1" alt=""><hr><p><a href="https://medium.com/kotaicode/ai-assisted-coding-the-tip-of-the-iceberg-in-software-development-13948d12a0d3">AI-Assisted Coding: The Tip of the Iceberg in Software Development</a> was originally published in <a href="https://medium.com/kotaicode">kotaicode</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Structured Context for AI: Building an Enterprise-Grade Model Context Protocol (MCP) Server]]></title>
            <link>https://medium.com/kotaicode/structured-context-for-ai-building-an-enterprise-grade-model-context-protocol-mcp-server-f92c20ee784f?source=rss-b26d6e4fa84e------2</link>
            <guid isPermaLink="false">https://medium.com/p/f92c20ee784f</guid>
            <category><![CDATA[mcp-server]]></category>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[Andreas Leicher]]></dc:creator>
            <pubDate>Fri, 15 Aug 2025 17:02:41 GMT</pubDate>
            <atom:updated>2025-08-15T17:02:41.843Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*OPqaZcEvVqjMNXHP" /><figcaption>Photo by <a href="https://unsplash.com/@lukejonesdesign?utm_source=medium&amp;utm_medium=referral">Luke Jones</a> on <a href="https://unsplash.com?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>As AI adoption accelerates across industries, one architectural challenge becomes clear:</p><p>🧠 <strong>LLMs are stateless by default.</strong><br>They don’t retain memory across sessions, struggle to access structured external data, and can’t reason reliably across multiple systems without careful orchestration.</p><p>To truly embed AI in enterprise workflows — with traceability, modularity, and control — we need more than good prompts.<br>We need a protocol.</p><h3>💡 Introducing the Model Context Protocol (MCP)</h3><p>The <strong>Model Context Protocol</strong> is an open standard for delivering <strong>structured, versioned, and inspectable context</strong> to AI models.</p><p>Rather than shoving ad-hoc data into a prompt string, MCP treats context as first-class, modular data assets. These <strong>resources</strong> (like users://42/profile) can be:</p><ul><li><strong>Static documents</strong> (reference data, templates)</li><li><strong>Dynamic documents</strong> (fetched via APIs or databases)</li><li><strong>Linked as a graph</strong> of context</li><li><strong>Served to any compliant LLM or agent</strong></li></ul><p>MCP enables AI systems to reason like structured applications — not one-off text blobs.</p><h3>🧩 Why MCP Matters for Enterprise AI</h3><p>In a business context, this shift is transformative.</p><p>Where prompts are brittle, MCP is:</p><ul><li>🔍 <strong>Auditable</strong> — Every piece of context is logged, versioned, and referencable.</li><li>⚙️ <strong>Composable</strong> — Reuse profiles, settings, policies across use cases.</li><li>🔐 <strong>Secure</strong> — Serve scoped context to different apps or agents.</li><li>🧱 <strong>Modular</strong> — Develop context providers independently of model logic.</li></ul><h3>📈 Use Cases That Benefit from MCP AI implementations</h3><h3>🔧 Internal Developer Copilots</h3><p>Give internal AI assistants access to:</p><ul><li>Project documentation: projects://alpha/docs</li><li>Engineering org chart: org://engineering/team-leads</li><li>Platform configs: envs://prod/config</li></ul><p>Imagine an internal developer assistant that can instantly answer onboarding questions, suggest the right team contact, or surface the most relevant documentation — all powered by structured knowledge of your org chart and project landscape.</p><h3>📞 Customer Support Agents</h3><p>Enable agents to serve customers with:</p><ul><li>CRM data: customers://789/details</li><li>Purchase history: orders://789/history</li><li>SLA policies: policies://returns</li></ul><p>You could enable your support team to generate highly personalized responses — drawing from a customer’s purchase history, prior interactions, and SLA terms — without needing to manually dig through the CRM.</p><h3>💼 Financial Copilots</h3><p>Let models reference:</p><ul><li>Fund performance: funds://alpha/returns</li><li>Tax rules: regulations://germany/kst</li><li>Partner structures: entities://vc-group/partners</li></ul><p>Think of a tax assistant that drafts fund reports, flags anomalies, or explains performance — grounded in regulatory data, entity structures, and live fund metrics served as structured context.</p><h3>🧠 Multi-Agent Orchestration</h3><p>Have tools communicate via shared memory such as task assignments: tasks://active or shared knowledge: knowledge://2025/q3-objectives</p><p>Consider a multi-agent system where planners, summarizers, and reporting bots collaborate using shared memory — aligned on current tasks, priorities, and business goals via a common context graph.</p><p>Let your imagination go wild and unleash the potential of LLMs to automate and augment your business processes.</p><blockquote>MCP becomes the structured fabric through which enterprise AI systems operate.</blockquote><h3>🛠️ Building an MCP Server in TypeScript</h3><p>To demonstrate MCP in action, we’ve built a reference implementation using:</p><ul><li>TypeScript + Node.js</li><li>The official <a href="https://www.npmjs.com/package/@modelcontextprotocol/sdk">@modelcontextprotocol/sdk</a></li><li>OpenAI API (can be replaced)</li><li>Express REST API</li><li>Dynamic resolvers</li></ul><p>🔗 <strong>Get the full code on GitHub (released soon)</strong></p><h3>⚙️ Core Concepts in Code</h3><p>The key concept in MCP revolves around resources and resolvers. Resources give access to information in a structured way, and resolvers allow to retrieve such information dynamically from external systems.</p><p>Think of it as a way to let your LLM reach out to other systems and retrieve the information required.</p><h3>Register a Static Resource</h3><p>Static resources can for example be texts, which do not need additional dynamic information but shall be available at a specifc resource identifier, such as a configuration of an application.</p><pre>server.registerResource(&quot;config&quot;, &quot;config://app&quot;, { ... }, async () =&gt; ({<br>  contents: [{ uri: &quot;config://app&quot;, text: &quot;MCP Demo App v1.0&quot; }]<br>}));</pre><h3>Register a Dynamic Resource with Resolver</h3><p>Dynamic Resources allow the lookup of resources from other systems. Imagine that you want to greet your users individually and reach out in your email campaigns with tailored messages, you might want to provide the user detail information to the LLM in a structured format. Do achieve this dynamic resources can use resolvers to lookup data, in other APIs or databases.</p><pre>server.registerResource(<br>  &quot;user-profile&quot;,<br>  new ResourceTemplate(&quot;users://{userId}/profile&quot;),<br>  { ... },<br>  async (_, { userId }) =&gt; {<br>    const user = await db.getUser(userId);<br>    return { contents: [{ uri: `users://${userId}/profile`, text: JSON.stringify(user) }] };<br>  }<br>);</pre><h3>Request a Completion via REST API</h3><p>Typically, the service then exposes an easy to consume REST API for end users and other systems to trigger the retrieval of information using the given resources and executing a prompt including the context provided by the given resources.</p><p>In this example, we ask the system to generate a welcome email to the application, tailored to the given user profile.</p><pre>POST /api/complete<br>{<br>  &quot;prompt&quot;: &quot;Write a welcome email to the given app, tailored to the given user profile, make it personal.&quot;,<br>  &quot;context&quot;: [&quot;users://42/profile&quot;, &quot;config://app&quot;]<br>}</pre><h3>🧠 Why This Approach Scales</h3><h4>✅ More Maintainable AI Systems</h4><p>Decouple model prompts from business data. No more brittle prompt spaghetti.</p><h4>✅ Easier Governance</h4><p>Track exactly what data was used in every AI response.</p><h4>✅ Reusability</h4><p>Serve the same structured context to different models or apps.</p><h4>✅ Multimodal Ready</h4><p>Context can include references to files, documents, even tool APIs.</p><h3>🧬 Architecture Overview</h3><p>On a high level a typcial integration in an enterprise IT landscape is done through the HTTP REST APIs or directly the MCP interface. Since REST APIs are a common method to connect various systems, MCP can easily be integrated in existing enterprise workflows and systems. The Enterprise app triggers the request using the REST API, which then triggers the context lookup, LLM execution with prompt assembly and context loading to then generate the final result back to the enterprise application.</p><pre>[Enterprise App]<br>     ↓<br>[HTTP API / MCP Interface]<br>     ↓<br>[Context Graph: User + App + History]<br>     ↓<br>[LLM with Prompt Assembly + Context]<br>     ↓<br>[Response + Logging + Auditing]</pre><p>MCP acts as the contract between your enterprise knowledge and your AI.</p><h3>🏁 Final Thoughts</h3><p>AI systems deserve the same design discipline as software systems.</p><p>With MCP, we move beyond one-off prompting and into structured, governable, and composable AI architecture — the kind that scales inside real companies.</p><p>If you’re building internal copilots, customer assistants, or domain-specific agents, now is the right time to start working with MCP.</p><p><em>Follow me for more insights on enterprise AI architecture, context-driven agents, and scaling LLM infrastructure.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f92c20ee784f" width="1" height="1" alt=""><hr><p><a href="https://medium.com/kotaicode/structured-context-for-ai-building-an-enterprise-grade-model-context-protocol-mcp-server-f92c20ee784f">Structured Context for AI: Building an Enterprise-Grade Model Context Protocol (MCP) Server</a> was originally published in <a href="https://medium.com/kotaicode">kotaicode</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Using OpenStreetMap and OverpassAPI to Analyze GPX Tracks]]></title>
            <link>https://medium.com/kotaicode/using-openstreetmap-and-overpassapi-to-analyze-gpx-tracks-78d59cbb69f3?source=rss-b26d6e4fa84e------2</link>
            <guid isPermaLink="false">https://medium.com/p/78d59cbb69f3</guid>
            <category><![CDATA[openstreetmap]]></category>
            <category><![CDATA[gis]]></category>
            <dc:creator><![CDATA[Andreas Leicher]]></dc:creator>
            <pubDate>Thu, 16 Jan 2025 10:50:56 GMT</pubDate>
            <atom:updated>2025-01-16T10:50:56.483Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*gwfsCgl-Ljx2YwuA" /><figcaption>Photo by <a href="https://unsplash.com/@benky?utm_source=medium&amp;utm_medium=referral">Kevin Benkenstein</a> on <a href="https://unsplash.com?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>Introduction</h3><p>Cyclists and outdoor enthusiasts often rely on GPX tracks to plan their adventures. But GPX files alone lack vital information, such as the surface types of roads, elevation changes, or route suitability for different bike types. Enter <a href="https://www.openstreetmap.org/"><strong>OpenStreetMap (OSM)</strong></a> and the <a href="https://wiki.openstreetmap.org/wiki/Overpass_API"><strong>OverpassAPI</strong></a>, tools that can enrich GPX track data with custom geographic information.</p><p>In this article, we’ll explore how to use OpenStreetMap and the OverpassAPI to analyze GPX tracks. We’ll start with a general overview of OSM and OverpassAPI, move on to a practical example of surface analysis, and then calculate the suitability of a route for road or gravel biking. Finally, we’ll touch on extending this approach with custom tags and data using a private OverpassAPI setup.</p><h3>What is OpenStreetMap and OverpassAPI?</h3><h3>OpenStreetMap (OSM)</h3><p>OSM is a collaborative, open-source mapping platform where users contribute geographic data. OSM is versatile, containing detailed information about roads, paths, amenities, and even less-common data like surface types, slopes, or bike lanes. Its open nature allows developers to extract, analyze, and visualize data for various use cases.</p><h3>OverpassAPI</h3><p>OverpassAPI is a powerful query engine for extracting specific data from OSM. Unlike downloading entire map files, OverpassAPI allows targeted queries for nodes, ways, and relations based on attributes like tags, bounding boxes, or spatial relationships. This makes it ideal for processing specific GPX tracks.</p><h4>Query Syntax Basics</h4><p>The OverpassAPI uses a custom query language that lets users specify exactly what data they need. Here’s a quick breakdown:</p><ol><li><strong>Output Format</strong>: The [out:json] option specifies JSON as the output format. Other formats include XML and CSV.</li><li><strong>Timeout</strong>: Use [timeout:180] to define the maximum time (in seconds) the query can run.</li><li><strong>Bounding Boxes: </strong>Define the area of interest with (minlat, minlon, maxlat, maxlon). Example: way(50.112,8.618,50.114,8.622); queries all ways within the bounding box.</li><li><strong>Filters</strong>: Add tag filters, such as way[&quot;surface&quot;], to retrieve ways with a surface tag.</li><li><strong>Output Options</strong>: Use out geom; to include full geometry of the ways (i.e., lat/lon pairs for each node).</li></ol><pre>[out:json][timeout:180];<br>(<br>  way(50.112,8.618,50.114,8.622)[&quot;surface&quot;];<br>);<br>out geom;</pre><p>This query retrieves all ways within the bounding box that have a surface tag and returns their geometry in JSON format.</p><h4>Advanced Query Features</h4><ul><li><strong>Around Filter</strong>: Use way(around:50,50.113,8.620) to find ways within a 50-meter radius of a point.</li><li><strong>Multiple Filters</strong>: Combine filters with logical operators. Example: way[&quot;highway&quot;=&quot;cycleway&quot;][&quot;surface&quot;].</li><li><strong>Union</strong>: Group multiple queries with parentheses to fetch multiple data types in one request.</li></ul><h3>Using OverpassAPI to Analyze a Given GPX Track</h3><h3>The Problem</h3><p>GPX tracks are collections of waypoints or routes, often lacking surface or contextual data. For example, a cyclist might want to know if the route is paved (suitable for road bikes) or gravel (better for gravel bikes). OSM contains this information via tags like surface=asphalt or surface=gravel, but extracting it requires a spatial query.</p><h3>Example: Surface Analysis of a GPX Track</h3><p>We can use OverpassAPI to enrich a GPX track with surface data by:</p><ol><li><strong>Extracting Bounding Boxes</strong>: A GPX track is defined by its waypoints. To query relevant OSM data, a bounding box or buffer zone around the track is created.</li><li><strong>Querying the Surface Data</strong>: Use OverpassAPI to retrieve ways (road segments) within this bounding box that have surface tags.</li><li><strong>Analyzing Results</strong>: Match the queried road segments to the GPX track and calculate the lengths of each surface type.</li></ol><p>Here’s a Python code snippet that demonstrates querying OverpassAPI for surface data:</p><pre>import requests<br>from shapely.geometry import LineString<br><br># Define the bounding box for the GPX track<br>bbox = &quot;50.112,8.618,50.114,8.622&quot;  # (minlat, minlon, maxlat, maxlon)<br>query = f&quot;&quot;&quot;<br>[out:json][timeout:180];<br>(<br>  way({bbox})[&quot;surface&quot;];<br>);<br>out geom;<br>&quot;&quot;&quot;<br><br># Query the Overpass API<br>response = requests.post(&quot;http://overpass-api.de/api/interpreter&quot;, data=query)<br>response.raise_for_status()<br>data = response.json()<br><br># Analyze and print results<br>for element in data[&#39;elements&#39;]:<br>    surface = element[&#39;tags&#39;].get(&#39;surface&#39;, &#39;unknown&#39;)<br>    print(f&quot;Surface: {surface}&quot;)</pre><h3>Considerations</h3><ol><li><strong>Extending the GPX Track</strong>: Tracks often need a buffer (e.g., 20 meters) to capture nearby road segments, as GPS devices aren’t perfectly accurate.</li><li><strong>Handling Missing Tags</strong>: Not all road segments in OSM have surface tags. These can be flagged as unknown.</li></ol><h3>Using Analyzed Data for Bike Suitability</h3><p>Once we have surface data, we can calculate a suitability score for road or gravel bikes. Using a predefined matrix, we assign scores based on how suitable each surface type is for each bike type.</p><h3>Suitability Matrix</h3><p>The matrix assigns weights to surface types based on how comfortable they are for road and gravel biking:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/779/1*731s2WNW1nbuF7felck6EQ.png" /></figure><h3>Calculation Example</h3><p>Using Python, the suitability scores can be calculated as follows:</p><pre>def calculate_suitability(surface_data):<br>    total_length = sum(surface_data.values())<br>    road_score = sum((length / total_length) * ROAD_MATRIX.get(surface, 0.2) for surface, length in surface_data.items())<br>    gravel_score = sum((length / total_length) * GRAVEL_MATRIX.get(surface, 0.5) for surface, length in surface_data.items())<br><br>    return {&quot;roadbike&quot;: round(road_score, 2), &quot;gravelbike&quot;: round(gravel_score, 2)}</pre><h3>Extending for Additional Use Cases</h3><h3>Use Cases for Custom Data</h3><p>Custom data in OpenStreetMap opens up a range of possibilities for specialized analyses and proprietary insights. Here are some common use cases and how they can be implemented:</p><h4>Proprietary Information</h4><p>Custom tags allow users to include data that isn’t part of the standard OSM schema. For example, a private company might tag proprietary trails or restricted areas with a custom tag like access=private or private_trail=yes. This data can then be queried and analyzed for internal applications, such as:</p><ul><li><strong>Mapping private trails for internal use.</strong></li><li><strong>Analyzing restricted zones for planning projects.</strong></li></ul><h4>Enhancing Data for Niche Use Cases</h4><p>Standard OSM data might not include specific attributes required for niche applications. Custom tags can be added for:</p><ul><li><strong>Trail difficulty</strong>: Add tags like difficulty=easy or difficulty=hard for hiking and biking routes.</li><li><strong>Traffic Analysis</strong>: Use tags like traffic_density=high for urban planning.</li><li><strong>Environmental Data</strong>: Tag areas with attributes such as pollution_level=low or wildlife=protected.</li></ul><h3>Custom OverpassAPI Setup</h3><p>For querying custom tags, a public OverpassAPI instance won’t suffice as it relies on the standard OSM dataset. To enable custom data queries, you need to set up your own OverpassAPI server. Here’s how:</p><ol><li><strong>Install OverpassAPI</strong>: Follow the <a href="https://wiki.openstreetmap.org/wiki/Overpass_API/Installation">installation guide</a> to install OverpassAPI on your server.</li><li><strong>Import Custom OSM Data</strong>: Use tools like <a href="https://osm2pgsql.org/">osm2pgsql</a> to load your data, including custom tags, into the database.</li><li><strong>Query Custom Tags</strong>: Your OverpassAPI instance can now query custom tags just like standard ones.</li><li><strong>Extend with Geospatial Tools</strong>: Combine OverpassAPI with tools like QGIS, Python libraries (geopandas, shapely), or custom applications to visualize and analyze the data.</li></ol><p>Example of a query making use of custom tags:</p><pre>[out:json];<br>way[&quot;custom_tag&quot;=&quot;value&quot;];<br>out geom;</pre><h3>Conclusion</h3><p>The combination of OpenStreetMap and OverpassAPI offers a powerful toolkit for analyzing GPX tracks. Whether you’re enriching your tracks with surface data, calculating suitability scores for biking, or using custom tags, the possibilities are vast.</p><p>For a complete implementation, check out the GitHub repository at <a href="https://github.com/kotaicode/gpx_analyzer">https://github.com/kotaicode/gpx_analyzer</a> containing the full codebase. Happy mapping!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=78d59cbb69f3" width="1" height="1" alt=""><hr><p><a href="https://medium.com/kotaicode/using-openstreetmap-and-overpassapi-to-analyze-gpx-tracks-78d59cbb69f3">Using OpenStreetMap and OverpassAPI to Analyze GPX Tracks</a> was originally published in <a href="https://medium.com/kotaicode">kotaicode</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Comparing Terraform, Pulumi, and Crossplane: A Comprehensive Guide to Infrastructure as Code Tools]]></title>
            <link>https://medium.com/kotaicode/comparing-terraform-pulumi-and-crossplane-a-comprehensive-guide-to-infrastructure-as-code-tools-3841b783eeb0?source=rss-b26d6e4fa84e------2</link>
            <guid isPermaLink="false">https://medium.com/p/3841b783eeb0</guid>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[infrastructure-as-code]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <dc:creator><![CDATA[Andreas Leicher]]></dc:creator>
            <pubDate>Fri, 30 Aug 2024 10:11:16 GMT</pubDate>
            <atom:updated>2024-08-30T10:11:16.269Z</atom:updated>
            <content:encoded><![CDATA[<p>Infrastructure as Code (IaC) has become a cornerstone of modern cloud computing, allowing teams to manage and provision infrastructure through code rather than manual processes. Among the plethora of IaC tools available, Terraform, Pulumi, and Crossplane stand out as powerful options, each with its own unique approach and philosophy. This article delves into these three tools, comparing their methodologies, strengths, and weaknesses, and providing code examples to help you understand how they operate in real-world scenarios.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*H8f2IzcAgYRw0m77" /><figcaption>Photo by <a href="https://unsplash.com/@cgower?utm_source=medium&amp;utm_medium=referral">Christopher Gower</a> on <a href="https://unsplash.com?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>Understanding the Basics: Terraform, Pulumi, and Crossplane</h3><p><strong>Terraform and Pulumi: Similar Goals, Different Approaches</strong></p><p>Terraform and Pulumi are both designed to define and manage cloud infrastructure, but they differ significantly in how they achieve this goal.</p><ul><li><a href="https://www.terraform.io/"><strong>Terraform</strong></a> uses HashiCorp Configuration Language (HCL), a domain-specific language tailored for infrastructure management. It is widely adopted due to its simplicity, readability, and large ecosystem of providers.</li><li><a href="https://www.pulumi.com/"><strong>Pulumi</strong></a>, on the other hand, takes a more developer-centric approach by allowing infrastructure to be defined using general-purpose programming languages like JavaScript, TypeScript, Python, Go, and C#. This allows developers to leverage existing skills, integrate infrastructure as code with application code, and use familiar programming constructs such as loops, conditionals, and functions.</li></ul><p><strong>Crossplane: A Different Philosophy</strong></p><p><a href="https://www.crossplane.io/">Crossplane</a> stands apart from Terraform and Pulumi by embracing a different philosophy rooted in Kubernetes. While Terraform and Pulumi are imperative tools that rely on explicit commands to provision infrastructure, Crossplane operates declaratively within a Kubernetes environment. It uses the concept of continuous reconciliation, where the desired state is maintained automatically by the Kubernetes control plane.</p><p>This approach aligns with Kubernetes’ native operations, making Crossplane an attractive option for teams already invested in Kubernetes. However, it also requires a Kubernetes cluster to operate, which adds a layer of complexity compared to Terraform and Pulumi.</p><h3>Key Differences and Similarities</h3><p><strong>Reconciliation: Continuous vs. Rollout Processes</strong></p><p>One of the most significant differences between these tools is how they handle reconciliation — the process of ensuring that the actual state of infrastructure matches the desired state defined in code.</p><ul><li><strong>Crossplane</strong> leverages Kubernetes’ continuous reconciliation model. Once you define the desired state, Crossplane ensures that the actual state continuously aligns with it, without the need for explicit rollouts.</li><li><strong>Terraform and Pulumi</strong>, by contrast, rely on a rollout process. After defining the desired state in code, you must execute a command (terraform apply or pulumi up) to provision the infrastructure. This action reconciles the infrastructure with the defined state at a specific point in time but does not continuously monitor or update it.</li></ul><p><strong>Extensibility Through Providers</strong></p><p>All three tools support extensibility through providers, which are plugins or extensions that allow the tools to interact with various cloud platforms, services, and APIs.</p><ul><li><strong>Terraform</strong> boasts a massive ecosystem of providers, making it one of the most versatile IaC tools available. Providers are written in Go and can be maintained by either HashiCorp or the community.</li><li><strong>Pulumi</strong> also supports a wide range of providers, and it allows for custom provider development using general-purpose languages, which can be more accessible for developers.</li><li><strong>Crossplane</strong> uses Kubernetes Custom Resource Definitions (CRDs) and controllers to extend its functionality. This Kubernetes-native approach makes Crossplane highly modular and extensible, but it requires familiarity with Kubernetes concepts.</li></ul><p><strong>Programming Language Support</strong></p><ul><li><strong>Terraform</strong> uses HCL, which, while powerful and well-suited for infrastructure definition, is a domain-specific language. This means developers need to learn HCL in addition to their primary programming languages.</li><li><strong>Pulumi</strong> allows you to define infrastructure using popular programming languages. This is a major advantage for teams with existing software development expertise, as it reduces the learning curve and enables more complex logic within infrastructure definitions.</li><li><strong>Crossplane</strong> also allows for extensibility through programming but within the context of Kubernetes CRDs and operators, requiring knowledge of Kubernetes and its ecosystem. With the recent addition of <a href="https://docs.crossplane.io/latest/concepts/compositions/#write-a-composition-function">Crossplane Composition Functions</a> you can also write your infrastructure code in Python or Go</li></ul><h3>Pros and Cons</h3><p><strong>Terraform</strong></p><p><strong>Pros:</strong></p><ul><li>Large ecosystem of providers.</li><li>Mature, well-documented, and widely adopted.</li><li>Excellent for multi-cloud environments.</li></ul><p><strong>Cons:</strong></p><ul><li>Learning HCL can be a hurdle for new users.</li><li>Rollout-based reconciliation can be less dynamic than continuous reconciliation.</li><li>The recent <a href="https://www.hashicorp.com/blog/hashicorp-joins-ibm">acquisition of Hashicorp by IBM</a> brings additional <a href="https://medium.com/netpremacy-global-services/the-beginning-of-the-end-for-terraform-cfffcd2c5420">uncertainty to the future fate of terraform</a></li></ul><p><strong>Pulumi</strong></p><p><strong>Pros:</strong></p><ul><li>Supports general-purpose programming languages, reducing the need to learn a new DSL.</li><li>Integrates well with existing development workflows.</li><li>Strong support for complex logic and abstractions.</li></ul><p><strong>Cons:</strong></p><ul><li>Smaller ecosystem compared to Terraform.</li><li>Can be overkill for simple infrastructure setups.</li></ul><p><strong>Crossplane</strong></p><p><strong>Pros:</strong></p><ul><li>Native integration with Kubernetes and continuous reconciliation.</li><li>Highly modular and extensible through Kubernetes CRDs.</li><li>Ideal for teams heavily invested in Kubernetes.</li></ul><p><strong>Cons:</strong></p><ul><li>Requires a Kubernetes cluster to operate, adding operational overhead.</li><li>Steeper learning curve for teams not familiar with Kubernetes.</li></ul><h3>Example: Provisioning an AWS S3 Bucket</h3><p>To demonstrate the differences between these tools, let’s look at how each would provision an AWS S3 bucket.</p><h3>Terraform</h3><p>The setup of terraform and configuration of providers is left out in this example:</p><pre>provider &quot;aws&quot; {<br>  region = &quot;us-west-2&quot;<br>}<br><br>resource &quot;aws_s3_bucket&quot; &quot;example&quot; {<br>  bucket = &quot;my-unique-bucket-name&quot;<br>  acl    = &quot;private&quot;<br>}</pre><h3>Pulumi (TypeScript)</h3><p>The setup of pulumi and configuration of providers is left out in this example:</p><pre>import * as aws from &quot;@pulumi/aws&quot;;<br><br>const bucket = new aws.s3.Bucket(&quot;example&quot;, {<br>    bucket: &quot;my-unique-bucket-name&quot;,<br>    acl: &quot;private&quot;,<br>});</pre><h3>Crossplane (YAML)</h3><p>The setup of crossplane and configuration of providers is left out in this example:</p><pre>apiVersion: s3.aws.crossplane.io/v1alpha3<br>kind: Bucket<br>metadata:<br>  name: example<br>spec:<br>  forProvider:<br>    acl: private<br>    bucketName: my-unique-bucket-name<br>  providerConfigRef:<br>    name: aws-provider</pre><p>All of the above are the bare minimum to provision an AWS S3 bucket. All three IaC tools allow DevOps and Platform teams to build abstractions above the base components, providing development teams with higher level components to be used. Terraform uses the concept of modules, in Pulumi (TypeScript) classes and libraries can be created, and Crossplane is built around the concept of Compositions, which allow you to compose multiple cloud resources using your own custom API.</p><h3>Conclusion</h3><p>Terraform, Pulumi, and Crossplane each offer powerful tools for managing cloud infrastructure, but they cater to different needs and philosophies. Terraform is a robust, battle-tested tool with a vast ecosystem, making it ideal for multi-cloud environments. Pulumi appeals to developers by integrating with general-purpose programming languages, offering a seamless transition from application to infrastructure code. Crossplane, with its Kubernetes-native approach, is perfect for teams that already leverage Kubernetes and want to adopt continuous reconciliation for their infrastructure.</p><p>When choosing between these tools, consider your team’s existing expertise, your infrastructure needs, and your preferred operational model. Each tool has its strengths, and the right choice depends on your specific use case.</p><p>What all these tools have in common is that they are cloud-agnostic and can be used to provision and manage infrastructure in multiple different cloud environments. Cloud-provider specific tooling such as <a href="https://aws.amazon.com/cloudformation/">AWS CloudFormation</a>, <a href="https://learn.microsoft.com/de-de/azure/azure-resource-manager/bicep/overview?tabs=bicep">Azure Bicep</a> or <a href="https://cloud.google.com/kubernetes-engine/enterprise/config-controller/docs/overview">Google Cloud Config Controller</a> could also be interesting for your team. However they often lack extensibility to manage resources outside the cloud provider, which Pulumi, Terraform and Crossplane allow with a huge and growing ecosystem of providers for third party systems.</p><p>By understanding the differences and the unique benefits each tool brings, you can make an informed decision that aligns with your team’s goals and capabilities.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3841b783eeb0" width="1" height="1" alt=""><hr><p><a href="https://medium.com/kotaicode/comparing-terraform-pulumi-and-crossplane-a-comprehensive-guide-to-infrastructure-as-code-tools-3841b783eeb0">Comparing Terraform, Pulumi, and Crossplane: A Comprehensive Guide to Infrastructure as Code Tools</a> was originally published in <a href="https://medium.com/kotaicode">kotaicode</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[AWS IAM Roles for Kubernetes Pods in EKS]]></title>
            <link>https://medium.com/kotaicode/aws-iam-roles-for-kubernetes-pods-in-eks-5fdbb2df4ed0?source=rss-b26d6e4fa84e------2</link>
            <guid isPermaLink="false">https://medium.com/p/5fdbb2df4ed0</guid>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[it-security]]></category>
            <category><![CDATA[aws]]></category>
            <dc:creator><![CDATA[Andreas Leicher]]></dc:creator>
            <pubDate>Fri, 19 Jan 2024 14:59:10 GMT</pubDate>
            <atom:updated>2024-01-19T14:59:10.735Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*EfFUZR-HSkN2hiGI" /><figcaption>Photo by <a href="https://unsplash.com/@teapowered?utm_source=medium&amp;utm_medium=referral">Patrick Robert Doyle</a> on <a href="https://unsplash.com?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Amazon Elastic Kubernetes Service (EKS) simplifies the deployment and management of Kubernetes clusters on AWS. As organizations transition to containerized workloads, it becomes crucial to implement robust security measures. One powerful tool at your disposal is AWS Identity and Access Management (IAM), which allows you to control access to AWS services and resources securely. In this article, we’ll explore the usage of IAM Roles for pods in AWS EKS and discuss the option of using IAM Roles for Service Accounts.</p><h3>Why IAM Roles for Pods?</h3><p>When running applications on Kubernetes, pods often need to interact with AWS services such as S3, DynamoDB, or other AWS resources. Instead of embedding AWS credentials directly within the pod or managing them manually, IAM Roles for pods provide a more secure and scalable solution.</p><p>Key Advantages of Using IAM Roles for Pods:</p><p><strong>1. Improved Security:</strong></p><p>IAM Roles allow you to follow the principle of least privilege, granting pods only the permissions they need to perform specific actions. This minimizes the risk associated with exposed or leaked credentials.</p><p><strong>2. Automated Credential Rotation:</strong></p><p>IAM Roles come with automatic credential rotation, enhancing the security of your applications by regularly rotating access keys. This eliminates the need for manual intervention and ensures that your credentials remain up-to-date.</p><p><strong>3. Simplified Access Management:</strong></p><p>IAM Roles facilitate centralized access management, enabling you to define and enforce access policies consistently across your Kubernetes cluster. This simplifies auditing and compliance efforts.</p><h3>Implementing IAM Roles for Pods in EKS</h3><p>AWS provides two methods of implementing IAM Roles for Pods in EKS: IAM Roles for ServiceAccounts (IRSA), and EKS Pod Identity (released in November 2023).</p><p><strong>Using IAM Roles for Service Accounts (IRSA):</strong></p><p>Let’s walk through the steps of setting up IAM Roles for pods in AWS EKS:</p><p>1. Create an IAM OIDC Identity Provider</p><p>Before associating IAM roles with Kubernetes service accounts, you need to create an OIDC identity provider. Follow the detailed instructions in the <a href="https://docs.aws.amazon.com/eks/latest/userguide/enable-iam-roles-for-service-accounts.html">AWS documentation</a>.</p><p>2. Create an IAM Role</p><p>Create an IAM role that defines the permissions your pods require. Ensure that you trust the OIDC identity provider you created in the previous step.</p><pre># Example IAM Role JSON<br>{<br>  &quot;Version&quot;: &quot;2012-10-17&quot;,<br>  &quot;Statement&quot;: [<br>    {<br>      &quot;Effect&quot;: &quot;Allow&quot;,<br>      &quot;Principal&quot;: {<br>        &quot;Federated&quot;: &quot;arn:aws:iam::&lt;account-id&gt;:oidc-provider/&lt;eks-cluster-id&gt;&quot;<br>      },<br>      &quot;Action&quot;: &quot;sts:AssumeRoleWithWebIdentity&quot;,<br>      &quot;Condition&quot;: {<br>        &quot;StringEquals&quot;: {<br>          &quot;oidc.eks.&lt;region&gt;.amazonaws.com/id/&lt;eks-cluster-id&gt;:sub&quot;: &quot;system:serviceaccount:&lt;namespace&gt;:&lt;service-account-name&gt;&quot;<br>        }<br>      }<br>    }<br>  ]<br>}</pre><p>3. Associate the IAM Role with the Kubernetes Service Account:</p><p>Update your Kubernetes service account to use the IAM role created above.</p><pre># Example Kubernetes Service Account YAML<br>apiVersion: v1<br>kind: ServiceAccount<br>metadata:<br> name: &lt;service-account-name&gt;<br> annotations:<br> eks.amazonaws.com/role-arn: arn:aws:iam::&lt;account-id&gt;:role/&lt;iam-role-name&gt;</pre><p>4. Test that the role can be properly assumed by the pod</p><p>In order to test that the IAM Role can be used by the pod, it is easiest to launch a debug pod in the respective namespace. For this example, we use our <a href="https://hub.docker.com/r/kotaicode/ubuntu-devops">public kotaicode/ubuntu-devops docker image</a>. This docker image contains a lot of useful tools for debugging in different cloud providers, database systems, and the <a href="https://github.com/kotaicode/ubuntu-devops">code for the docker image</a> is public in github.</p><pre># assuming that the serviceaccount is &quot;replace-me&quot;<br>SA_NAME=replace-me kubectl run tmp-shell-0 --rm -i --tty --image kotaicode/ubuntu-devops:24 --overrides &#39;{&quot;spec&quot;:{&quot;serviceAccountName&quot;:&quot;&#39;$SA_NAME&#39;&quot;}}&#39; -- /bin/bash<br><br># this will launch a pod in the current namespace, and gives you a shell<br># now, from inside the pod we check our AWS role<br>aws sts get-caller-identity --no-cli-pager<br>{<br>    &quot;UserId&quot;: &quot;AXXXXXXXXX:botocore-session-12343214&quot;,<br>    &quot;Account&quot;: &quot;123456789012&quot;,<br>    &quot;Arn&quot;: &quot;arn:aws:sts::123456789012:assumed-role/xxxxxxxxxxxx&quot;<br>}<br></pre><p><strong>EKS Pod Identity:</strong></p><p>In November 2023, <a href="https://aws.amazon.com/de/about-aws/whats-new/2023/11/amazon-eks-pod-identity/">AWS launched the feature of EKS Pod Identity</a>, which further simplifies the usage of IAM roles for pods.</p><p>EKS Pod Identity allows for more granular control over pod-level permissions. With this feature, you can assign IAM roles directly to individual pods, tailoring permissions to the specific needs of each workload. One significant improvement is the simplified configuration of pod identities. EKS Pod Identity automates the setup of IAM roles and OIDC identity providers, reducing the manual steps required to establish secure pod-to-AWS communication.</p><p>On top, auditability is increased, since access and event logging is available through AWS CloudTrail to help facilitate retrospective auditing.</p><p>Amazon EKS Pod Identity provides credentials to pods with an additional <em>EKS Auth</em> API and an agent pod that runs on each node. From the code itself, AWS SDKs are used to access AWS services. Note that you need to use an updated AWS SDK in your client code, which already supports the EKS Pod Identity feature.</p><p>The details of how EKS Pod Identities work can be found in the <a href="https://docs.aws.amazon.com/eks/latest/userguide/pod-id-how-it-works.html">AWS documentation</a>.</p><p>The next steps are a summary of the required steps, please follow the <a href="https://docs.aws.amazon.com/eks/latest/userguide/pod-id-association.html">official documentation</a>.</p><p>The steps boil down to:</p><ol><li>Install the EKS Pod Identity Agent in your cluster</li><li>Once the agent is up and running, you can use the AWS console or AWS CLI to map pod ServiceAccounts to IAM roles:</li></ol><p>2.1. create a serviceaccount in your cluster</p><pre>apiVersion: v1<br>kind: ServiceAccount<br>metadata:<br>  name: my-service-account<br>  namespace: default</pre><p>2.2. Create a role, which allows the AssumeRole for the pods.eks.amazonaws.com principal using such an assumeRolepolicyDocument</p><pre>{<br>    &quot;Version&quot;: &quot;2012-10-17&quot;,<br>    &quot;Statement&quot;: [<br>        {<br>            &quot;Sid&quot;: &quot;AllowEksAuthToAssumeRoleForPodIdentity&quot;,<br>            &quot;Effect&quot;: &quot;Allow&quot;,<br>            &quot;Principal&quot;: {<br>                &quot;Service&quot;: &quot;pods.eks.amazonaws.com&quot;<br>            },<br>            &quot;Action&quot;: [<br>                &quot;sts:AssumeRole&quot;,<br>                &quot;sts:TagSession&quot;<br>            ]<br>        }<br>    ]<br>}</pre><p>2.3. Attach the IAM policies to the role to grant the desired permissions</p><p>2.4. create the association between the serviceAccount and the IAM Role</p><pre>aws eks create-pod-identity-association --cluster-name my-cluster --role-arn arn:aws:iam::111122223333:role/my-role --namespace default --service-account my-service-account</pre><p>To debug the functionality, you can use the same steps as with IRSAs, by launching a pod, and checking the assume-role functionality</p><pre># assuming that the serviceaccount is &quot;replace-me&quot;<br>SA_NAME=replace-me kubectl run tmp-shell-0 --rm -i --tty --image kotaicode/ubuntu-devops:24 --overrides &#39;{&quot;spec&quot;:{&quot;serviceAccountName&quot;:&quot;&#39;$SA_NAME&#39;&quot;}}&#39; -- /bin/bash<br><br># this will launch a pod in the current namespace, and gives you a shell<br># now, from inside the pod we check our AWS role<br>aws sts get-caller-identity --no-cli-pager<br>{<br>    &quot;UserId&quot;: &quot;AXXXXXXXXX:botocore-session-12343214&quot;,<br>    &quot;Account&quot;: &quot;123456789012&quot;,<br>    &quot;Arn&quot;: &quot;arn:aws:sts::123456789012:assumed-role/xxxxxxxxxxxx&quot;<br>}</pre><h3>Summary</h3><p>Whether you use the IRSA concept or the newer EKS Pod Identity feature, it is highly recommended to be as specific and restrictive as possible and hence assign permissions on a per Pod level and leverage the existing AWS IAM security architecture.</p><p>It is a bad practice to assign policies directly to the nodes of the EKS cluster and thus giving all pods permissions. Ideally you should consider the security best practices for AWS EKS, and disable the instance metadata service, as per the <a href="https://docs.aws.amazon.com/whitepapers/latest/security-practices-multi-tenant-saas-applications-eks/restrict-the-use-of-host-networking-and-block-access-to-instance-metadata-service.html">AWS documentation</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5fdbb2df4ed0" width="1" height="1" alt=""><hr><p><a href="https://medium.com/kotaicode/aws-iam-roles-for-kubernetes-pods-in-eks-5fdbb2df4ed0">AWS IAM Roles for Kubernetes Pods in EKS</a> was originally published in <a href="https://medium.com/kotaicode">kotaicode</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[One Day of ReactJS]]></title>
            <link>https://medium.com/kotaicode/one-day-of-reactjs-1aa908e24978?source=rss-b26d6e4fa84e------2</link>
            <guid isPermaLink="false">https://medium.com/p/1aa908e24978</guid>
            <category><![CDATA[reactjs]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[react]]></category>
            <dc:creator><![CDATA[Andreas Leicher]]></dc:creator>
            <pubDate>Fri, 20 Dec 2019 10:25:58 GMT</pubDate>
            <atom:updated>2019-12-20T12:32:59.329Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*N7je4u05jpeWseaBbapWgA.jpeg" /></figure><p><a href="https://reactday.berlin/">ReactDay Berlin</a> was an event bringing together 800 React developers from all over the globe, 24+ speakers with talks on 2 different tracks.<br>With a mix of in-depth-talks, hands-on workshops, the conference showed the high level of interest and activity in the ReactJS universe.</p><p>We attended the conference with our team and want to share some of our impressions here with you. The conference website provides an <a href="https://reactday.berlin/#talks">overview of the talks</a>. All talks were also streamed live to the web and are available on the <a href="https://www.youtube.com/channel/UC1EYHmQYBUJjkmL6OtK4rlw">ReactDay youtube channel</a>.</p><h4>CSS in JS</h4><p>The keynote, held by <a href="https://medium.com/@mxstbr">Max Stoiber</a>, one of the co-creators of <a href="https://www.styled-components.com/">styled components</a>, presenting not only the history of the different packages that have been created, but also giving a detailed view into the use of the styled-components package. Since v2, released in 2017, the developers delivered massive performance boosts, just recently released v5, which is fully hooks-powered. By using React hooks, there is less component nesting and much cleaner React DevTools.</p><p>The main idea behind styled-components (and other packages) is to write actual CSS in your Javascript. This allows you to use all features of CSS, but extends your possibilities. You can interpolate a function into your css template, which gets passed the props of the component, allowing you to create very dynamic CSS.</p><p>Also Max encouraged people to join the efforts in the opensource community, and shared his experience on how to create an open source project:</p><p>- make it work, make it right, then make it fast<br>- Share early, share often<br>- Document all the things</p><h4>Performance Anxiety with React</h4><p>Jessica Leach of FutureLearn presented a whole collection of great tools that make the everyday life of a react developer easier, more efficient and productive. With this great overview of tools and possibilities to analyse and solve performance issues in your react apps.<br>For sure something we are already using, and will investigate deeper in our daily work when building react applications:</p><p>- Why did you update (<a href="https://github.com/maicki/why-did-you-update">https://github.com/maicki/why-did-you-update</a>) notifies you in the console if you have unnecessary re-renders in your application<br>- React Profiler (<a href="https://reactjs.org/blog/2018/09/10/introducing-the-react-profiler.html">https://reactjs.org/blog/2018/09/10/introducing-the-react-profiler.html</a>) which helps you to collect timing information about each component to identify performance bottlenecks in React applications<br>- use of `ShouldComponentUpdate` hook to avoid updating, when no re-render is needed<br>- use Pure components (<a href="https://medium.com/better-programming/working-with-react-pure-components-166ded26ae48">https://medium.com/better-programming/working-with-react-pure-components-166ded26ae48</a>)<br>- optimize using memoization, e.g. the `usememo` hook (<a href="https://reactjs.org/docs/hooks-reference.html#usememo">https://reactjs.org/docs/hooks-reference.html#usememo</a>) and `useCallback` (<a href="https://reactjs.org/docs/hooks-reference.html#usecallback">https://reactjs.org/docs/hooks-reference.html#usecallback</a>) which returns a memoized callback<br>- if you need to render large datasets, react-window(<a href="https://github.com/bvaughn/react-window">https://github.com/bvaughn/react-window</a>) helps you to improve performance by only rendering part of a large dataset, also react-virtualized(<a href="https://github.com/bvaughn/react-virtualized">https://github.com/bvaughn/react-virtualized</a>) might be worth a look<br>- in order to make sure that your webpack bundle only contains the stuff you need, take a look at webpack bundle analyzer (<a href="https://github.com/webpack-contrib/webpack-bundle-analyzer">https://github.com/webpack-contrib/webpack-bundle-analyzer</a>)<br>- although still in experimental stage, the suspense for data fetching (<a href="https://reactjs.org/docs/concurrent-mode-suspense.html">https://reactjs.org/docs/concurrent-mode-suspense.html</a>) of react adds a Suspense component which lets you “wait” for some code to load and specify a loading state, e.g. a spinner while you’re waiting.</p><h4>Strong RESTful contracts in a GraphQL world</h4><p>Tejas Kumar of contiamo GmbH gave a very inspiring talk about the disadvantages of a RESTful world. From his point of view Graphql provides benefits over RESTful contracts, summarized by the following four points about RESTful:</p><p>- it is not a formal specification<br>- it often requires guessing (types, fields)<br>- can lead to long, meaningless discussions<br>- no contractual agreements are in place when using RESTful</p><p>However, establishing graphql in companies can be difficult, so they created the package <a href="https://github.com/contiamo/restful-react">restful-react</a> which is a wrapper around the fetch API to provide a better developer experience when building react apps which interact with a RESTful API. Definitely worth checking out.</p><h4>other takeaways</h4><p>There have been many more interesting talks, so check out the <a href="https://www.youtube.com/channel/UC1EYHmQYBUJjkmL6OtK4rlw">videos</a>, the above only presents a selection of interesting topics.<br>In general, the react community is very alive, with constant improvements to the ecosystem and for sure a frontend framework of choice when it comes to build modular and scalable frontend applications.</p><h4>about kotaicode</h4><p>We are a software company specializing in the development of scalable web applications, cloud and data science. We love to build fullstack web applications using go, ruby on rails, python and react, we build infrastructure using docker &amp; kubernetes. If you are passionate about building software products, feel free to reach out to us: <a href="http://kotaico.de">kotaico.de</a><br>If you’re planing to introduce docker or kubernetes, and are looking for training: checkout our <a href="https://devops-workshops.com/">workshops</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1aa908e24978" width="1" height="1" alt=""><hr><p><a href="https://medium.com/kotaicode/one-day-of-reactjs-1aa908e24978">One Day of ReactJS</a> was originally published in <a href="https://medium.com/kotaicode">kotaicode</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Delivery Pipelines as enabler for a DevOps culture]]></title>
            <link>https://medium.com/hackernoon/delivery-pipelines-as-enabler-for-a-devops-culture-ebc45963f703?source=rss-b26d6e4fa84e------2</link>
            <guid isPermaLink="false">https://medium.com/p/ebc45963f703</guid>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[docker]]></category>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[culture]]></category>
            <category><![CDATA[continuous-delivery]]></category>
            <dc:creator><![CDATA[Andreas Leicher]]></dc:creator>
            <pubDate>Fri, 20 Jul 2018 13:58:10 GMT</pubDate>
            <atom:updated>2019-04-27T10:49:10.258Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NSN1a2xVtV1exzcD8fpzhA.jpeg" /></figure><p>A lot of teams and organisations are embracing <a href="https://hackernoon.com/tagged/devops">DevOps</a> culture for building digital products and delivering business value with digital services. DevOps <a href="https://hackernoon.com/tagged/culture">culture</a> promotes an agile, iterative approach, with a strong emphasis on continuous delivery of working software, in close alignment with business goals. The term is already 10 years old, still most companies and teams are now on the journey to put it into practice.</p><p>DevOps is based on the idea to reduce the time it takes between committing a change to the code and this change being made available to users (in a way it provides value to the users).</p><p>Or to even expand on this notion: reduce the time it takes between learning about how users are experiencing your product today, and creating a better user experience by shipping an improved version of your product.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8NUKdU9XS-ItKFwTW01V6A.png" /><figcaption>DevOps with a User Experience Perspective: it’s not only about how fast you can deliver from code change to user value, but how fast you can turn a bad user experience into a great user experience and continuously improve your product.</figcaption></figure><p>The perspective of DevOps as a continuous improvement of the user experience of your product means you put your users at the center of your work, by continuously going through the full cycle of product development: plan, code, build, test, release, deploy, operate, monitor, and then plan again based on the observations you made.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/781/1*H6-sYH6dUKSYqvri3-H0kw.png" /><figcaption>The DevOps Continuous Lifecycle: the notion of continuous product improvement</figcaption></figure><p>When you look at the phases in the DevOps Lifecycle it is important to mention that this is more than a technical perspective. Roughly it can be broken down in two areas. The left side (code, build and test) focusses on the creation of new product value, the right side (deploy, operate, monitor) focusses on the value delivery to the user. Especially phases that are user facing (the right side of the loop), shall be used to monitor user behaviour, understand user experience, and learn about how your product is used. The transition between the two loops, of value creation and value delivery, focusses on planning the next iteration and making sure you release the value you wanted to create.</p><p>If our goal is to minimise the time (and effort) to come from a bad user experience to a better user experience (or from a defect to a fix, from a request to a new feature), we also shall look at the factors that contribute to that goal. Obviously culture is key, to generate the environment where this notion is understood and supported. At the same time, tools and toolchains play an important role along this value chain.</p><p>Tools along the lifecycle allow to:</p><ul><li>ease communication to create a better shared understanding</li><li>automate recurring tasks, and thus reduce error</li><li>not only fix issues, but add tests to prevent same issues from coming up again</li><li>understand how users use your product</li><li>prioritise next releases and features based on actual user feedback and business value</li></ul><p>The notion of a delivery pipeline that assists the team in eliminating waste, and deliver value faster and better is very often expressed in concepts such as Continuous Integration and Continuous Delivery (CI/CD). By automating infrastructure, tests and deployments, by leveraging cloud functionality it is possible to bring down the time between code being written and being made available.</p><p>Most of the CI/CD work focusses on the left side of the DevOps cycle. It has proven that container based architectures in combination with cloud technology provides huge benefits, in such a sample environment:</p><ul><li>Communication: Messaging apps like slack or flock have proven to be very useful at keeping everyone on the same page. Especially since it allows the integration of relevant events into the messaging channels.</li><li>Plan: Tasks are tracked, planned and prioritized in tools such as JIRA or trello</li><li>Code: code is kept in git version control so all developers can collaborate. Even during development, docker containers are used to prevent the ‘worked on my machine’ syndrome</li><li>Build: builds are created automatically using Continuous Integration like CircleCI, Jenkins or gitlabCI. The containers which are built are pushed to a container registry, so every commit creates a build. Since it is automated, no developer time is consumed. Also: there’s immediate feedback if a build fails.</li><li>Test: automated tests are a great way to make sure you don’t have to fix the same bug twice. While concepts like Test Driven Development (TDD) are great, not all teams have the budget or time to really start with tests first. In an environment of continuous improvement however, it shall become a habit to add a test, anytime a bug is found. Since you minimise time to ship, having a bug in production might not be as critical if the next deploy is only a minute away. By using cloud technology, such as Kubernetes, you can even spin up a test environment for your QA team before each release</li><li>Release: if the desired value is captured in the new version, even a non-technical person can release, by just adding a tag to the current version in version control. The CI system then takes care</li><li>Deploy: Especially in combination with container technology such as docker and kubernetes, the CI can now just apply updated manifest files to the kubernetes cluster, and by that make sure that the new version will be deployed/pulled from the container registry. Containers make sure, you have exactly the same software that the developer used, and that was tested before. Also technologies like terraform or ansible might come to play, in case you bring up new infrastructure via code.</li><li>Operate: operations encompass performance monitoring, logging, and making sure the engine runs. Kubernetes provides the container orchestration to automatically restart failed deployments, tools like fluentd, elasticsearch, kibana, and prometheus allow for continuous monitoring of all applications. The product team is constantly aware of the system health</li><li>Monitor: not only system performance, also UX. Use techniques like A/B testing, page speed, using Google Analytics, AppDynamics, Optimizely and the like</li><li>The results form monitoring and operations then feed back into the plan of the next iteration, helping the product team to prioritise</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Ce5TF2R9nrUwL9TVTVNKyA.png" /><figcaption>DevOps Pipeline Tool Overview (selection of tools, note: image/logo rights are with the respective copyright owners)</figcaption></figure><p>note: the products and technologies mentioned above are not the only ones, but have proven to work pretty well in projects.</p><p>While DevOps is not about the technology you apply, the delivery pipeline can enable the product team to deliver value continuously. In a second part of this article, I’ll share a more technical view on the architecture of a sample delivery pipeline.</p><p>Credits:</p><ul><li>header image: by <a href="https://unsplash.com/photos/p-xSl33Wxyc?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Farzad Nazifi</a> on <a href="https://unsplash.com/search/photos/pipeline?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Unsplash</a></li><li>brand and product logos belong to their respective copyright holders</li></ul><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fupscri.be%2Fdde502%3Fas_embed%3Dtrue&amp;dntp=1&amp;url=https%3A%2F%2Fupscri.be%2Fhackernoon%2F&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=upscri" width="800" height="400" frameborder="0" scrolling="no"><a href="https://medium.com/media/3c851dac986ab6dbb2d1aaa91205a8eb/href">https://medium.com/media/3c851dac986ab6dbb2d1aaa91205a8eb/href</a></iframe><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ebc45963f703" width="1" height="1" alt=""><hr><p><a href="https://medium.com/hackernoon/delivery-pipelines-as-enabler-for-a-devops-culture-ebc45963f703">Delivery Pipelines as enabler for a DevOps culture</a> was originally published in <a href="https://medium.com/hackernoon">HackerNoon.com</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The false promises of prototyping]]></title>
            <link>https://medium.com/hackernoon/the-false-promises-of-prototyping-2d87a5a08311?source=rss-b26d6e4fa84e------2</link>
            <guid isPermaLink="false">https://medium.com/p/2d87a5a08311</guid>
            <category><![CDATA[design-thinking]]></category>
            <category><![CDATA[prototyping]]></category>
            <category><![CDATA[startup]]></category>
            <category><![CDATA[rapid-prototyping]]></category>
            <category><![CDATA[lean-startup]]></category>
            <dc:creator><![CDATA[Andreas Leicher]]></dc:creator>
            <pubDate>Mon, 05 Feb 2018 23:20:17 GMT</pubDate>
            <atom:updated>2019-04-27T10:49:11.268Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oZXmY8cSXYGvImmJe4x2Dg.jpeg" /><figcaption>Know your tools, so you can build the right thing, in the right way.</figcaption></figure><p>With all the buzz around digital transformation, and more and more consultancies jumping on the bandwagon of throwing tech buzzwords around to convince their clients to spend huge sums on some new digital initiative, there seem to be more silver bullets than ever before to tackle the challenges of <a href="https://hackernoon.com/tagged/digitization">digitization</a>.</p><p>One of these silver bullets that’s overly hyped is the <a href="https://hackernoon.com/tagged/prototyping">prototyping</a> and the promises behind it. The promises associated with prototyping cover a broad range: deliver fast results (who doesn’t want to be fast?), have something tangible to convince your internal stakeholders (who doesn’t want to have sth fancy to climb up on the career ladder?), to visualize an idea (who doesn’t want to have something fancy to put on that next slidedeck?), a clickdummy to play around and define your future product (clickdummies are easy to explain and sell, so why not?), or a showcase to have a nice new addition to your corporate museum (called innovation lab). So it starts to happen that the prototype becomes a product in its own, and more often than not, this mentality then leads to prototypes that are expensive, time consuming and no longer serve an important purpose: maximise your learning.</p><p>When dealing with complex problems in the age of digital, you have to deal with uncertainty. The world changes faster than ever before, and technology is becoming a commodity which allows more and more founders to start a new business on the budget of their credit card limits. In order to deal with the uncertainty and the associated risk, it is paramount to have early market feedback. This is well explained in a lot of places, e.g. the <a href="https://steveblank.com/2015/05/06/build-measure-learn-throw-things-against-the-wall-and-see-if-they-work/">build-measure-learn cycle by Steve Blank</a>. Only with this early market feedback, you can change direction by measuring and deriving learnings from it.</p><p>With this in mind, the prototype becomes one tool in your toolbelt to reach the goal of <a href="https://steveblank.com/2013/07/22/an-mvp-is-not-a-cheaper-product-its-about-smart-learning/">maximising your learning</a>. Therefore it is important to start with a clear set of hypotheses and an idea about your business model. Identify the riskiest parts of it, and the parts where you see the highest uncertainty. Only if you test the riskiest assumptions, you can maximise your learning. By doing that you risk, that the customer feedback is negative. So it is not about creating a prototype to please your users or stakeholders, it is not about building something to visualise your idea, it is about running an experiment.</p><p>In order to run an experiment, you should have your question and hypothesis prepared. You use the prototype to measure and test the market. For that you have to <a href="https://www.inc.com/steve-blank/key-to-success-getting-out-of-building.html">get out of the building</a> and talk to <a href="https://steveblank.com/2013/09/05/why-real-learning-is-outside-the-building-not-demo-day/">real users and customers</a>. Some people recommend specific amounts of people you shall talk to, others even prepare questionnaires which are then religiously followed in customer interviews, and even worse: by asking them if they like what they see. By doing this you run the risk of just getting confirmation of your pre-conceived opinion, and won’t get the learning. Asking good (open) questions is well described by Rob Fitzpatrick in ‘<a href="http://momtestbook.com/">The Mom Test</a>’. For each iteration, for each hypothesis, you should decide individually how many people to interview, and when to dig deeper, and ask more people. For example you might decide to ask 10 people from your target user group, and decide that if at least 5 face the problem you are trying to solve, to then dig deeper and ask more users. This process cannot be planned upfront, and has to be decided upon in each iteration.</p><p>Ideally you engage with these potential early adopters and early users on a personal level and continue the dialogue and experiments as these might actually become the first paying customers for your service or product. Also it allows you to learn a lot about how users interact with your product, and prevents you from making a pre-mature investment into an <a href="https://medium.com/swlh/just-skip-it-9-features-your-product-does-not-need-to-launch-b9f2311e0dfa">unnecessary self-service onboarding process</a>.</p><p><strong>Recommendations when prototyping</strong></p><ul><li>know your business model, or at least, have a set of assumptions of how it might look like. Do not start with just an idea.</li><li>identify the riskiest part of your business model</li><li>have a clear goal in mind, know your hypothesis, and decide how you are going to measure the results</li><li>go from lo-fi to hi-fi prototypes, try to test fast and early</li><li>get out of the building and test it yourself, ask open questions, learn about the problem the customer is facing</li><li>keep track of the results, and your learnings, try to challenge your assumptions and be ready to discard your initial assumptions and ideas</li></ul><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fupscri.be%2Fdde502%3Fas_embed%3Dtrue&amp;dntp=1&amp;url=https%3A%2F%2Fupscri.be%2Fhackernoon%2F&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=upscri" width="800" height="400" frameborder="0" scrolling="no"><a href="https://medium.com/media/3c851dac986ab6dbb2d1aaa91205a8eb/href">https://medium.com/media/3c851dac986ab6dbb2d1aaa91205a8eb/href</a></iframe><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2d87a5a08311" width="1" height="1" alt=""><hr><p><a href="https://medium.com/hackernoon/the-false-promises-of-prototyping-2d87a5a08311">The false promises of prototyping</a> was originally published in <a href="https://medium.com/hackernoon">HackerNoon.com</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The rise and death of corporate innovation labs]]></title>
            <link>https://medium.com/hackernoon/the-rise-and-death-of-corporate-innovation-labs-6139b9000d40?source=rss-b26d6e4fa84e------2</link>
            <guid isPermaLink="false">https://medium.com/p/6139b9000d40</guid>
            <category><![CDATA[design-thinking]]></category>
            <category><![CDATA[innovation]]></category>
            <category><![CDATA[agile]]></category>
            <category><![CDATA[lean-startup]]></category>
            <dc:creator><![CDATA[Andreas Leicher]]></dc:creator>
            <pubDate>Sun, 03 Dec 2017 14:06:05 GMT</pubDate>
            <atom:updated>2019-04-27T10:49:13.064Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_hEDASII5u7vgqJ9NH4mYA.jpeg" /><figcaption>Great products are built, when passion hits vision.</figcaption></figure><p>The whole idea of building a corporate innovation lab sounds exciting, promising, hip, and somehow innovation labs are all the rage. Having the words <em>‘innovation’</em> and <em>‘lab’</em> in it, makes it sound like you’re missing the party of digital, when your company doesn’t have one yet. And while some are just considering starting their lab, and others are running their labs, the first ones get already shut down. Obviously the event of shutting down the innovation lab, that was once the holy grail on the road to digitalisation, is not made public as much as the opening.</p><p>However, following the philosophy of <a href="https://steveblank.com/2015/05/06/build-measure-learn-throw-things-against-the-wall-and-see-if-they-work/">build-measure-learn</a>, and fail fast, a lot can be learned from looking at those labs that failed in their journey.</p><h3>Cool ideas are not enough</h3><p>Most often, people conflate innovation with creativity. While creativity is an important ingredient in innovation, just <em>‘coming up with cool ideas’</em> is not enough for innovation to be sustainable. You need to combine creative ideas with viable business models, that solve real problems to come to a sustainable business model. Some labs fail to deliver on that promise, as they are not about searching and finding profitable business models, but rather about coming up with new ideas. You see yourself going down that road, when ideas are valued more than the results from experiments. Even worse so, when prototypes are made to be put on slideshows, to show how great ideas are. Originally they ought to be used to validate a business idea.</p><h3>Innovation Theatre</h3><p>Bean bags, pitch sessions, cool furniture, everything seems to look different. Post-Its on the walls, business model canvasses spread over the place, and all other ‘<a href="https://hackernoon.com/tagged/startup">startup</a>’-like swag. That goes together with the chatter around minimum-viable-products, <a href="https://hackernoon.com/tagged/agile">agile</a>, pivots, iterations, sprints, etc. It seems, everybody just found their inner Silicon Valley. When true innovation is put to work, you might see the same items appear, but for a reason. These are the tools and there are reasons for using these tools, the visible things are just an expression of the tools being put to practice. Innovation Sprints that last 3 days, with the goal of delivering a slidedeck in the end kind of defy the original meaning of the <a href="http://www.gv.com/sprint/">Design Sprint</a>. You will rcognize you built an innovation theatre, when discussions about gadgets, showcases, take over the discussions about a user-centric approach to discover problems worth solving.</p><h3>Focus on vanity metrics</h3><p>It might be hard to convince the stakeholders that your main job as innovation hub is to validate business models. Hence, it is much easier to fall back to vanity metrics, which are nor directly related to impact. Number of events hosted, visitors welcomed, number of press mentions, etc. Number of validated business models? 0. Number of business models taken to scale? 0.</p><h3>Putting space first</h3><p>…and forgetting about the people. Yes, a shiny office, with all the innovation theatre swag you need might impress visitors and your clients. That alone does not create innovation. Focus on the people instead. Think about the process you want to facilitate. The space should work for the people who are supposed to work in there. Make sure you cater for all the different needs. You might be tempted to build a very open space, as it is great to welcome all your visitors and creates this feeling that innovation <em>must</em> happen here. Beware though that exactly these kind of environments can bring productivity to a standstill, as open offices have been proven to not work. If you are still building your hub, consider this <a href="https://medium.com/@ummerr/youre-working-in-the-wrong-place-e289036ee01c">article</a> for architectural inspiration.</p><blockquote>They tend to believe that bean bags and nerf guns create a great office culture and magically lead to innovation — <a href="https://www.innovate-strategy.com/blog/2017/10/22/youre-building-or-managing-an-innovation-hub-this-post-is-for-you-1">Sebastian Vetter</a></blockquote><h3>No protected space</h3><p>While the physical space needs serious consideration to support the desired outcome, you also need to think about the psychological safety you need to create in order to drive innovation. If the team cannot work autonomous, and is prone to attacks from the corporate immune system, you will sooner or later be working in the same methods and ways the existing organisation does. Your ability to innovate is inherently dependent on how independent you can be from the main organization. Good innovation labs have built an almost completely separate entity, with backing from C-level executives. Their job then becomes defending the new entity against the reactions of the corporate immune system. By being autonomous, the new entity can build the roles, processes, systems, tools, and methods that are required to even attack the business model of the existing corporation. Then slowly, the new ways of working can transpire into the larger organisation.</p><h3>No investment for innovation</h3><p>In today’s ever-changing world, nobody can predict what business is going to look like in 3 to 5 years. Hence, the key is the ability to adapt to change, and the speed of reacting to change. Hence, you have to take the risk that something might not work. Treat failure as learning. Optimize for early failure, and fast learning, even if that means no immediate return on investment.</p><h3>Be ready to make your current business model obsolete</h3><p>If you are not willing to explore the option of making your current business model obsolete, someone else will do so. Or is already working on it. In order to be able to do so, you must be ready to invest, willing to protect from the corporate immune system, and have C-level buy-in to create the protected space in which innovative business models can appear.</p><h3>Building a museum not a work area</h3><p>When you are on the road to set up an innovation theatre, you might as well fall trap to building a museum, full of gadgets, showcases, which is aswesome to support your vanity metrics, such as amounts of visitors, and guests. This will make a lot of buzz and increase your visibility.</p><p>Beware that exactly these outcomes are the things that will prevent your team from actually delivering value. The museum will attract many visitors. Visitors will need guidance, which will take away valuable time. At the same time you increase the distraction, keeping also those from working who are not guiding visitors. By providing your new space for corporate events, you will soon be recognized not for the value you wanted to bring, but for your ability to host events. You focus on the right catering, light and sound system and forget about the original goal: validate new business models, take risks, experiment, fail, learn, build.</p><h3>The luxury and misery of many projects</h3><p>You started your innovation lab, and with all the buzz around it, you get a lot of projects. This is a luxury and a sign that something you’re doing seems to be of interest. However, trying to work on all or too many of them at the same time will make you deliver less. Innovation Methods, like sprints, are designed to focus on one thing at a time, to deliver a focussed outcome. It is not about how many things you can juggle at the same time, but picking the thing that the team can juggle best, and do it. Sprinting on more than one project at the same time is an anti-pattern, still often seen in corporate innovation labs. As you want to make everyone happy, and are measured by the amount of sprints, or even worse, by the amount of hours billed for sprints. This defies the idea of making sure you do the right thing, even if that means burying an idea if it has proven not viable in a sprint.</p><h3>Approaches for building innovation labs that work</h3><p>While not all corporate innovation labs go down that road, or have to, it is worth exploring the common factors of those considered successful. There <a href="https://www.acronis.com/en-us/blog/posts/four-worlds-most-innovative-corporate-labs">are</a> <a href="https://www.imaginatik.com/5-innovation-labs-that-im-watching/">several</a> <a href="https://techcrunch.com/2015/05/31/labs-and-incubators-fuel-enterprise-innovation/">publications</a> about successful innovation labs. These are some of their common factors:</p><ol><li><strong>Built outside of the regular organisation</strong>. While it might be connected in one way or the other, treating the innovation lab as an almost independent entity gets rid of most of the issues mentioned above</li><li><strong>Ability to take risks</strong>. Moonshot ideas like the ones being set forth in Google[x] require you to take risks. If only 1-2 of them emerge after several years, it is considered a success. Experiments are mandatory.</li><li><strong>Diversity</strong>. Diverse teams allow to look at problems from multiple angles. Only by allowing to see problems from different perspectives, and allowing all opinions, with no politics, new and innovative approaches can emerge.</li><li><strong>Not serving the organisations demands</strong>. While this might sound counter-intuitive at first, a lot of value can be generated by doing things differently, even if that means attacking the current business model of the organisation and being truly disruptive. When you start serving the demands of your organisation, you immediately shift into the role of the service provider, trying to fulfil requirements that are already known. The key is however to discover the unknown. To understand the problem from a user centric perspective and build the right solution to that problem. This might be a solution that attacks the current business model. Hence, you inherently are in conflict of interest, when you start serving the needs of your organisation’s demands.</li><li><strong>Have a clear vision, and be passionate about it</strong>. Great products are built, when passion hits vision. You need to state a clear vision that you are willing to defend against the outside environment, and position yourself properly against all other stakeholders. Be passionate about the vision, show your passion to the team, make sure the team understands the clear vision and can build passion for it.</li></ol><h3>Thoughts, Ideas, Comments?</h3><p>As developer and entrepreneur, I am passionate about building products people love. I think that a lean and agile approach to building products, services and companies is a way to deal with the inherent complexity of today’s business challenges. Leave your thoughts and ideas in the comments.</p><h3>Further Reading</h3><ul><li><a href="http://www.leanessays.com/2017/11/the-cost-center-trap.html">The Cost Center Trap</a></li><li><a href="https://www.innovate-strategy.com/blog/2017/10/22/youre-building-or-managing-an-innovation-hub-this-post-is-for-you-1">You&#39;re building or managing an innovation hub? This post is for you!</a></li><li><a href="https://medium.com/@Cat_knees/the-life-and-death-of-a-corporate-innovation-lab-rip-2012-2016-2c59b9d48c91">The Life and Death of a Corporate Innovation Lab — RIP 2012–2016</a></li><li><a href="https://www.forbes.com/sites/tendayiviki/2016/09/04/five-reasons-your-boss-was-right-to-close-your-innovation-lab/#4d67b7571c45">Five Reasons Your Boss Was Right To Shut Down Your Innovation Lab</a></li><li><a href="https://venturebeat.com/2015/12/12/before-you-build-an-innovation-lab-answer-these-6-questions/">Before you build an innovation lab, answer these 6 questions</a></li></ul><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fupscri.be%2Fdde502%3Fas_embed%3Dtrue&amp;dntp=1&amp;url=https%3A%2F%2Fupscri.be%2Fhackernoon%2F&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=upscri" width="800" height="400" frameborder="0" scrolling="no"><a href="https://medium.com/media/3c851dac986ab6dbb2d1aaa91205a8eb/href">https://medium.com/media/3c851dac986ab6dbb2d1aaa91205a8eb/href</a></iframe><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6139b9000d40" width="1" height="1" alt=""><hr><p><a href="https://medium.com/hackernoon/the-rise-and-death-of-corporate-innovation-labs-6139b9000d40">The rise and death of corporate innovation labs</a> was originally published in <a href="https://medium.com/hackernoon">HackerNoon.com</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Should I go for microservices or a monolithic application?]]></title>
            <link>https://medium.com/hackernoon/should-i-go-for-microservices-or-a-monolithic-application-28e9e2a47eae?source=rss-b26d6e4fa84e------2</link>
            <guid isPermaLink="false">https://medium.com/p/28e9e2a47eae</guid>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[startup]]></category>
            <category><![CDATA[monolithic-applications]]></category>
            <category><![CDATA[agile]]></category>
            <category><![CDATA[lean-startup]]></category>
            <dc:creator><![CDATA[Andreas Leicher]]></dc:creator>
            <pubDate>Sun, 03 Dec 2017 12:38:31 GMT</pubDate>
            <atom:updated>2019-04-27T10:49:14.430Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3yuw8W5U20IWIuSaYREN9w.jpeg" /><figcaption>Building a product that works is like climbing a mountain. You go step by step, and enjoy the journey.</figcaption></figure><h3><strong>Intro to microservices</strong></h3><p>Microservices have been around for some while, and are a pretty well known pattern to build applications and digital services. To put it in simple terms, a <em>microservices architecture </em>decouples individual components of a service, basically each component becomes an application of its own. All microservices are connected using defined <em>APIs, </em>making it possible to have autonomous teams work on individual pieces of the application, mostly without breaking each others functionality. <a href="https://medium.com/refraction-tech-everything/how-netflix-works-the-hugely-simplified-complex-stuff-that-happens-every-time-you-hit-play-3a40c9be254b">Netflix</a> for example states that it uses about 700 microservices to provide their streaming service.</p><p>A lot has been written about the options to convert from an existing monolithic application to microservices, e.g. using <a href="https://www.elastic.io/breaking-down-monolith-microservices-and-self-contained-systems/">self-contained systems</a>, or the <a href="https://www.michielrook.nl/2016/11/strangler-pattern-practice/">strangler application pattern</a> as described by <a href="https://www.martinfowler.com/bliki/StranglerApplication.html">Martin Fowler</a>, as well as the <a href="https://www.readitquik.com/articles/in-premises/hy-microservices-is-the-future-of-software/">benefits of microservices</a>, and books have been written about how to <a href="https://www.amazon.com/Building-Microservices-Designing-Fine-Grained-Systems/dp/1491950358/">build and design microservices</a>.</p><p>While microservices might now sound like the holy grail to an architecture that supports agile practices (and to some extent it does), you should apply it in the right situation for the right problem, with the target outcome and environment in mind. Hence this article brings in the perspective of product development and the lifecycle of your product from idea to <a href="https://hackernoon.com/tagged/scalability">scalability</a>.</p><h3>On the Journey to Microservices</h3><p>When you read about success stories of converting to microservice architectures, you will realize that most of them stem from product companies, which all have a business model, where the core relies on a digital product/asset that is responsible for the majority of their revenues.</p><p>With this in mind, we shall remind ourselves that these companies have been on a journey of hundreds of iterations in their product and business model.</p><p>They then arrived to this architecture as it solved some of their needs. In most cases you start to switch from monolithic to microservices when you have proven that you’re solving a problem. When they did <a href="http://andrewchen.co/when-has-a-consumer-startup-hit-productmarket-fit/">hit product market fit</a>. “Product/market fit means being in a good market with a product that can satisfy that market”, as <a href="http://web.archive.org/web/20070701074943/http:/blog.pmarca.com/2007/06/the-pmarca-gu-2.html">Marc Andreessen</a> puts it.</p><p>This allows them to have independent teams, that work on individual services, scale team and product without compromising too much on speed (think <a href="http://blog.idonethis.com/two-pizza-team/">Bezos’ two pizza rule</a>).</p><p>They all share common goals and a vision which is closely tied to the success of the product and hence to thebusiness model. Since the work and effort is tightly connected to the success of the business, it is natural to continuously invest in the product and the team that delivers it as you thrive towards delivering maximum business value per product iteration.</p><p>Then all the decoupling, autonomy, scalability of microservices can bring more value in shorter time. It is an investment in a long-run game.</p><blockquote>Microservices are not a free lunch — Benjamin Wootton</blockquote><h3>Microservices and the early state company</h3><p>On the other hand, microservices inherently introduce added complexity, and operational overhead. You need to have the right people, stable teams working with a DevOps mindset and the right skills. ”<a href="http://highscalability.com/blog/2014/4/8/microservices-not-a-free-lunch.html">Microservices are not a free lunch</a>”, as said by <a href="https://twitter.com/benjaminwootton">Benjamin Wootton</a>. Martin Fowler rightly says: “<a href="https://martinfowler.com/bliki/MicroservicePrerequisites.html">you must be this tall to use microservices</a>”, basically advocating an approach where you slowly transition into microservices, as you build internal expertise and team.</p><p>All this overhead can slow you down in the initial phase, in <a href="https://steveblank.com/2010/01/25/whats-a-startup-first-principles/">the search for a scalable business model</a>, in the phase where you try to reach the MVP, and get customers excited about your product.</p><p>In this phase, speed is key. First to market means early customer access. And even more important: the shorter your <a href="http://www.startuplessonslearned.com/2010/09/good-enough-never-is-or-is-it.html">build, measure, learn feedback cycle</a> is, the more you reduce the risk of building something nobody wants.</p><p>In an early product phase, try to reach product market fit first. <a href="https://blog.adioma.com/do-things-that-dont-scale-in-startups-infographic/">Take shortcuts</a>. <a href="http://paulgraham.com/ds.html">Do things that don’t scale</a>. Do things manually. Premature optimisation binds resources that could deliver more direct customer value. Ask yourself whether you rather want a working business model that does not scale yet, or whether you want to scale a business model that doesn’t work.</p><blockquote>Do things that don’t scale — Paul Graham</blockquote><h3>So what shall I do now?</h3><p>First, make sure you understand the benefits and drawbacks of microservices, and consider the investment you need to make. Make a plan and answer the following questions for yourself:</p><ol><li>Are you building a product that is the core of your business model? If it is a project that you hand off to someone else later, that you deliver to someone else, make sure you agree with them on your strategy.</li><li>Do you have a stable team/stable teams, which will continue working on the product until you sunset it? If not, the added complexity will slow you down and the investment in the teams will most likely not pay off, if you reshuffle them, and assign them on other projects or tasks.</li><li>Do you plan to expand your team and product, because the market demands your product to grow and scale? If you plan to just launch it, and then see what comes, without a plan on how you grow your product beyond launch day, why would you prematurely optimize.</li><li>Do you have the right people with the right skills? You will need people who bring all the high-class skills to manage, build, design, operate complex distributed systems. If you’re not willing to build a stable team around the product, most likely you will not invest in the team.</li><li>Do you have a business model that works and your product at the core? If your business model is not proven yet, consider that you are trading scalability for speed at a stage, where speed is key, where you want to learn fast, iterate quickly. A complex architecture might be adaptable to change, but bringing it there might be an initial investment that slows you down.</li></ol><h3>Thoughts, Ideas, Comments?</h3><p>I tried bringing in the perspective of business building into the discussion of microservices. As developer and entrepreneur, I am passionate about building products people love. I think that a lean and agile approach to building products, services and companies is a way to deal with the inherent complexity of today’s business challenges. Leave your thoughts and ideas in the comments.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fupscri.be%2Fdde502%3Fas_embed%3Dtrue&amp;dntp=1&amp;url=https%3A%2F%2Fupscri.be%2Fhackernoon%2F&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=upscri" width="800" height="400" frameborder="0" scrolling="no"><a href="https://medium.com/media/3c851dac986ab6dbb2d1aaa91205a8eb/href">https://medium.com/media/3c851dac986ab6dbb2d1aaa91205a8eb/href</a></iframe><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=28e9e2a47eae" width="1" height="1" alt=""><hr><p><a href="https://medium.com/hackernoon/should-i-go-for-microservices-or-a-monolithic-application-28e9e2a47eae">Should I go for microservices or a monolithic application?</a> was originally published in <a href="https://medium.com/hackernoon">HackerNoon.com</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>