<?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[Lightenna - Medium]]></title>
        <description><![CDATA[Highly-scalable web services, DevOps and Cloud architecture - Medium]]></description>
        <link>https://medium.com/lightenna?source=rss----9107dcf5095d---4</link>
        <image>
            <url>https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png</url>
            <title>Lightenna - Medium</title>
            <link>https://medium.com/lightenna?source=rss----9107dcf5095d---4</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 12:13:59 GMT</lastBuildDate>
        <atom:link href="https://medium.com/feed/lightenna" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Fear not the technical debt]]></title>
            <link>https://medium.com/lightenna/fear-not-the-technical-debt-4c9e8474949b?source=rss----9107dcf5095d---4</link>
            <guid isPermaLink="false">https://medium.com/p/4c9e8474949b</guid>
            <category><![CDATA[technical-debt]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[web-services]]></category>
            <dc:creator><![CDATA[Alex Stanhope]]></dc:creator>
            <pubDate>Wed, 16 Jan 2019 11:20:11 GMT</pubDate>
            <atom:updated>2019-01-16T11:18:52.750Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jvMXeWVsIy4qHfItgkJ5zg.jpeg" /><figcaption>Technical debt might feel like a weight around a development team’s neck, but it can be pretty healthy if periodically remediated.</figcaption></figure><ul><li>Everything you should have done</li><li>Couldn’t do or</li><li>Couldn’t afford to do earlier</li></ul><p>Technical debt (tech debt) is the sum total of all the technical tasks that either <em>need</em> to be completed, or <em>should</em> be completed before an app/web site/web service goes live. There are many different descriptions of live, but I’m talking about the full production mode of the app after it’s been through alpha and beta test stages.</p><p><a href="https://www.youtube.com/watch?v=OwbgCgDeH4k&amp;t=18s">https://www.youtube.com/watch?v=OwbgCgDeH4k</a></p><h3>Examples</h3><ul><li>IAC</li><li>Documentation</li><li>API formalisation</li><li>No frameworks</li></ul><p>Depending on the scale of the app and the skills of the team working on it, often it seems faster to set up infrastructure by hand rather than write it as infrastructure-as-code. However before you plunge headlong into production operation, it’s worth catching the infrastructure up. Here are some examples of the kind of things that can later expose unremediated tech debt:</p><h3>Someone needs a live-like environment that’s not prod</h3><p>That might be because you will need another production-like environment to:</p><ul><li>conduct some new feature testing</li><li>test the impact of upgrading dependencies</li><li>shift-left your prod environment to increase the accuracy of regression testing</li><li>improve the quality of code being cut by giving developers a live-like environment</li><li>manage a transition to a new platform or cloud</li><li>give access to an auditor, security penetration tester, due diligence consultant etc.</li></ul><h3>You didn’t document anything</h3><p>At some point a developer sage said “the code is self-documenting” and everyone on the dev team agreed, so nobody wrote anything to explain how it works.</p><p>No one likes writing documentation, but a certain amount of it is essential, no matter how well crafted the code is. It’s worth writing a high-level design (or HLD) document retrospectively if one doesn’t exist already. Looking at the project from 30,000 feet, the HLD should guide the uninformed observer through all aspects of the technology contained within or linked to this app. There doesn’t need to be any duplication, so a well-written HLD should link through to the code for more information. And then, yes, the code should be self-documenting to clearly explain <em>how</em> it works.</p><h3>Components connect by magic</h3><p>APIs are great. Formalising the interface between different components means that they can be developed independently and readily decoupled. Loose coupling means those same components could be reused, or more likely swapped out because:</p><ol><li>stuff changes</li><li>no one can predict how it’s going to change, accurately, all of the time</li><li>the (better if refactored) replacement just has to deliver the interface contract, ideally specified as tests.</li></ol><h3>Everything is bespoke</h3><p>Open source is a transformative tool if well-deployed. Not-invented-here frameworks and libraries save you time in the long-run. While their adoption may take additional time in the beginning, it’s usually worth it to:</p><ul><li>understand the elements of your solution that you share in common with hundreds or perhaps thousands of other dev teams</li><li>research relevant frameworks</li><li>design integrations between distinct open-source components</li><li>curb your architecture to fit with community design patterns and practices</li><li>learn about each framework and deal with the inevitable issues of customisation</li></ul><p>The alternative is to code everything in-house. That’s often hugely attractive to inexperienced dev teams, but becomes less attractive when the volume of code maintained by the team grows while headcount remains the same. Developers are spending more time debugging, maintaining, securing and extending existing code.</p><p>Over-reliance on frameworks and under-reliance on frameworks can both be different types of tech debt. The goal is to tread a pragmatic line:</p><ul><li>try not to invent things that already exist elsewhere</li><li>use community frameworks catalytically to prompt ‘standards’ discussions within the team</li><li>embrace the disciplines that make large open source projects work</li></ul><h3>More examples</h3><ul><li>Scalability</li><li>Unmaintainable code</li><li>High availability, DR</li><li>Tests</li><li>Access to production</li></ul><p>Tech debt rears it’s head in many guises. Here are some more examples of the kind of things that can hide in web projects:</p><h3>It won’t scale</h3><p>If you design a solution to be infinitely scalable — more accurate to say ‘massively scalable’ — it will probably take longer to build that it needed to. Even if you’re absolutely certain it’s going to need to meet that scale, it’s still sensible to build a smaller, leaner iteration before jumping right in. Agile says when building a sportscar, that you should build a wheel, then a skateboard, then a buggy, then a compact, then eventually evolve it right the way through to your target sportscar. This approach helps identify unknowns early, before the design becomes too intransigent to change.</p><p>If you’ve taken an agile approach then hopefully you’ve deliberately accrued some tech debt around scalability.</p><h3>It’s a monolith</h3><p>When building a solution, it’s typically <em>slightly</em> quicker to build it as a single large program. Now this quickly becomes untrue, and purists would argue that it is actually faster to design and build microservices from the start, but judging by how many teams have built monoliths I’d argue that unless prompted, that tends to be how big projects go. When faced with a monolith, it becomes very difficult to maintain and support that code:</p><ul><li>Maintenance releases typically require downtime.</li><li>Parallel running instances of the codebase create concurrency issues.</li><li>Pinch points accumulate around data write operations.</li><li>Business domains get conflated into single codebases and lose flexibility.</li></ul><p>The solution is to build out microservices whose high-level designs follow that of the business or organisation they serve. Splitting a large monolithic codebase into microservices can be a particularly tricky remediation activity. This can be a particularly toxic form of tech debt because it’s so costly to sort it out later.</p><h3>If anything fails, it all fails</h3><p>It takes time to go back and swap out those single instances for managed clusters (horizontal scaling) and more time to ensure that there’s no scenario where an elaborate combination of failures means that you lose data. Investing that time too early is wasteful, so it’s worth accumulating some technical debt, because it’s going to be remediated later… just so long as you do actually remediate it later! Coding for failure is another area where it’s best not to accumulate the debt in the first place, because fixing it retrospectively is tough.</p><h3>You didn’t do TDD</h3><p>There are robust development methodologies that should make it impossible, but sometimes unit and integration tests are:</p><ul><li>functionally incomplete</li><li>missing key areas of the sites functionality</li><li>don’t cover all the code</li><li>haven’t been kept up-to-date as the product has evolved</li></ul><h3>Nothing’s in production yet</h3><p>If Sprint 0 is about setting the team up, sprint #1 is entirely about getting to production. Sadly it’s Sprint 26 and while your alpha testing has gone really well and you’ve got some great user feedback, you’ve nothing in production. I see it over and over again that teams leave production to later, or worse expect to hurl the code over the wall to an operations team who “look after live”.</p><blockquote><em>You build it, you run it.</em></blockquote><p>I’m a firm believer that having an app in production as early as possible is a great discipline for a team. If you can get into a regular release cadence, that empowers everyone in the team to embrace the DevOps methodology that sees Development and Operations collaborating right through the software development lifecycle, you’re going to go far.</p><h3>Why does it accrue?</h3><ul><li>Foresight is 0/20</li><li>Risk management</li></ul><p>While each of us can make an informed guess of what will happen in some areas of technology, in the short to medium term, no one can tell you in detail what’s going to happen next year. Knowing the limitations of that crystal-ball gazing is empowering.</p><h3>Manage risks not predictions</h3><p>Project teams deal with this 0/20 foresight using risk management. Because we can’t know the future, we have to:</p><ul><li>build for the present</li><li>build for what we know now</li><li>build to test and learn</li></ul><h3>Derisk early and often</h3><p>Technical debt is a natural artifact of risk management. We cut corners now, because we only know about now. While we might be able to make an informed guess about the future, investing significant development time on features or functionality that might never see the light of day is a sure way to waste money and shorten the runway. The key principal of deliberately accruing tech debt is that we <em>will</em> return to a feature in the future, but ideally when we more completely understand its requirements: what we need versus what we’d like.</p><ul><li>Never</li><li>Right away</li><li>When it becomes the next blocker</li><li>Risk vs reward</li></ul><p>Knowing when to remediate that tech debt comes down to an informed understanding of the gap between what we have now and what we need.</p><h3>Procrastinate until tomorrow</h3><p>Suprisingly often, the answer is never. If we cut a corner or created a partial implementation of a feature, but later discover that the feature is not important, or less used that we’d hoped, then we can dump the feature and dump all the tech debt attached to it. No one likes throwing code away, but it’s a much nice feeling discarding or writing off effort when it’s a bit of proof-of-concept work, rather than an expensive over-engineered, production-grade solution.</p><h3>Do it today</h3><p>Similarly sometimes the tech debt should be dealt with immediately. I encourage teams to always keep tests up-to-date and ensure appropriate coverage for unit tests. It’s a false economy “just hacking something fast” because bugs cost more the later they’re discovered. Test first and test always, unless of course you want a low quality product, in which case let your test suite go. Just don’t imagine that you can ‘inspect’ quality back into the product later. Bad source code is just bad source code, unless you’ve got tests that prove it’s good enough, or mathematical proofs that it’s perfect (say because that aircraft vendor you work for needs their autopilot to be 100%!)</p><h3>Yesterday was the perfect time</h3><p>If there is a ‘right’ time to remediate, it’s usually driven by a need. Typically the cost of developing a feature drops, but beyond a certain point, the cost starts rising again. But beware: those increasing costs are often hidden! If you half-ass your disaster recovery work, you’ll find out how expensive that tech debt can be when something goes wrong.</p><h3>How much of it should we carry?</h3><ul><li>Indicators</li><li>Too much</li><li>Too little</li></ul><p>It’s impossible to say how much is right, but there are some good indicators that you’re carrying too much or too little.</p><h3>Too much</h3><p>If progress against deliverables is slow, often that’s caused by unremediated tech debt. If your developers are not spending time coding afresh, but debugging then you’ve probably not had sufficiently robust automated test procedures in the past, or scant unit testing. If your developers are spending too much time coding, then that could be caused by re-building the wheel, when a common framework might save time and nugatory effort.</p><p>If your dev team are complaining about the amount of tech debt (or ‘hacks’) in the solution, it’s usually time to review it. Perfectionist programmers — I’ve been guilty of this — tend to bemoan anything that isn’t quite right. The solution isn’t to down tools and concentrate only on the debt, but perhaps to instigate some kind of progressive improvement process. Teams can dedicate a certain number of hours/week to fixing, refactoring or sorting out the debt properly.</p><h3>Too little</h3><p>If your product owner (PO) is complaining about poor progress against features, the answer may be to deliberately accumulate more tech debt. Again this approach is beset on all sides by precarious risks. Delaying tech tasks that the PO doesn’t care about might seem like a good way of racing forward, but it’s important to be clear that by taking short-cuts we’re really borrowing from future capacity rather that creating more capacity.</p><h3>How do we know what we’ve got</h3><ul><li>Get us in</li><li>Use our free web audit toolkit</li><li>Peer behind the curtain</li></ul><p>Well you get Lightenna in for a couple of days to do a web audit for you!</p><p>Or use our free <a href="https://www.lightenna.com/tech/2018/web-service-review-and-cloud-audit/">web audit framework</a> to conduct your own audit, but seriously the best way to tackle the problems associated with tech debt is to understand it and manage it explicitly. There’s no reason to fear it, unless you can’t quantify it or recognise the consequences of carrying it. Like every good horror movie director knows, we’re all much more afraid of that which we can’t see.</p><p><em>Originally published at </em><a href="https://www.lightenna.com/tech/2019/fear-not-the-technical-debt/"><em>www.lightenna.com</em></a><em> on January 16, 2019.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4c9e8474949b" width="1" height="1" alt=""><hr><p><a href="https://medium.com/lightenna/fear-not-the-technical-debt-4c9e8474949b">Fear not the technical debt</a> was originally published in <a href="https://medium.com/lightenna">Lightenna</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to go to the Cloud, well]]></title>
            <link>https://medium.com/lightenna/how-to-go-to-the-cloud-well-bc7bfe1de923?source=rss----9107dcf5095d---4</link>
            <guid isPermaLink="false">https://medium.com/p/bc7bfe1de923</guid>
            <category><![CDATA[open-source]]></category>
            <category><![CDATA[cloud]]></category>
            <category><![CDATA[cloud-framework]]></category>
            <dc:creator><![CDATA[Alex Stanhope]]></dc:creator>
            <pubDate>Fri, 30 Nov 2018 20:33:30 GMT</pubDate>
            <atom:updated>2018-11-30T20:33:30.038Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jZ3gq9cgkMlZDiQnfwFZLQ.jpeg" /><figcaption>Cloud might feel like a tick-box purchasing decision, but getting tangible business outcomes from a Cloud strategy is all about the people.</figcaption></figure><ul><li>Mountain / Elephant metaphor</li><li>Overwhelming big design</li></ul><p>Bigger consultancies might sell the Cloud as a destination: a mountain-top that you can only ascend with their help. It’s not. Creighton Abrams said “when eating an elephant, take one bite at a time”. They might propose elaborate Cloud frameworks, each unique and ‘tailored’ to your business, but they would be glossing over two fundamentals:</p><ol><li>Their minimum viable product could be much more minimum.</li><li>Much of the Cloud is generic, re-usable and free.</li></ol><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FeE9fZd5nHp0%3Ffeature%3Doembed&amp;url=http%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DeE9fZd5nHp0&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FeE9fZd5nHp0%2Fhqdefault.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/008e69a9031ef3f09a5d4f29be2befd7/href">https://medium.com/media/008e69a9031ef3f09a5d4f29be2befd7/href</a></iframe><h3>Cloud framework</h3><p>Here’s an example of a fairly moderate but still intimidating Cloud framework. There’s a lot here and I talk it through box-by-box in the <a href="https://www.lightenna.com/tech/2018/cloud-framework/">Cloud framework</a> post. <strong>If</strong> your world is sufficiently unchanging that you can design something end-to-end now for a well-understood future, then going for a big launch once you’ve completed an 18-month build is viable.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/771/1*lpPN8P8DmjBnVryJeuTuhg.png" /></figure><h3>Agile</h3><ul><li>Fast-changing</li><li>New actors</li><li>Managing risk</li><li>Active</li></ul><p>However the digital world we live in is dynamic and fast-changing. Massive visions and behemoth Cloud adoption strategies are comforting in their organised elegance, but fraught with risk. Lean, test-and-learn, short-cycle iteration is taking us in a different direction.</p><p>Businesses live and die by their ability to get data, refine it into knowledge then use that to make good decisions about the short and medium term. Reactive, and proactive, teams have the skills to embrace that change, adapt their knowledge and grow.</p><h3>Alike</h3><ul><li>Common ground</li><li>Accentuate the differences</li><li>Not invented here</li></ul><p>The Cloud is incredibly generic. While every snowflake business has a purpose, core logic and selling point that makes it unique, there’s no reason why their server estates have to be so individual. Every day developers, technical architects and specialists are designing improved re-usable components that can make your Cloud:</p><ul><li>more manageable</li><li>more scalable</li><li>more secure</li></ul><h3>Open</h3><ul><li>Open source software</li><li>Free or freemium software</li></ul><p>These components are shared openly because their value is in application, not in abstract. Earlier this year Lightenna released our <a href="https://www.lightenna.com/tech/2018/cloud-starter/">Cloud Starter</a> training course open-source, so that others could benefit from that sharing in the same way we have.</p><h3>Starting with people</h3><p>Instead of shooting for the moon or buying into a seven-figure, multi-year plan, I’d like to advocate a different approach. A box on a diagram has a nice simplicity, but the business outcomes associated with Cloud success have people at their core.</p><p>As ever, if you’ve got questions or comments, please tweet, reply or <a href="https://www.lightenna.com/contact">get in touch</a>.</p><p><em>Originally published at </em><a href="https://www.lightenna.com/tech/2018/how-to-go-to-cloud-well/"><em>www.lightenna.com</em></a><em> on October 1, 2018.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=bc7bfe1de923" width="1" height="1" alt=""><hr><p><a href="https://medium.com/lightenna/how-to-go-to-the-cloud-well-bc7bfe1de923">How to go to the Cloud, well</a> was originally published in <a href="https://medium.com/lightenna">Lightenna</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Web service review and Cloud audit]]></title>
            <link>https://medium.com/lightenna/web-service-review-and-cloud-audit-ebb791a57944?source=rss----9107dcf5095d---4</link>
            <guid isPermaLink="false">https://medium.com/p/ebb791a57944</guid>
            <category><![CDATA[production-readiness]]></category>
            <category><![CDATA[cloud-audit]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[Alex Stanhope]]></dc:creator>
            <pubDate>Fri, 30 Nov 2018 20:20:44 GMT</pubDate>
            <atom:updated>2018-11-30T20:20:13.369Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NW7ngyi2n0ajzX7TjHW9lA.jpeg" /><figcaption>Beyond the code, there’s so much that needs to be thought about when launching and running a production-grade, scalable and extensible app or web service. Let’s get specific!</figcaption></figure><p>Every audit is about deeply understanding a technology platform and the people who are responsible for it. That process is as unique as the project itself, but we tend to ask a standard set of questions to ensure that nothing gets overlooked.</p><h3>Drawing data out</h3><h3>Log capture</h3><ul><li>What does your log pipeline look like? (e.g. Fluentd, Logstash, Elasticsearch)</li><li>How long are logs retained for?</li><li>What’s the log latency from capture to analysis?</li><li>What data is redacted from the logs and where in the pipeline?</li><li>What container-level, host-level or environment-level data is logged?</li></ul><h3>Application log analysis</h3><ul><li>What technologies do you use to analyse logs? (e.g. Kibana)</li><li>Who supports the application?</li><li>Are the developers involved and if so at what ‘line’?</li><li>Who has access to application logs (in different environments)?</li><li>What IDs are related log entries joined by?</li><li>Who is responsible for the logs, their readability, utility and insights?</li></ul><h3>Security log analysis</h3><ul><li>How are attacks detected?</li><li>Once detected, how is an attack understood?</li><li>How are threat actors identified and blocked?</li><li>Do you receive or subscribe to any threat analysis services? If so, how do you act on that information?</li><li>Do you conduct any pattern analysis on logs to identify new threats?</li><li>Which (IdP) systems on your network conduct user authentication (validating who they are) and authorisation (giving them permission to do things)?</li><li>Are all access attempts on IdP systems logged?</li><li>Who is responsible for reviewing, categorising and (where appropriate) verifying failed access attempts?</li></ul><h3>APM</h3><ul><li>How do you profile application performance?</li><li>What technologies do you use for APM? (e.g. Stackify, Dynatrace)</li><li>Where are the known bottlenecks in your application?</li><li>When do you conduct optimisation?</li></ul><h3>Managing code</h3><h3>Source control</h3><ul><li>What source control do you use? (e.g. GitHub)</li><li>What’s your branching strategy?</li><li>Where are different branches deployed?</li><li>How are production branches identified?</li><li>What systems refer to your source control system?</li></ul><h3>Continuous Integration</h3><ul><li>How does the build process work?</li><li>What software orchestrates the build process? (e.g. Jenkins)</li><li>What artifacts are produced by the build?</li><li>How are tested changes merged into the codebase?</li><li>Is there a static/dynamic code review performed on each merge?</li><li>Are any code quality tests run as part of a merge?</li></ul><h3>Configuration management</h3><ul><li>What tools are used to handle configuration management? (e.g. Puppet, Ansible, Chef)</li><li>What configuration logs are kept?</li><li>Can administrators directly access production systems?</li><li>How much manual intervention is required during environment provisioning?</li></ul><h3>Artifact management (e.g. Artifactory)</h3><ul><li>How are static assets handled?</li><li>How is the code versioned?</li><li>How are tags/identifiers/names used to connect artifacts with source versions?</li><li>Where are version:environment deployment logs kept?</li></ul><h3>Deployments and environments</h3><h3>Environment management</h3><ul><li>What environments do you maintain for the product/project?</li><li>What is the path to live through those environments?</li><li>Are there any shared environments used by multiple projects or their administration?</li><li>How are new environments provisioned?</li></ul><h3>Continuous Deployment (e.g. Jenkins)</h3><ul><li>How are builds deployed to production?</li><li>Does the deployment process vary for dev, test, staging or production?</li><li>What deployment strategies do you use into production? (e.g. Rolling/Canary/Recreate)</li><li>How do you handle breaking changes? (e.g. a breaking schema update on the database)</li></ul><h3>Container hosting (e.g. Docker)</h3><ul><li>Do you use containers in dev?</li><li>Do you use containers in production?</li><li>Upon what image do you base your containers?</li><li>How are containers built?</li></ul><h3>Container orchestration</h3><ul><li>How do you orchestrate your containers in production? (e.g. Kubernetes, Docker Swarm)</li><li>What degree of control do you have over the orchestration layer?</li><li>How do you handle platform updates?</li><li>How is access controlled to the platform?</li></ul><h3>Machines and services</h3><ul><li>What subscription-based services do you use in favour of building/running/managing yourself?</li><li>To what extent are you dependent upon those services?</li><li>What SLAs do you have in place with those vendors?</li><li>How do you manage the risks associated with vendor lock-in?</li></ul><h3>Machine provisioning</h3><ul><li>What tools do you use for machine provisioning? (e.g. Terraform)</li><li>Is that provisioning idempotent (reliably repeatable as exactly once) or are there uncontrolled environmental/human influences?</li><li>How is your infrastructure versioned?</li><li>How is provisioning state handled? (e.g. local, S3 bucket, other — Atlas)</li></ul><h3>Patch management</h3><ul><li>For self-managed hosts, how are operating systems and application servers patched?</li><li>How do you stage those patches before releasing into production?</li><li>To what extent are you exposed to upstream changes? (e.g. NPM left-pad chaos)</li><li>If using a gold OS build, how are older systems up-levelled to the latest gold build?</li></ul><h3>Secure base operating system</h3><ul><li>For self-managed hosts, where do you source the base operating system image?</li><li>What hardening do you undertake of the image?</li><li>What additional tools do you install on all hosts?</li><li>Do you maintain your own gold build, or if not how do you standardise at the OS level?</li></ul><h3>Secret management</h3><ul><li>What information is classified as secret?</li><li>Where are secrets stored?</li><li>What technology is used to store and protect secrets? (e.g. Vault or KMS)</li><li>How are limited-lifetime secrets (e.g. certificates) rotated?</li><li>Who is allowed access to the secret management system?</li><li>How are machines granted access to secrets?</li><li>Where else are secrets persisted and in what state (encoded/encrypted)?</li></ul><h3>Off-cloud access and LAN integration (e.g. AWS DirectConnect)</h3><ul><li>How do engineers access your production systems?</li><li>What separation exists between your local area network (LAN) and the production network?</li><li>What kind of external access is available to your staff? How is that restricted?</li></ul><h3>People and processes</h3><h3>[Maintenance] User management</h3><ul><li>Who has access to your production systems?</li><li>Under what situations is access granted?</li><li>How is access controlled?</li><li>How are maintenance users separated from application users?</li><li>Can administrators masquerade as application users or perform operations as-if them?</li></ul><h3>Architecture</h3><ul><li>Is the system broken into services and if so, at what granularity? (e.g. Monolith, microservices, nano-services)</li><li>When segmenting a system</li><li>Is the system architecture horizontally scalable?</li><li>How do you decouple your services?</li><li>What jobs/tasks/operations are handled asynchronously?</li><li>How do you handle sync-async transitions when users (synchronous web requests) encounter those asynchronous tasks?</li><li>How do you assess good vs bad architecture?</li></ul><h3>Development methodology</h3><ul><li>How does are requirements identified and managed?</li><li>Who performs business analysis and what level of domain knowledge do they have?</li><li>How is change managed, who originates a ‘change’ and tracks it?</li><li>What does knowledge management mean to you team?</li><li>Ticket management</li></ul><h3>Incident management</h3><ul><li>How are incidents managed?</li><li>Do you perform retrospective analysis (or RCA) on incidents?</li><li>Do you rate the severity of each incident?</li><li>What response times do you aim to hit for an incident? How do these vary by severity?</li><li>What is your service Recovery Point Object (RPO, how old can the data be from the backups)?</li><li>What is your service Recovery Time Object (RTO, how quickly can you recover from a disaster)?</li><li>Is your incident management process linked to your Security Log Analysis and Data Integrity Management/data breach detection processes?</li></ul><h3>Governance</h3><ul><li>How empowered are your architects, developers, testers and other engineers to make technical decisions?</li><li>What kind of governance process exists to manage technical decision making?</li><li>How are decisions evaluated, logged and disseminated?</li><li>Who is responsible for assessing the business impact of technical decisions?</li></ul><h3>General Data Protection Regulation (GDPR)</h3><h3>Storage</h3><ul><li>Where and how is your data stored?</li><li>If you store backups, where and how are they stored?</li><li>How is data encrypted in-transit and at-rest?</li></ul><h3>Data privacy and consent</h3><ul><li>What types of data are being captured and which of these is kept?</li><li>How do you identify personal data?</li><li>Have you included in your data management processes all employee data too?</li><li>How long is the personal data retained for?</li><li>Do you maintain a clear set of terms and conditions that cover data privacy? How often is this reviewed?</li><li>Do you have a log of when each user accepted those terms, by version?</li><li>What provision do you make for users requesting access to their data?</li><li>What provision do you make for users to request the removal of their data?</li><li>Do you follow privacy-by-design, and if so how does that relate to your Governance and Software Architecture processes?</li><li>Do you have data on children? How do you verify their age and get guardian approval?</li></ul><h3>Data controls</h3><ul><li>Who is authorised to view/edit/delete the data?</li><li>What physical safeguards exist to limit that access to those who are authorised?</li><li>What virtual/digital safeguards exist to limit that access to authorised users?</li><li>Who is the Data Controller and the Data Protection Officer?</li><li>Who is responsible in the organisation for GDPR regulations and compliance?</li><li>Can you provide a document to clearly explain all data flows and touch points with your systems or staff?</li></ul><h3>Outsourcing</h3><ul><li>Do you maintain a current list of the outsourcers and partner who collect, manage, process or in some other way have access to data on your behalf?</li><li>Does this list include all the Cloud services your staff use on a daily basis?</li><li>Do you have a clear understanding of their policies and procedures for handling data?</li><li>How do you handle shadow IT (services that are used without being run/managed by your central IT function)?</li><li>How do you manage staff training around your IT systems and their regulatory or compliance obligations?</li></ul><h3>Breaches</h3><ul><li>What mechanisms do you have in place to detect data breaches?</li><li>Do you have a communication plan in place to enact in the event of a data breach?</li></ul><h3>Payment Card Industry Data Security Standard (PCI DSS)</h3><h3>Scope</h3><ul><li>Does the service interact in any way with card payment processing?</li><li>Does it control how consumers are redirected to a validated third-party service provider?</li><li>Have you reviewed the relevant Self-Assessment Questionnaire (SAQ) for PCI compliance?</li><li>Do you already know which SAQ classification you fall into:</li><li><a href="https://www.pcisecuritystandards.org/documents/SAQ_A_v3.pdf">SAQ A</a>. Card-not-present, all cardholder data functions are fully outsourced</li><li><a href="https://www.pcisecuritystandards.org/documents/SAQ_A-EP_v3.pdf">SAQ A-EP</a>. Partially outsourced eCommerce using a third-party website for payment processing</li><li>SAQ B. Imprint or standalone machines (including B-IP and P2PE), no electronic cardholder data storage (not applicable to eCommerce channels).</li><li>SAQ C. Payment Application Systems connected to the Internet or Web-based virtual terminals (C-VT), no electronic cardholder data storage (not applicable to eCommerce channels).</li><li><a href="https://www.pcisecuritystandards.org/documents/SAQ_D_v3_Merchant.pdf">SAQ D</a>. All other merchants/service providers</li></ul><h3>Third-parties</h3><ul><li>How do you manage service providers with whom cardholder data is shared/made accessible?</li><li>What legal documentation do you maintain with/for them?</li><li>How do you engage them? What due diligence do you conduct?</li><li>How do you monitor their compliance? (e.g. annual assessment)</li><li>How do you distribute your PCI DSS requirements across those service providers?</li></ul><h3>Payment pages</h3><p>Choosing between SAQ A and SAQ A-EP can be difficult, but there is help in the <a href="https://www.pcisecuritystandards.org/documents/Understanding_SAQs_PCI_DSS_v3.pdf">Understanding SAQs</a> guidance.</p><ul><li>Is there any program or application code that does or <em>could</em> capture payment information? (e.g. javascript on payment pages)</li><li>Do all elements of payment pages originate from the third-party service provider?</li><li>How does the system link to or embed the third-party payment processing service provider?</li><li>How and where is the payment form created?</li></ul><h3>Cardholder data</h3><ul><li>Do you store any cardholder data, such as Primary Account Number (PAN), expiration date, cardholder name or CV2?</li><li>If so, do you store it electronically or in hardcopy? Name all the places where this data is stored.</li><li>Do you receive any reports or receipts featuring cardholder data?</li><li>For each physical data storage location:</li><li>How are the media secured?</li><li>How do you restrict physical access to the media?</li><li>How is distribution controlled?</li><li>How is the media classified, transmitted, approved for access or transmission, destroyed after use, stored prior to destruction etc.?</li><li>For each electronic storage location (including storage locations managed by a third-party service provider):</li><li>How do you define the Cardholder Data Environment (CDE)?</li><li>If hosted on a non-networked computer, how is the host machine isolated?</li><li>If hosted on a networked computer, how is the network segmented?</li><li>If hosted by a networked third-party:</li><li>How is your office network segmented?</li><li>How is the system segmented from the third-party service provider?</li></ul><h3>Staff access</h3><ul><li>Which employees have access to cardholder data?</li><li>What audit process wraps their access to it?</li><li>What credentials are required for their access?</li><li>How are those credentials secured (e.g. password requirements)? How and when are they rotated?</li><li>Do you have a policy that covers information security?</li><li>How often are staff trained in information security and how is that logged?</li></ul><h3>SAQ A</h3><ul><li>How do you meet the SAQ A requirements?</li><li>9. Restrict physical access to cardholder data</li><li>12. Maintain a policy that addresses information security for all personnel?</li></ul><h3>SAQ A-EP and SAQ D</h3><ul><li>In addition to SAQ A above, how do you meet the SAQ A-EP/D requirements?</li><li>1. Install and maintain a firewall configuration to protect data</li><li>2. Do not use vendor-supplied defaults for system passwords and other security parameters</li><li>3. Protect stored cardholder data</li><li>4. Encrypt transmission of cardholder data across open, public networks</li><li>5. Protect all systems against malware and regularly update anti-virus software or programs</li><li>6. Develop and maintain secure systems and applications</li><li>7. Restrict access to cardholder data by business need to know</li><li>8. Identify and authenticate access to system components</li><li>10. Track and monitor all access to network resources and cardholder data</li><li>11. Regularly test security systems and processes</li></ul><p>There is no substitute for a thorough compliance assessment against GDPR and PCI DSS conducted by a Qualified Security Assessor (QSA), but these questions are a useful indicator of a business’s readiness. Any formal PCI assessment should begin with the <a href="https://www.pcisecuritystandards.org/documents/SAQ_InstrGuidelines_v3-1.pdf">PCI DSS Self-assessment questionnaire</a>.</p><h3>Code review</h3><h3>Standards</h3><ul><li>Do you provide any recommendations, guidelines or rigid technical standards to your development teams?</li><li>What Key Performance Indicators (KPIs) do you monitor for the technical team’s output?</li></ul><h3>Software architecture</h3><ul><li>Who decides the distribution of functional responsibility across the code?</li><li>How are those design decision disseminated?</li><li>What design patterns are used in the code?</li><li>How do you ensure consistency of approach in a multi-developer team?</li></ul><h3>Secure coding practices</h3><ul><li>How are dependencies handled?</li><li>What kind of scanning do you use?</li><li>What is your policy on input sanitisation (SQL injection, XSS) and form forgeries (CSRF)?</li><li>How do you treat authentication (including any tokens) and authorisation (including privilege escalation)?</li><li>Do you treat input from the database as potentially hostile?</li></ul><h3>Logging</h3><ul><li>What log-levels does the code issue messages at?</li><li>How verbose and accurate are those messages at each level?</li><li>How relevant are the messages, specifically in relation to user journeys, tests, documented requirements, operation needs?</li></ul><h3>Test coverage</h3><ul><li>What level of unit test coverage is acceptable?</li><li>What is the current level of test coverage?</li><li>Do you practice test-driven development?</li><li>What is the balance between unit tests and integration tests?</li><li>Who performs system testing?</li><li>How are user acceptance tests written and executed and by whom?</li></ul><h3>Documentation</h3><ul><li>What standards do you enforce around commenting?</li><li>What value do you ascribe to doc blocks or inline comments?</li><li>What documentation do you maintain and how does that link to the source?</li><li>Tabs or spaces? (Only kidding)</li></ul><p><em>Originally published at </em><a href="https://www.lightenna.com/tech/2018/web-service-review-and-cloud-audit/"><em>www.lightenna.com</em></a><em> on October 2, 2018.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ebb791a57944" width="1" height="1" alt=""><hr><p><a href="https://medium.com/lightenna/web-service-review-and-cloud-audit-ebb791a57944">Web service review and Cloud audit</a> was originally published in <a href="https://medium.com/lightenna">Lightenna</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Tell me what you’ve got, what you’ve really really got]]></title>
            <link>https://medium.com/lightenna/tell-me-what-youve-got-what-you-ve-really-really-got-522ba84c7cc8?source=rss----9107dcf5095d---4</link>
            <guid isPermaLink="false">https://medium.com/p/522ba84c7cc8</guid>
            <category><![CDATA[due-diligence]]></category>
            <category><![CDATA[web-services]]></category>
            <category><![CDATA[web-audit]]></category>
            <category><![CDATA[technical-debt]]></category>
            <dc:creator><![CDATA[Alex Stanhope]]></dc:creator>
            <pubDate>Fri, 30 Nov 2018 20:12:53 GMT</pubDate>
            <atom:updated>2018-11-30T20:12:53.813Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cuyWGW0x3gwbD9-sT-0Ogw.jpeg" /></figure><blockquote>Whether you’ve got a web site, web service or full web business, understanding where it’s at requires a clear view of where it’s headed.</blockquote><p>Websites vary hugely in scale and aspiration. One might offer basic product information and contact details to an audience of a few dozen, another may process thousands of page requests each second.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FXXvINMz8cCQ%3Ffeature%3Doembed&amp;url=http%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DXXvINMz8cCQ&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FXXvINMz8cCQ%2Fhqdefault.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/d1a410207d6b3ed6e6a063ef81b03acb/href">https://medium.com/media/d1a410207d6b3ed6e6a063ef81b03acb/href</a></iframe><p>Value is a completely independent axis. Those few dozen customers may represent 90% of the revenue to an enterprise, whereas a high-traffic advertising-driven site may value its users in fractions of a cent. The common element is the web service itself.</p><p>Each of these web services has a value to the organisation that owns it. They’re both figuratively and literally invested in the quality of that service and its success.</p><p>If you’re reading this, chances are that you have some kind of stake in some kind of web service.</p><h3>What you call it</h3><ul><li>Software</li><li>Server</li><li>Somewhere</li><li>Someone</li></ul><p>I’m using the term ‘web service’ to describe this group of disparate web properties because whether whatever it does, there is some <em>software</em> that sits on a <em>server</em>, <em>somewhere</em> and it delivers a <em>service</em> to <em>someone</em>. And hopefully it represents some kind of value to them.</p><h3>What’s it worth?</h3><ul><li>Why price it</li><li>Cost vs return</li><li>Analysing growth</li></ul><p>Understanding that value is itself important. If you’re making or seeking investment to grow your business, most future investment will seek to understand the present value. If you want to sell it, or buy another one, that transaction needs a price.</p><p>Similarly if your company is about to refresh the web service, it helps to think about that as an explicit investment (of time, money or other resources) to yield a return. The return may be indirect or non-financial, but quantifying and measuring the value is essential. Otherwise, why invest?</p><p>Most businesses work to maximise the value of their web services, irrespective of how they intend to seek it.</p><h3>Value determinant</h3><ul><li>Func and non-func</li><li>Users</li><li>People and processes</li><li>(…also software)</li></ul><p>What the web service does is an important part of its value, but it’s the non-functional properties that create value.</p><p>Things like the reach of the service, it’s presence in search engines, the profile of user interactions, the richness of their experience matters. These factors are contingent upon more than whether it works, in one use case, for one person, in one moment.</p><p>How it was built is almost as important as its current functionality. Think about the people who built the service, the knowledge they gleaned during development and the processes they adopted to run it. How much of this is written down in an accessible way versus stored only in someone’s head. What if they leave?</p><h3>Questions</h3><ul><li>Performance</li><li>Security</li><li>Compliance</li><li>Extensibility</li><li>Robustness</li></ul><p>How well is it going to perform in production? How likely is it to get hacked and what would that cost the business? Does it conform to legislation like <a href="https://eugdpr.org/">GDPR</a> or information security standards like <a href="https://www.pcisecuritystandards.org/pci_security/">PCI DSS</a>? Can it be maintained and handle failures? These are the questions that drive an IT audit with a view to understanding the whole of an asset, not just some small part.</p><h3>Evidence, not hand-waving</h3><p>It’s quite easy to answer some of these questions with hand waving, but the challenge is to provide <em>evidence</em>. The web audit process is really just about assembling that evidence and identifying short-falls.</p><h3>Future</h3><ul><li>Proving the future</li><li>Experience</li><li>Shortcomings are good</li><li>Tech debt</li></ul><p>How can we prove that this system is going to extensible in the future? The best evidence is a design that’s based on reuse and refactoring. Philosopically, the only methodology I’ve ever seen work efficiently, at scale and over a sustained time period is test-and-learn: stop throwing things away; never start again from scratch; iterate.</p><p>If the team can demonstrate that they’ve done something before, great. If not, can they prove that they’re robustly following a development methodology that’s worked for other teams in similar situations before?</p><p>The best audit yields a shopping-list of stuff that’s:</p><ul><li>not been thought about yet/designed</li><li>not been done</li><li>been only partly done</li><li>been done deliberately badly</li></ul><p>None of those shortcomings are bad. Every web service has technical debt. It’s a consequence of expedient decision-making and it’s fundamentally a good thing, if managed.</p><p>Technical debt for a web service tends to take the form of development work that <em>could</em> have been done before, but wasn’t because other things were prioritised. It’s actually really healthy but you might ask why. The answer is risk (but that’ll be another blog post).</p><h3>Free</h3><ul><li>Audit checklist</li><li>Major headings</li><li>Identify scope</li><li>Successful services</li></ul><p>The web audit process doesn’t have to be intimidating. We publish a <a href="https://www.lightenna.com/tech/2018/web-service-review-and-cloud-audit/">free list of questions to inform your audit</a>. They’re free and open-source.</p><p>The aim of these questions is to help teams think around a web service, not just about what it does.</p><p><em>Originally published at </em><a href="https://www.lightenna.com/tech/2018/web-audit-spice/"><em>www.lightenna.com</em></a><em> on November 14, 2018.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=522ba84c7cc8" width="1" height="1" alt=""><hr><p><a href="https://medium.com/lightenna/tell-me-what-youve-got-what-you-ve-really-really-got-522ba84c7cc8">Tell me what you’ve got, what you’ve really really got</a> was originally published in <a href="https://medium.com/lightenna">Lightenna</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>