AI Governance

Greetings!

Governance of how an organisation uses AI will be a key factor in how much value/benefit can be realised in the future.

As AI becomes increasingly present in our everyday lives, both at work and at home, more domestic and international governments will attempt to exert control through legislation and regulatory standards.

This will naturally lead to organisations needing to understand, in-depth, how they are using AI and what data sources/structures are being used so they can monitor, manage and maintain compliance with all of the applicable statutes and industry best practices.

Areas that will need careful consideration include the following.

Business case/usage

A clear idea of what AI can and cannot be used for should be established. This should establish firm use cases and decision trees that teams within the organisation can follow if they want to implement AI to tackle specific scenarios.

Intellectual property

An organisations IP must be protected to ensure that, through the use of AI, whether public platform or internet connected private platform, it isn’t exposed to the threat of theft or loss.

Legislative compliance

The introduction of new legislation, such as the EU AI Act, organisations have new statutory obligations to meet or face significant fines and damage to their reputation.

Organisational culture/Skills evolution

At this stage, AI introduces new and exciting, tools that are lauded as being able to improve an organisation’s productivity by percentages that have not been achieved since the Industrial Revolution. However, picking up a spanner doesn’t automatically make me a mechanic! Therefore, an organisation needs to define, implement and continually refresh its culture to ensure that its resources make effective use of these new tools and that the expected Return On Investment is achieved.

An organisations ITSM capability will need to be at the core of this, ensuring that the appropriate strategies and plans are in place to enable business AI agility whilst robustly managing the associated risks.

“But how?!”, I hear you cry…. Well here are some of my thoughts on the subject.

Robust enterprise architecture to provide

architectural patterns and reusable technology stacks, that evolve with business needs and technology improvements

enterprise management solutions that can manage, monitor, alert, and report on the organisations AI solutions

automated and integrated tracking of key data assets that underpin an organisations AI implementation e.g. Large Language Models

Adhere through the use of policy and process controls designed to meet the regulatory requirements of the geographies that the organisation operates in.

Effective audit and reporting capabilities that can analyse information, in real-time, and facilitate escalations, as appropriate, within the organisation so that risks can be managed. The more this can be automated, possibly with the use of AI for analysis, the more robust this will be.

Enforce policies, at the operational and technology levels, to control

usage (appropriate and inappropriate)

data separation to safeguard company intellectual property

user access controls

Invest in the skills of your team, and encourage experimentation with new technologies. AI is growing at an unprecedented pace and so organisations must adapt quickly to meet business demands.

In summary, ITSM capabilities must embrace the organisations use of AI and provide guidance and guardrails. How fast they can evolve with business needs will have a significant impact on the organisations ability to manage risks and realise value from AI.

Hopefully this has been useful to you and I wish you well on your ITSM journey…

Config Management Database (CMDB)

Greetings!

In this weeks article I will be talking about the concept of a Configuration Management Database (CMDB) and whether it is still relevant in today’s fast paced I.T. world.

## What is a CMDB?

A CMDB is, in essence, the main tool that the Service Asset & Configuration Management function uses to track the state of “stuff”. In the context of an I.T. service “stuff” is anything that the services needs to manage and control the state of in order to be able meet its obligations e.g. levels of service, compliance requirements etc.

Commonly each instance of “stuff” is referred to as a Configuration Item (CI), at least in the world of ITIL&reg;, and has a number of attributes against which pertinent information is stored. For example, the CI record, in a CMDB, for a laptop may hold the following information; 

- Make
- Model
- Warranty Status
- Operating System
- Assigned Owner
- Related Cost Centre
- Previous Incidents
- etc

This information can all be useful to various roles and functions within an I.T. service, for example;

- Operating System - can be used by Technical Management to know which devices to patch with what updates
- Related Cost Centre - can be used by Financial Management for cross charging
- Previous Incidents - may be useful to the Service Desk when trying to diagnose a  reported issue

Now all of this information is undoubtedly useful, but does it all need to be kept in (and typically manually replicated into) a monolithic CMDB?

## Is there a better way?

Better, in a sense of being more efficient, and less prone to human error? Absolutely! In the following sections I will expand upon this and describe the options in a toolset agnostic way.

### Federation

![Federated CMDB!](https://res.cloudinary.com/xenos-design/image/upload/v1689867576/ITSM/CMDB_Federation_zybvzx.png)

The federation model is where the base minimum of data is held in the CMDB to enable ITSM processes but, when further information is required, it points to the single source of truth for that data type. 

The guiding principle is here “Right data, right place and only accessible by those who need it, when they need it”.

This model is my preference when there is a complex service environment spanning multiple delivery models and architectures.

### Integration

![Integrated CMDB!](https://res.cloudinary.com/xenos-design/image/upload/v1689867576/ITSM/CMDB_Integration_p9lipe.png)

The integration model is where the various primary data sources,  that underpin delivery of your service(s), feed into your central CMDB (typically within your ITSM toolset).

Automation is the underpinning point here. This approach can work well where integrations have been proven to work, and most leading ITSM tools will come with standard integration with other leading tools, but I am always conscious that anything new requires time and will undoubtedly need iteration to get it right.

## Conclusion

The CMDB still has an important part to play in delivering and controlling services to ensure consistency and quality.

However, the days of the CMDB being deployed as a single entity, and source of truth for everything, should be reconciled to the past.  Instead consideration should be given to who really needs the information and how that information visibility requirement should be met.

Hopefully this has been useful to you and I wish you well on your ITSM journey…

Inside an XLA


Greetings!

This week we will be diving deeper into what an XLA (eXperience Level Agreement) should be and look at some examples.

If you are not familiar with XLAs then my previous article XLAs - avoiding watermelons give a useful introduction.

An XLA is a combination of objective and subjective measures that give you a balanced measurement of the impact of the service, with a weighting towards how the “users” experience the service. So let’s look at some examples of what that means in reality.

Balanced Measurement

Objective and Subjective

An objective measure is based on data derived, usually, from the systems or toolsets that are used to manage either ITSM processes, e.g. Incident Management tools, or IT systems, e.g. Application Performance Management.

The objective measures, that help to make up an XLA, are important because they bring context and meaning to the subjective measures.

For example, if you have an XLA that is measuring user satisfaction with your Service Desk, then objectively measuring the number of contacts with the Service Desk gives context.

The context is important because if your subjective result shows 50 negative responses then this sounds, on the face of it, to be a bad thing. Now this result is never a “good” thing but, when taken into the context of 20,000 contacts in the Service Desk in a measurement period, thus meaning a 0.25% negative response, it doesn’t sound so bad.

But, is this really an accurate measure?

Again the answer revolves around context. If 20,000 contacts result in 20,000 survey responses, your subjective source, then this could well be a valid measurement. However, this is unlikely to be the case.

So, another objective measure would be the number of survey responses received in your measurement period. For the sake of novelty let’s say you get 420 completed surveys. Now this changes your perspective quite significantly.

Your original 0.25% becomes 11.9%, which is quite a dramatic change and suddenly things don’t seem quite so good.

However, what cannot be emphasised enough is that XLAs are for driving improvement in areas that are important to the business to that the service(s) are being delivered.

An XLA is neither a carrot to reward a service provider, nor is it a stick with which to beat one. An XLA is a point on the horizon that both customer and supplier are walking towards together. The measurement points are simply there to identify whether they are walking forwards, standing still or are walking backwards.

Source: Steven Godson

So, what we have, so far, is a number of objective measurements, which are as follows.

Total contacts to a Service Desk

Total number of survey results and as a % of total contacts

Total number of positive/negative survey responses and their respective percentages

So, what’s next? Well, the next thing is to define what good” actually looks like in your context and ensure balance in your results.

What is “good” anyway?

What good means, in the context of XLAs, will greatly depend on what you are using XLA measurements to achieve.

However, it is true to say that whatever it is there needs to be acknowledgement that the target chosen should be realistic and is a target to be worked towards rather than there being an expectation that it will be achieved from day one.

It is also sensible to apply a balanced approach to reporting the measures that combine to give the overall XLA measure. A pragmatic way to do this is to apply weighting to each of the component measures based on their importance/significance. The weighting is a % split across the number of measures you are using to calculate your XLA score.

For example, if you are working towards users adopting self-service and digital channels, your XLA measurement may look like this.

Weighting % - this weighting allows you to apply a balanced, business-focused, view whilst maintaining transparency

Metric - the objective and subjective numbers captured in the reporting periods

eXperience Performance Indicator - the XPIs expressed as a % of the relevant total

XLA Score - the weighting applied to the XPI

XLA achievement - the figure that you would be reporting for the given measurement period

The examples of what an XLA could be used to measure are;

Gauging the impact of a new supplier or service, so that improvements can be identified

Measuring the end-user experience (UX) for one or more applications, as long as there is a subjective element to the measurement

Impact of a change program

Summary

In this article, I have talked about what makes up an XLA, and the mindset required, and provided a real-life example. Hopefully, this article has been of some use and has given you a good idea of the types of areas that need to be addressed.

I wish you well on your ITSM journey…

Adding Latest posts…


Greetings!

In this post we will be building on the site created in the first two articles, and demonstrating the benefit of having re-usable components, to add your latest *Posts* to your home page.

## Steps 1 - Get the correct data

Open your *./pages/index.js* file and add the following to the end of the file.

```jsx
export async function getStaticProps() {
	// fetches all the post data from your published article folder
    const webpackContext = require.context('../posts', true, /\.\/.*\.md$/);
    // console.log('webpackContext', webpackContext.keys())

    // the list of file names contained inside the "posts" directory
    const keys = webpackContext.keys();

	// reverse the array of posts so the newest one is first
    const reverseKeys = keys.reverse();
    // console.log('keys', keys)

    const values = reverseKeys.map(webpackContext);
    // console.log('values', values)

    // getting the post data from the files contained in the "posts" folder
    const posts = reverseKeys.map((key, index) => {
        // dynamically creating the post slug from the file name
        const slug = key
            .replace(/^.*[\\\/]/, '')
            .split('.')
            .slice(0, -1)
            .join('.');

        // console.log('slug', slug)
        // getting the .md file value associated with the current file name
        const value = values[index];
        // console.log('value', value)

        // parsing the YAML metadata and markdown body contained in the .md file
        const document = matter(value.default);
        // console.log('document', document.data)

        return {
            frontmatter: document.data,
            markdownBody: document.content,
            slug,
        };
    });
    // console.log('posts', posts);

	// cut the list of posts down to the first 4 in the array e.g. the latest 4 
    const topPosts = posts.slice(0, 4);
    // console.log('topPosts', topPosts)

	// export the data for the 4 latest posts
    return {
        props: {
            latestPosts: topPosts,
        },
    };
}
```

If you encounter issues I recommend using the console logs, already written in, to see where the issues are.

Assuming there are no errors you are now ready to move on to Step 2.

## Step 2 - Use the data

Now that you have the data for the posts, that you want displayed, it can be used to display on your home page.

There are only a few changes required to do this which are shown in the following code.

```jsx
import Head from 'next/head';
import Image from 'next/image';
import Layout from '../components/Layout';
import Introduction from '../components/Introduction';
import AnimatedSplash from '../components/AnimatedSplash';
// Change 1 - import the BlogList component, if not already done
import BlogList from '../components/BlogList';
import Contact from '../components/Contact';
import styles from '@/styles/Home.module.css';
// Change 2 - import grey-matter
import matter from 'gray-matter';

// Change 3 - change "props" to "latestPosts" to directly access the export data from Step 1
export default function Home({ latestPosts }) {
    return (
        <Layout>
            <Introduction />
            <AnimatedSplash />
			// Change 4 - add the BlogList component and pass in latestPosts
			// consider adding a heading before the component
            <BlogList allBlogs={latestPosts} />
            <Contact />
        </Layout>
    );
}
```

## Step 3 - View the data

Now that we have got the correct data, and passed it into the correct component, we are ready to see the result.

- Navigate to the *root* folder of your project
- Run `npm run dev`
- Now go to [http://localhost:3000](http://localhost:3000) in your browser

You should now see something like the following.

![Latest Posts!](https://res.cloudinary.com/xenos-design/image/upload/v1690470282/Post_Content/nextjs-md-latestPosts/latestPosts_kmlyxv.png)

And that’s it for now… you have now updated your blogging site, using Next’s and Markdown, and enhanced the experience of your readers. Hopefully, you found this article useful and will continue your journey.

Thanks for stopping by…

ITSM and DevOps

Greetings!

In this week's article, I will be talking about how ITSM can co-exist with DevOps so that the ITSM teams are not seen as blockers and the DevOps team(s) are not seen as “chaos monkeys”.

This can be achieved through two fronts;

1. Culture
2. Understanding and agreeing on the touch points

## Culture

It is easy to say that a good working culture, within an organisation, leads to better interworking between departments and the teams within them. But what does that mean in practical terms when you are aspiring to get ITSM and DevOps working together?

In my experience, this means addressing the following areas, in a program of change that is sponsored from the top but driven from the bottom up.

- Open and respectful dialogue - so that issues can be raised and ideas discussed
- Willingness to change - adopting a one-team approach
- Continual improvement mindset - striving to do better

## Touchpoints

The below diagram is my view on where the key touch points are between ITSM and DevOps as models. I have deliberately used ITIL terminology for the ITSM side, mainly because it is widely used around the globe.

![DevOps and ITSM!](https://res.cloudinary.com/xenos-design/image/upload/v1687544857/ITSM/ITSM_and_DevOps_Interaction_n60p55.png)

### Ticket Creation / Update / Resolve

- The resolution of an Incident or Problem may require the DevOps team so, unless it is critical, it would need to be cross logged onto the appropriate Product Backlog
- A Service Request could be a conduit for “asks” being raised onto a Product Backlog
- Depending on how rigorously the deployment of Release Packages to the production environments is controlled, the DevOps team will be raising Operational Request for Changes (RFCs) to get approval to deploy. This can be seen as a bottleneck that restricts business agility, so consideration must be given to;
	- Agreement on what can be automatically approved based on specific criteria being met i.e. tests passing
	- Pre-agreed windows for deployment

### Authorisation

The Operational Change Management process will provide authorisation to deploy based on what criteria is either defined in the Change Management policy document or as agreed operationally for each Product. 

The key to this is finding the appropriate balance between the business's needs;
	- frequency and rapidity of change
	- ensuring that users / customers, depending on your business environment, do not suffer from change fatigue
	- maintaining the required levels of service availability
	- minimising risks

### Pre/Post Baseline Report

The SACM (Service Asset and Configuration Management) team is responsible for ensuring that there is accuracy in the configuration of the service(s). 

The DevOps team relies on this information to;

- know what *good* looks like, so they can restore the service back to its baseline configurations in the event of an Incident
- identify what might be impacted as a result of planned changes

The typical advice, which I broadly agree with, is to use a CMDB (Configuration Management Database)  to hold this data. 

My view on this is that a CMDB should be seen as a collection of federated data / information repositories that are specific to the type of data / information that is being managed e.g. a Software Configuration Manager tool (CICD pipeline or Github etc) or Wiki / Knowledge Articles (ITSM tool, Gitbook, Confluence).

### Knowledge Share

This touchpoint is important to ensure that changes to the service(s) are understood by the Service Desk, and other support tiers, so that they know what to do when an Incident occurs or a user phones up to query something.

It is also important from a user perspective so that they;

- know what has changed and what, if anything, that change means to them
- can access self-service knowledge to resolve issues themselves

The DevOps team also needs a flow of knowledge not them so that they can understand;

- whether the knowledge that they are providing is actually of use
- how users are reacting to the visible changes that are being made

## Summary
In this article, I have described the key touchpoints between ITSM and DevOps and why they are important. Hopefully, this article has been of some use and has given you a good idea of the types of areas that need to be addressed.

I wish you well on your ITSM journey…

Service Design Package

Greetings!

In this article I will be exploring the concept of the Service Design Package, what it should be and what should be included within its scope.

## What is a Service Design Package?
Service Design Package, abbreviated to SDP, is a term that initially appeared in ITL&reg; v3 which was first published in 2007, is a collection (the package part) of documents and artefacts that describes;  

- Scope - what a service is
- Users / Location - who it can be consumed by
- Compliance - the business, regulatory and statutory constraints that it has to exist within
- Requirements - the warranty, utility, quality and satisfaction characteristics that it has to meet
- Processes - that will be used to manage the service on a day to day basis
- Products - the tools that will be used to deliver the service. This includes everything from SaaS solutions through to bespoke applications
- Partners - the sub-contractors you use to deliver parts of the service
- People - the individual roles and functions that will govern and manage all of the above

> “Good service starts, and ends, with having great people..”. Source: me

## What should it be?
An SDP should be the definitive source of information for anyone requiring an understanding on what a service should deliver and how it delivers that service.

It should provide different views so that it can be used by different stakeholders with different perspectives.

It should be useable, accessible and written in plain English (or whichever language is relevant).

It should be a number of complimentary, and not over lapping, documents that are regularly reviewed and maintained to ensure currency.

## What should be included within an SDP?
The following is based on my years of experience of designing and building ITSM solutions as part of a Managed Services provider. 

Depending on your situation e.g. internal servicer provider (“The IT department”) or a Managed Service provider (external organisation to the one buying the services), you may consider some of these to not be relevant.

And, depending on your situation, you may be correct. However, all of the following areas should at least be considered when creating an SDP.

### Service Description - the what and the when…

A Service Description is the shiny document that, depending on your scenario, your customers and / or users will read to understand what the service is that they are consuming / paying for.

The common scenarios under which these tend to exist are;

- Contractual Service Description - part of a customer / supplier legal agreement where what is being delivered needs to be concise
- Service Catalogue (Public) - part of your businesses website / marketing collateral where you describe the services you offer
- Service Catalogue (Internal) - the portal where your internal IT department lists the services that users get as standard or that can be ordered

However, there is a common set of information, described below, that a Service Description should cover.

SCOPE - this is where you clearly describe what the service is and what it will, and as importantly will not (exclusions), delivers.

SERVICE LEVELS & PATTERNS - this is the level of service that a consumer should expect to receive and when the service will be available to them.

GOVERNANCE - how the service will be governed, who the key points of escalation are and what the measurement periods will be.

CHARGES - inescapable, but possibly less relevant in an internal IT department setting, how much the customer will pay for the service(s) that you are describing is important.

### Service Management Design - the how and tho who…

A Service Management Design (or Architecture or Blueprint or…) is the document where you describe how the service is going to be put together to deliver the service.

It covers the various building blocks needed, and how they interact, to deliver the service(s) covered by the SDP.

Typically, in no particular order, this includes;

SCOPE - this is where you clearly describe what the service is and what it will, and as importantly will not (exclusions), delivers.

RCTM - the Requirements Capture and Traceability Matrix where all the requirements that the service(s) need to meet are captured.

COMPLIANCE - the legislative, regulatory and industry standards that the service(s) need to comply with. Examples include ISO20k, ISO27001, Payment Card Industry (PCI) etc

UTILITY / WARRANTY - what the service(s) provide functionally, the *utility*, and when the customer / user can expect the service to be available to them, the *warranty* or Service Levels.

PROCESSES - the ITSM processes that need to be used for the service(s), whether there is any “localisation” needed or whether bespoke processes are needed.

TOOLSETS - the shiny toys that the service and support functions will use to underpin the ITSM process and technical activities required to manage the service. Given the availability or relatively mature and emergent technologies, the following should be considered;

- Integration
- Robotic Process Automation
- Artificial Intelligence
- Augmented and Virtual Reality
- Smart Locker / Vending solutions
- Self-healing systems

DATA MAP - crucial to both understanding where the data that will feed into your billing and performance measurement of the service, as well as helping you to understand your position as it relates to data residency and access legislation / regulations.

> Data is like garbage. You’d better know what you are going to do with it before you collect it. - Mark Twain

ROLES & FUNCTIONS - the individual roles and functions, within your organisation, that will perform day to day management or technical support functions to support the service(s). Examples are Service Desk, Security Operations Centre, Service Delivery Manager or Release Management.

PARTNERS / SUPPLIER MANAGEMENT - the third parties, and how they will be managed / governed, they will deliver aspects of the service(s). Thought needs to be given as to how Service Levels will be flowed down to them.

INFORMATION SECURITY - either described separately, or interwoven into all of the above, a description of how Information Security will be managed against the defined Information Security Management System (ISMS).

> It takes 20 years to build a reputation and few minutes of cyber-incident to ruin it. - Stephane Nappo

RAID - the identified Risks, Assumptions, Issues and Dependencies of the service(s), both for the transition to live and ongoing.

TECHNICAL REFERENCE DOCUMENTS - such as…
- Enterprise Architecture
- High Level Designs for Networks, Applications, Infrastructure, Integrations, Enterprise Management, Data Management
- ISMS, Role Based Access Controls etc
- Disaster Recovery, Backup, Recovery and Data Retention 

### Ops Policies, Processes and Procedures

A service can be described beautifully and designed to within an inch of its life but, when the brown and sticky hits the spinning blades, it is the operational processes and procedures, based on well thought out policies, run by well trained people that will see you through. Consideration should be given to…

- Incident, Problem and Event
- Call Handling, Knowledge Articles and escalation management
- Major Incident Management
- Change (Normal, Standard and Emergency), Release, Knowledge and SACM
- Information Security, SIEM, Access Control etc
- Applications Management, Agile and DevOps
- Capacity and Availability
- IT Service Continuity
- Technical Management, Patch Management, On Premise vs Hybrid vs Cloud and Technical Refresh
- Request Catalogue and Fulfilment
- Management Information, Billing and Invoice to Cash
- Continual Service Improvement

## Things to avoid…

Based on my, not inconsiderable experience, try to avoid the following.

- Trying to fit all of the above into a single document, it doesn’t work and creates a monolithic document that no-one, other than insomniacs, will want to read
- Re-inventing the wheel, re-use is awesome and helps to create consistency (as long as it is consistently good!)
- Repetition, say it once and cross reference, where practical. Adopting a Document as Code approach can greatly help with this 

> In our company, we all have 2 jobs: 1) to do our job and 2) to improve it - Toyota

## A final word…

Ultimately the SDP scope you use has to meet the needs of the business environment that you are working in. Hopefully this article has been of some use and has given you a good idea of the types of areas that need to be addressed.

I wish you well on your ITSM journey…

XLAs


Greetings!

This weeks article is dedicated to is XLAs (eXperience Level Agreements) and will answer:

- What are they?
- Should you care?
- How can they be used?

## What is an XLA?
A couple of quotes to start us off…

> XLA is a powerful new addition to the traditional IT Service Level Agreement (SLA). One that builds on the SLA concept by measuring human sentiment and using this to break down silos and think and act from the perspective of a user. 
*Source: [Giarte.com](https://www.giarte.com)*

> Xperience Level Agreement (XLA) is the *concept* of consensus between IT service provider and consumer regarding the desired human experience and business impact.  
> 
> It is also an *agreement* that extends the scope of the output-oriented Service Level Agreement (SLA) to describe the collaboration, experience, and business impact associated with IT services – the outcome. This outcome-oriented document defines the agreed goals, metrics that indicate achievement of the goals, and procedures for collaboration.
*Source: [www.xlaconsortium.com](https://www.xlaconsortium.com)*

In my opinion, both of the above quotes work quite nicely.

An SLA is purely an objective measure based on metrics that are gather from tools (ideally). It should be unimpeachable. 

However, beware of watermelons… which is where your shiny SLA dashboard or report is a field of green, but your customer still isn’t happy! This usually signifies you are not measuring the right things.

An XLA is a combination of objective and subjective measures that give you a balanced measurement of the impact of the service, with a weighting towards how the “users” experiences the service.

## Should you care?
Yes, yes you should… assuming that you are providing a service to a customer  rather than a utility type product that is positioned as being a “service”.

## How can XLAs be used?
XLAs can be used in a number of ways.

- Drive a specific business outcome e.g. adoption of digital channels to drive quicker resolution for users
- Improve the relationship between supplier and consumer by measuring what actually matters to your customers and users
- Gauging the impact of a new supplier or service, so that improvements can be identified
- Measuring the end user experience (UX) for one or more applications, as long as there is a subjective element to the measurement
- Impact of a change programme

The possibilities are varied. The key is having the subjective measure as part of any XLA calculation, ideally captured in a consistent way e.g. using a user survey tool.

However, XLAs should *not* be used as a stick to beat a supplier of services with. Rather they should be entered into as a joint exercise between the Service Provider and Customer to drive improvements.

In future posts I will be diving deeper into this space, so keep an eye open!

Agile Service Management

Greetings!

In this article I will be looking at *Agile Service Management&reg;* (ASM) and how it can be practically implemented. This will be based on the real world experience I gained in my 12 years as a Service Architect.

## What is ASM and where did it come from?

ASM is an approach to developing and maintaining ITSM processes. It was developed by the DevOps Institute&reg; in response to the perception that ITSM can be a blocker to the speed and agility of delivering benefit to the business.

So ASM is essentially using the Scrum, but instead of developing software you are developing processes. The following diagram compares ASM to pure Scrum and identifies key differences in terminology and cadence.

![Agile Service Management!](https://res.cloudinary.com/xenos-design/image/upload/v1687715150/ITSM/ASM_high_level_diagram_v0.1_brkh3d.jpg)

So, as you can see, the key differences are;  

- Scrum Master = Agile Service Manager  
- Product Backlog = Process Backlog (or CSI Register if it is a mature process)
- Product Owner = Process Owner  

## Example Implementation: Developing the Service and Support Model

This example of implementing ASM is where I was working with a client, who were creating a new business application using SCRUM to manage the software development, and there was a need to align the development of the service management and support model in alignment with the sprint planning and cycles.

This new application was going to be supported by a well established and mature support organisation. This meant that I didn’t have to look a standing up new processes, rather that I needed to analyse what needed to be designed and implemented to support the smooth transition from project to live service.

What I ended up with, as an output of the analysis, was a number of *Epics*, spanning the various processes, functions and tools, each of which had a number of high level *User Stories*. 

These *User Stories* were classified as either Enablers, which meant they needed to be completed before further work could be undertaken, or Functional, which were delivering specific elements inline with the delivered output from the software development sprints.

Then I brought all of the key protagonists together for a *Backlog* refinement and initial sprint planning session. This turned out to be invaluable as we were able to refine some needs, re-align others and produce the *Sprint Backlog* for the enabler sprint and the first functional sprint.

These sprints went well, or at least better than I was expecting given how new the approach was to all parties, and the project was delivered successfully. 

The following actions / activities certainly paid dividends;

- Establishing the *Minimum Viable Product* (MVP) is less straight forward in a well established ITSM model than if you are building some thing new, so allow time for this, listen to opinions but never be afraid of challenging the “norm” as, just because something is done in a certain way it doesn’t mean it is the best or most efficient way
- Engaging with the local process owners early on, and taking them through the ASM&asm; approach, and listening to their concerns helped to smooth the path to adoption
- Working closely with the software Product Owners and Solution Architects enabled early identification of challenges and producing collaborative responses 
- Acknowledging that issues arise in live operations, that may require the “service development” teams focus, and allowing a reasonable allowance in the *Sprint Plan* worked well and allowed us to meet expectation
- Stabling the correct routes of escalation, so that blockers can be removed as soon as possible, is essential to maintaining the cadence of the team

## Moving Forwards…

In my opinion the ASM approach can be very useful when you need to deliver and maintain an ITSM model for a software product where SCRUM, or another form of Agile, is used. However, as with any tool, it is not a one size fits all answer, so give serious consideration to the environment in which you want to use it.

I recommend that you go to the [DevOps Institute](https://www.devopsinstitute.com/skilbooks/agile-service-management-guide/) site and read about ASM further. 

If you decide that you want to use ASM then there are a couple of certification courses that you can attend, both developed and licensed by the DevOps Institute.

These are *Certified Agile Service Manager* (CASM) and *Certified Agile Process Owner* (CAPO). I have attended both of these courses, and gained the certifications, and see there is a lot of content that is repeated so attending one or the other, depending on what role you will be in, should be suffiicient to get a good baseline of understanding.

I hope that you found this article useful and I wish you good fortune in your ITSM journey.

An Introduction to ITSM


Greetings!

So, assuming you are relatively new to it, I thought I would give a high level overview of what ITSM is.

ITSM is an acronym, we use a lot of these, for Information Technology Service Management.

Since the early days of I.T. there has been a concept of “managing” the services that customers were buying. Initially this was very limited to support the products (hardware or software) that were purchased and, in my opinion, was very much there to drive additional sales rather then deliver any tangible value beyond that derived from the products.

Towards the end of the 1980’s the Central Computing and Telecommunications Agency, a government department in Great Britain, developed a framework for managing IT infrastructure. This methodology was called ITIL&reg; (IT Infrastructure Library), and was series of books that described how IT could be managed in a consistent way. It is now owned by AXELOS&trade;.

My first introduction to ITIL&reg; was in the late 1990’s / early 2000’s as I moved up the career ladder. At that point ITIL&reg; v2 was out and predominantly focused on two areas Service Delivery (SLAs, BCDR etc) and Service Support. My enduring memory is sitting two very long, and handwritten, exams after 2 weeks of training, which felt quite hellish at the time.

Since then ITIL&reg; has kept evolving with v3 coming out in 2007 and v4, the most recent iteration, coming out in 2019.

One of the things I have always found fascinating in this areas is the continual evolution of how close an “IT Department” should be to its “Customer” from a relationship and goal alignment perspective. Initially coming across as quite standoffish through to being closely interwoven with how the business operates.

Also that ITIL&reg; has never positioned itself as a standard that must be followed to the letter. Rather you _adopt_ the methodology and _adapt_ it to the needs and constraints of your organisation. Thankfully this message has never changed but, what has grown up along side this methodology, are a number of other frameworks and standards, such as:

- _[Microsoft Operations Framework](https://learn.microsoft.com/en-us/previous-versions/tn-archive/cc506049(v=technet.10)?redirectedfrom=MSDN)_ - based on ITIL, that came out in 2008
- _[ISO 20000-1](https://www.iso.org/standard/70636.html)_ - the international standard for IT Service Management. This has been heavily influenced by ITIL evolution over the years and could be considered the hard stick for what “good” looks like
- _[IT4IT](https://www.opengroup.org/it4it)_ - developed by The Open Group&trade; who, among other areas, own the TOGAF framework for Enterprise Architecture (I am a big advocate of this) , this is a architectural model for delivering and managing IT service. There is a lot of crossover, in my opinion, between this and ITIL&reg; v4 which makes them very complimentary
- _[Agile Service Management](https://www.devopsinstitute.com/skilbooks/agile-service-management-guide/)_ - developed by The DevOps Institute, which heavily focuses on service management process development as a “product”. Think scrum for process development and maintenance and you will get the picture.

Now, fascinating as this potted history is, it doesn’t quite answer the question of what ITSM actually is.

One definition of ITSM is

> IT service management (ITSM) is a strategic approach to design, build, deliver, operate, and control information technology (IT) services offered to customers. Source: Wikipedia.

This is an ok, if somewhat dry, statement but misses a fundamental point, which is that IT, as a business function / capability, _MUST_ be aligned with the operational, regulatory and governance needs of the business that it delivers to.

If this isn’t achieved the IT will typically be seen as a “problem child”. Sadly even today, this kind of mis-alignment between the business needs and what the “IT department” thinks it reason for existing is, still exists.

Now when you get into the world of Managed IT Services e.g. those procured by a business from a 3rd party organisation, the original definition is still ok, but there still needs to be that alignment between the _consumer_ and _provider_ of IT services, albeit constrained by the boundaries of a commercial agreement (contract) of some kind.

I will be expanding on some of these areas in future posts.

I will sign-off at this point but watch out for future posts and discussions.



Filtering your Markdown posts


Welcome back!

Following on from my previous post [Create a NextJS blog using Markdown](https://www.stevengodson.com/blog/2023-06-15-nextjs-md-blog), I will now show you how to add Category filtering to your blog so that your ordinance can choose to see all posts of a particular type.

Before we begin you will need to have followed the installation steps in Part 1 of this series

## Key Files

The key files that we will be updating or creating are as follows.

**./components/BlogFiltersCategory.js** - this is the component that will render the interactive filter choices in the ./pages/blog/categories/index.js page.

**./components/BlogFiltersMain.js** - this is the component that will render the interactive filter choices in the ./pages/blog/index.js page.

The above two components are essentially the same apart from the href in the Link element, which points to different places.

**./components/BlogList.js** - this will need to be updated to show the categories against each posts card in the list.

**./pages/blog/categories/index.js** - this is the page that will filter your posts, based on the category selected, and render the list.

**./pages/blog/index.js** - this is the main blog page which will require minor updates to enable the filtering.

**./pages/blog/[slug].js** - this will need to be updated to show the categories against each post.

**./global.css** - This is where the styling for the dynamic components will be added.

The posts themselves will require an update to include the appropriate data into a unique entry against which the filtering can take place.

## Creating your filter
### Post Meta Data

The first thing that we will do is look at the metadata, which is at the front of each post, and amend it from this:

![Meta Data!](https://res.cloudinary.com/xenos-design/image/upload/v1687195278/Post_Content/nextjs-md-filters/001_gvyewg.png)

to this:

![Meta Data!](https://res.cloudinary.com/xenos-design/image/upload/v1687195278/Post_Content/nextjs-md-filters/002_bojc8s.png)

It is worth investing some time to consider what categories you want to use on your posts so that you have as complete a list as possible before we continue.

## Creating new files
Now we will create the new files needed to make this work.
### BlogFiltersMain.js

Create this file in the /.\/components/ folder and copy in the following code.

```jsx
import React from 'react';
import Link from 'next/link';
import Row from 'react-bootstrap/Row';
import Col from 'react-bootstrap/Col';

function BlogFilters() {
    const filters = ['Technology', 'Business', 'Freelancing', 'Personal'];

    return (
        <Row>
            {filters.map((filter, index) => (
                <Col md={6} lg={3} key={index}>
                    <Link href={`./blog/categories?category=${filter}`}>
                        <div className={`filterTag_${filter}`}>{filter}</div>
                    </Link>
                </Col>
            ))}
        </Row>
    );
}

export default BlogFilters;
```

Some key points to explain are:
* I have used /react-bootstrap/ for the row and column control
* There is an array of *strings* in this file, this needs to represent all of the categories that you want to actively use. This has been used in place of a table that would typically be used database or CMS-based blog. To avoid duplication you could store these values in a /.env/ file
* The /href/ in the /Link/ component points to one of the new files, that we will create later in this exercise, and passes in the filter name as a URL query so that it can be picked up from the context using getServerSideProps()
* The className content is also set dynamically with the styling controlled from the /global.css/ file

### BlogFiltersCategory.js

Create this file in the /.\/components/ folder, copy in all of the content from the /BlogFiltersMain.js/ files, and simply change the following.

```jsx
<Link href={`./blog/categories?category=${filter}`}>
	<div className={`filterTag_${filter}`}>{filter}</div>
</Link>
```

to

```jsx
<Link href={`./categories?category=${filter}`}>
	<div className={`filterTag_${filter}`}>{filter}</div>
</Link>
```


### Categories index.js

Now we will create the page where the filtered list will render.

Create the following folder /.\/pages/blog/categories\// and created an *index.js* file.

Now copy in the following code.

```jsx
import React from 'react';
import Link from 'next/link';
import matter from 'gray-matter';
import Layout from '../../../components/Layout';
import BlogList from '../../../components/BlogList';
import BlogFilters from '../../../components/BlogFiltersCategory';
import styles from '../../../styles/Blog.module.css';

function Categories({blogData}) {
    return (
        <Layout>
            <h1 className={styles.heading}>Tales from the deep...</h1>

            <hr />
            <h5 className={styles.heading}>Filter by Category or <Link href="../../blog">Back to Full List</Link></h5>
            <BlogFilters />
            <hr />

            <BlogList allBlogs={blogData} />
        </Layout>
    );
}

export default Categories;

export async function getServerSideProps(context) {

    const { req } = context;
    const passedURL = req.url;
    let filterName = passedURL.split('=');
    filterName = filterName[1];

    const webpackContext = require.context('../../../posts', true, /\.\/.*\.md$/);
    const keys = webpackContext.keys();
    const reverseKeys = keys.reverse();

    const values = reverseKeys.map(webpackContext);

    const posts = reverseKeys.map((key, index) => {
        const slug = key
            .replace(/^.*[\\\/]/, '')
            .split('.')
            .slice(0, -1)
            .join('.');

        const value = values[index];
        const document = matter(value.default);

        return {
            frontmatter: document.data,
            markdownBody: document.content,
            slug,
        };
    });

    const filteredPosts = (posts, filterName) => {
        const data = posts.filter((post) => post.frontmatter.category === filterName);
        return data;
    };

    let data = filteredPosts(posts, filterName);

    return {
        props: {
            blogData: data,
        },
    };
}
```

This file is very similar to the main *index.js* in the ./pages/blog/ folder. 

The key differences are:

* The use of *getServerSideProps* instead of *getStaticProps*. The reason for this is so that we can access the *context* API and pull the filter name that is passed from the filter components. This gets stripped from the request URL and passed into the *filteredPosts* function so the list of all posts can be filtered
* Use of the BlogFiltersCategory.js functionality. This ensures that a user clicking on categories after the initial filter will not be thrown back to the main blog page
* Reuse the BlogList component so there is a consistent look and feel to the site

### global.css

If you want to follow the same styling approach then copy the following into the *./styles/global.css* file.

```css
.tag_Technology,
.tag_Freelancing,
.tag_Personal,
.tag_Business {
    text-align: center;
    background-color: var(--secondary-color);
    color: var(--primary-color);
    padding: 0.2rem 0;
    letter-spacing: 2px;
    font-size: 1.5rem;
}
.tag_Freelancing {
    background-color: #00796b;
}
.tag_Personal {
    background-color: var(--primary-color);
    color: var(--secondary-color);
}
.tag_Business {
    background-color: darkblue;
}

.slugTag_Technology,
.slugTag_Freelancing,
.slugTag_Personal,
.slugTag_Business {
    text-align: center;
    background-color: var(--secondary-color);
    color: var(--primary-color);
    padding: 0.2rem 0;
    letter-spacing: 2px;
    font-size: 1.5rem;
    min-width: 250px;
    border-radius: 5px;
    margin-bottom: 2rem;
}
.slugTag_Freelancing {
    background-color: #00796b;
}
.slugTag_Personal {
    background-color: var(--primary-color);
    color: var(--secondary-color);
}
.slugTag_Business {
    background-color: darkblue;
}

.filterTag_Technology,
.filterTag_Freelancing,
.filterTag_Personal,
.filterTag_Business {
    text-align: center;
    background-color: var(--secondary-color);
    color: var(--primary-color);
    padding: 0.2rem 0;
    letter-spacing: 2px;
    font-size: 1.5rem;
    width: 100%;
    border-radius: 5px;
    margin-bottom: 1rem;
    cursor: pointer;
}
.filterTag_Freelancing {
    background-color: #00796b;
}
.filterTag_Personal {
    background-color: var(--primary-color);
    color: var(--secondary-color);
}
.filterTag_Business {
    background-color: darkblue;
}
```

If you are using another approach e.g. SASS, Bootstrap, or TailwindCSS then you can skip this section.

## Updating the existing document

Now that we have created the new pages and components we can move on to updating the existing pages and components to bring it all together.

### Blog index.js

Update the *./pages/blog/index.js* page to include the *BlogFilterMain.js* component as shown below.

![Blog Index!](https://res.cloudinary.com/xenos-design/image/upload/v1687195278/Post_Content/nextjs-md-filters/003_aonw61.png)

### BlogList.js

Now we update the BlogList component to render out the category name that has been added to a blog. I have done this as a conditional statement but, if you are sure it will always be added, you can add it without the conditional.

![Blog List!](https://res.cloudinary.com/xenos-design/image/upload/v1687248085/Post_Content/nextjs-md-filters/004_ua3j8o.png)

### Blog [slug].js

Finally, we will update the page, where all the content of an individual post is shown, to show the category name as well.

![Blog Slug!](https://res.cloudinary.com/xenos-design/image/upload/v1687195278/Post_Content/nextjs-md-filters/005_lww0os.png)

## Let's fire it up…
We are now ready to run the project and see our content. To do this you simply need to:

* navigate to the root folder in your terminal and run `npm run dev`
* open your browser navigate to *[http://localhost:3000/blog](http://localhost:3000/blog)*

The following should be visible on the screen.

![Working Blog!](https://res.cloudinary.com/xenos-design/image/upload/v1687248198/Post_Content/nextjs-md-filters/006_bagl8o.png)

And that’s it for now… you have now updated your blogging site, using Next’s and Markdown, and enhanced the experience of your readers. Hopefully, you found this article useful and will continue your journey.

In the next post of the series, we will be adding further functionality to your main *index.js* page by adding functionality for * latest posts*.

Thanks for stopping by…


Creating a NextJS blogging website using Markdown


Greetings!

In this article, the first in a series, I will take you through creating your own blogging website using the NextJS framework and Markdown files for the content.

A preview of the site can be seen at [https://nextjs-13-markdown-blog-website.vercel.app/](https://nextjs-13-markdown-blog-website.vercel.app/).

The advantage of this approach versus using a CMS backend e.g. Strapi, Ghost etc, is that you can build and deploy your site using Vercel without incurring any costs.

Being open there are limitations / compromises with this model, which I will talk about later on, but having built many CMS-based sites I like the simplicity of this approach.

## Now, let’s get started!

Firstly, you will need to clone the template repo that I have created for this article. This repo contains all you need to get started.

So create your project folder and navigate to it in a terminal. Then run the following.

```
git clone https://github.com/wookiehunter/nextjs-13-markdown-blog-website.git
```

Once the clone is complete, run the following to install the project's dependencies and start the project.

```
npm install && rpm run dev
```

Then, in your browser, navigate to [http://localhost:3000](http://localhost:3000) and you will be able to see the following front screen.

![NextJS Markdown Blog](https://res.cloudinary.com/xenos-design/image/upload/v1686830042/Post_Content/nextjs-md-blog/001_kne8bm.png)

We are now ready to move on and look at the project folder and file structure.

## Project Structure

If you haven’t already, open the project using your chosen Code Editor / IDE. I use [Visual Studio Code](https://code.visualstudio.com/) for all Node.js/ReactJS projects.

### Folder Structure

The repo that I have provided comes with the following folder structure.

![NextJS Markdown Blog](https://res.cloudinary.com/xenos-design/image/upload/v1686830043/Post_Content/nextjs-md-blog/002_ivlaou.png)

/*Components*/ - this is where the reusable React components will be kept.

/*MD\_Templates*/ - used to store any templates that you want to use to create your content.

/*node\_modules*/ - this doesn’t come with the repo as it is created when you run the `rpm install` command.

/*Pages*/ - this is the folder where you create the structure and pages for your NextJs project.

/*Posts*/ - this is where we will store the Markdown documents that will be used for your blog posts.

/*Public*/ - this is the folder where NextJs needs files that will be presented by your website kept, assuming you are not using separate storage or a CDN, such as images and Favicon files.

/*Styles*/ - CSS files are kept here. I have used CSS module files, but you can use any approach you are comfortable with e.g. Tailwind CSS, SASS, or Bootstrap.

/*Utils*/ - used to store utility functions used by your project. I have included one for Google Analytics as an example.

### Key Files

The key files that we will be focusing on are:

![NextJS Markdown Blog](https://res.cloudinary.com/xenos-design/image/upload/v1686830042/Post_Content/nextjs-md-blog/003_nxeabp.png)

/*Components/BlogList.js*/ - this is the component that will render your list of posts.

/*Pages/blog/\[slug\].js*/ - when you click o a post in your list, this is the page that will control how the post content is displayed.

/*Pages/blog/index.js*/ - this is the page that renders when you click on the Blog navigation link. You don’t need to use this if you want to show all of your posts on your home page pages/index.js

/*Posts/0001-my-first-post.md*/ - example of a post.

/*Next.config.js*/ - we need to add a specific config to this the project works correctly.

## How it works…

### Webpack Configuration

The following needs to be added to the next.config.js file. This allows Webpack to use [raw-loader](_https%3A//www.npmjs.com/package/raw-loader_) on .md files and create the arrays of Posts that you will showcase on your website.

![NextJS Markdown Blog](https://res.cloudinary.com/xenos-design/image/upload/v1686830042/Post_Content/nextjs-md-blog/004_gdpwc7.png)

### Using Markdown to create content

![NextJS Markdown Blog](https://res.cloudinary.com/xenos-design/image/upload/v1686830043/Post_Content/nextjs-md-blog/005_aepw3c.png)

The above shows the format used in the example Markdown post. There are two key sections in the file.

The first section, shown below, is written in [YAML](https://yaml.org/) and can be thought of as metadata. This specific format is used by the [gray-matter](_https%3A//www.npmjs.com/package/gray-matter_) dependency package and allows us to use dot notation to access the values e.g. frontmatter.title etc.

```yaml
---
title: 'My first post..?'
author: 'Your Name'
date: '2021-06-01T12:00:00.000Z'
hero_image: /magic.png
intro: "I did a thing..."
keywords: ""
read: 3
---
```

/Note: when adding images, you can either point to content in the public folder of the project, as shown in the example, or use a URL to content in a CDN, Image site e.g. [Freepik](_https%3A//www.freepik.com_) or [Unsplash](_https%3A//www.unsplash.com_), or cloud-based storage./

The second section is the content of your post and can be written using Markdown syntax, see [https://www.markdownguide.org/basic-syntax/](https://www.markdownguide.org/basic-syntax/) for a basic guide.

Another key consideration is the naming convention that you use for your post .md files.

The repo that I have provided has the following code, in the /*posts/index.js*/ file, which reverses the array of keys that Webpack creates when it interrogates the /*posts*/ folder.

```jsx
export async function getStaticProps() {
    const webpackContext = require.context('../../posts', true, /\.\/.*\.md$/);
    // the list of file names contained
    // inside the "posts" directory
    const keys = webpackContext.keys();
    // this reverses the order of the posts to show the most recent first or alphabetically descending order
    const reverseKeys = keys.reverse();
    const values = reverseKeys.map(webpackContext);
    // getting the post data from the files contained
    // in the "posts" folder
    const posts = reverseKeys.map((key, index) => {
        // dynamically creating the post slug
        // from file name
        const slug = key
            .replace(/^.*[\\\/]/, '')
            .split('.')
            .slice(0, -1)
            .join('.');
        // getting the .md file value associated
        // with the current file name
        const value = values[index];
        // parsing the YAML metadata and markdown body
        // contained in the .md file
        const document = matter(value.default);
        return {
            frontmatter: document.data,
            markdownBody: document.content,
            slug,
        };
    });
```

This is because I use a naming convention that allows for the newest posts to be shown at the top of the web page (the specific format I use is [yyyy-mm-dd-post-name.md](http://yyyy-mm-dd-post-name.md)). If you want to show your posts in alphabetical or some other order, you can amend the code easily.

Just replace the above with.

```jsx
export async function getStaticProps() {
    const webpackContext = require.context('../../posts', true, /\.\/.*\.md$/);
    // the list of file names contained
    // inside the "posts" directory
    const keys = webpackContext.keys();

    const values = keys.map(webpackContext);
    // getting the post data from the files contained
    // in the "posts" folder
    const posts = keys.map((key, index) => {
        // dynamically creating the post slug
        // from file name
        const slug = key
            .replace(/^.*[\\\/]/, '')
            .split('.')
            .slice(0, -1)
            .join('.');
        // getting the .md file value associated
        // with the current file name
        const value = values[index];
        // parsing the YAML metadata and markdown body
        // contained in the .md file
        const document = matter(value.default);
        return {
            frontmatter: document.data,
            markdownBody: document.content,
            slug,
        };
    });
```

At this point, it would be a good idea for you to create some test posts for yourself.

## Showing your content on your website

Now that we have content we can discuss how it is shown on the website.

There are three files that are key to creating, showing, and reading the posts in this project.

The first two are the blog/index.js file

![NextJS Markdown Blog](https://res.cloudinary.com/xenos-design/image/upload/v1686830044/Post_Content/nextjs-md-blog/006_wrlcdh.png)

And the components/BlogList.js file

![NextJS Markdown Blog](https://res.cloudinary.com/xenos-design/image/upload/v1686830043/Post_Content/nextjs-md-blog/007_ql0hpn.png)

The first uses Webpack to get the post data and passes it to the second so it can render on the screen.

/Note: you can easily move the code from the first file to your root index.js file if you don’t want a separate posts page./

The third and final file is /*pages/blog/\[slug\].js*/ which shows all of a post's content, at least that which you choose to show when a post is clicked on in the list.

![NextJS Markdown Blog](https://res.cloudinary.com/xenos-design/image/upload/v1686830042/Post_Content/nextjs-md-blog/008_rep2aw.png)

As you can see this has both the frontmatter data and markdownBody content passed into it so that you have access to all of the content in your .md files.

I have used a combination of react-bootstrap and CSS to create a layout and style the content. As mentioned before you are free to use whatever styling approach works for you.

## Let's fire it up…

We are now ready to run the project and see our content. To do this you simply need to:

* navigate to the root folder in your terminal and run `npm run dev`
    
* open your browser and navigate to /[*localhost:3000*/](http://localhost:3000/)
    

The following should be visible on the screen.

![NextJS Markdown Blog](https://res.cloudinary.com/xenos-design/image/upload/v1686830042/Post_Content/nextjs-md-blog/009_kfxxuk.png)

Now click on the Blog link at the top and…

![NextJS Markdown Blog](https://res.cloudinary.com/xenos-design/image/upload/v1689967164/Post_Content/nextjs-md-blog/11_rv0td8.png)

Your posts are showing on your blog page and the content is accessible.

In Part 2 of this series we will be looking at the filters, discussing how these are used and how best to implement them.

5 things to consider for your business website


As a business owner in this modern world of ours, you want to be able to engage with as wide an audience as possible to maximise your potential revenue.

There are many ways in which you can achieve this but most, if not, in reality, all, rely on having an internet presence. So what should this presence be?

Social media is an obvious place to start. Huge audiences, ready-built platforms, global reach etc. However, whilst social media platforms are superb for marketing and customer/client engagement, they are enhancements rather than a replacement for a website/app.

The benefits of your business having a dedicated website are;

- bespoke styling and theme to match your businesses brand

- having the User Experience (UX) that you need to be driven through the User Interface (UI) that you want

- order lifecycle control from basket creation through to payment and order status management

- integration with your payment service

- you can share specialised content behind a secure login

So you have decided that your business deserves a website. What do you need to consider? the simple answer is \"Lots!\" but there are a number of key areas that will help get you started and ensure success. An overview of each of these areas and what they mean to you is summarised below.

## Where should I host my site?

This decision very much depends on a number of factors.

- how much control do you want to have over the look and feel of your website?

- do you want to build/maintain the website yourself or get a professional to do the work?

- how much traffic are you expecting?

- how frequently will your website structure or functionality, not content, be likely to change?

- what technologies do I want my website built with?

The specifics of which hosting provider you ultimately go with is a decision between you and, assuming you are not self-building, your web developer. The two high-level choices are;

### Hosted Service

This is where you use a service such as Wix.com, GoDaddy.com, WordPress.com et, there are many to choose from, and build your website using their templates, 'wizards' etc.

These are a, relatively, painless approach to building a website, especially for the non-technical, and you can be up and running in a fairly short period of time.

There is, however, a trade-off.

Using one of these services means you have less control over how and where your website/data is hosted, as well as having to live with the constraints that the service provider places upon you in terms of what can and cannot be achieved within their service.

This may be perfectly acceptable to you and your business, especially when starting out where you want something quick and easy, but be mindful of the future when your business is growing rapidly and you need to migrate to a more functionally rich solution.

### Self Hosted

The title of this option is somewhat misleading in that you do not have to build your own data centre, networks etc, rather that you take responsibility, albeit sub-contracted out to cloud providers and professionals, for where and how your website/app is hosted as well as the maintenance of the solution.

This opens up a cornucopia of possibilities and technology choices which, as a business owner, you may not want to spend time on. This is absolutely fine as you can leave a lot of these decisions to your trusted professionals who should be able to guide you down the right path depending on what business outcomes you want to achieve.

There is, of course, a trade-off. See what I did there...

By implementing your website/app in this way it is quite possible that it will be more expensive than using a Hosted Service.

However, the benefits from this approach, which in my experience outweigh the costs, are;

- flexibility

- scalability

- speed of change

- ability to try out new technologies

- ability to swap out providers to get better prices or enhanced services

## Domain name

So firstly \"What is a domain name?\"...

![Domains!](https://res.cloudinary.com/xenos-design/image/upload/v1650973009/Post_Content/web_domain_illustration_15756c7010.png 'Domains')

This is a key decision as the domain name you choose needs to be;

- **Memorable** - choose something that will stick in the memory

- **Meaningful** - relate to your business name or what your business does

- **Available** - you need to make sure that the domain name you want is available

It is also worth considering whether you want to register, although not necessarily use, multiple top-level domains, such as .com, .co.uk, .uk etc.

This is usually done to safeguard your business against competitors from trading under a similar web address and capitalising on your brand and hard work. These can be registered altogether, some Registrars provide bulk discounts, or later on as your business grows.

The one thing to be mindful of is that domain name registration is an ongoing cost, frequency-dependent on which Registrar you choose, and needs to be maintained otherwise you lose rights to the domain name(s) and your website will no longer be reachable.

## SEO / Analytics - putting you on the map, and keeping you there

Search Engine Optimisation (SEO) is all about getting to Page 1 on a Google search (other search engines are apparently available) and can be seen as a form of wizardry at times.

There are many articles that can be found online that go into this subject in much greater depth than I would want to in this article. Suffice to say that there are a few key considerations that you need to give consideration to when thinking about a website/app for your business.

- **Metadata** - this is the, mostly, unseen content in you site that search engines look for and index for users to search against. the main three are;

- **Title** - the text that appears in your browser tab

- **Description** - tells search engines what your site or page is for

- **Keywords** - the words that you specifically would like search engines to include your site in searches for

- **Sitemaps and Robots.txt** - these are files that need to be created and stored in the root directory of your website/app and are specifically there to help search engines by telling what content is important and what can be ignored

All this is great but unless you proactively monitor your performance and adjust accordingly your website is unlikely to rise to the heady heights of Page 1.

There are many, free and paid for, services and tools that will help you do this. My recommendation is that you start off with a free one, such as Google Analytics, and see how you get on before progressing to a paid tool.

If you are time-poor, understandable as you are building the next mega-corporation, then outsourcing this to a professional who will do the monitoring and maintenance for you is a great way to take the stress away.

## Images - stock vs owned

Depending on what your business does or is trying to market with a website then you will need to consider where your images come from and whether you want to pay a license fee or provide your own images, assuming you own the rights to use them and have these on the site.

I always look at it like this.

Am I showing a proprietary product or service that I want to have specific images of on my website?

If **YES**, then either hire a professional photographer to take the images you want (make sure the price includes you owning the right to own/use) or, if you are a budding photographer, take the images yourself and store them securely.

If **NO**, then using stock images, from services such as Getty or Unsplash, is a great way to go. Just make sure you read the licensing terms and understand whether you need to add a 'credit' against each image or somewhere on your website.

**Content / Copy**

Similar to images the written content on your website/app also needs to be considered and either outsourced to professionals or, if you have the experience necessary qualifications/experience/skills, do the job yourself.

Consideration should be given to bringing in professionals for the following areas;

- Legal and Commercial

- Sales and Marketing

- Technical Writing

- Content creation e.g. articles or blogs

## Summary

All of this can seem quite daunting, especially if you don't come from a technical background, so it is always worth speaking with a professional who can guide you through the process and help you make the right decisions for your business.


Securing your Media in WordPress


It may sound like a contradiction, but there are times when you upload content to your web fronted Content Management System but do not want it to be publicly visible.

Business use cases for this scenario include;

- legal services, where the content may be sensitive or covered by legislation such as GDPR
- creative or artistic content, where you have to show your work but do not want anyone to steal it
- members or subscribers only content, where you want to make the content visible to select or fee-paying subscribers

This article will address each of these scenarios and identify options for achieving the desired outcome. The choices I talk about are WordPress specific, but the context and principles are relevant to any technology.

## Legal Services

When your business provides legal services and your CRM uses WordPress, it is vital to keep the documents (images, PDFs) hidden from general view.

If you do not take specific action to secure your data, it will be indexed by search engines and can be accessed via the directory of your website e.g. _<a target=\"\_blank\" rel=\"\" href=\"http://www.example.com/wp-content/[$filename]\">www.example.com/wp-content/[$filename]</a>_.

This means you are unlikely to comply with local data protection regulations e.g. GDPR in the EU. Not to mention being open to litigation from clients who find their data is open to the world!

There are two specific actions you can take to negate these issues. Each has different layers of complexity depending on what needs to be delivered.

## Creative and Artistic Content

If your website is there to showcase your talent you do not want visitors to download it without permission.

Failure to protect your work can have the following consequences:

- Loss of revenue – if you sell your art through your website, and it is not under your control, you are potentially losing revenue.
- Intellectual property – your art is your intellectual property and should be protected against theft.

## Private or Paid for Content

If you produce content and want to monetise it or only make it available to who you want, you need to ensure that it is only accessible to those who should have access.

## So what can you do…?

Depending on your specific use case(s) three options available to you are:

_robots.txt file_

Adding a ‘robots.txt’ file to your website is a way of discouraging search engine crawlers (think leaf cutter ants, collecting info and returning with it to the hive) which URLs on your site they can access.

This is by no means foolproof and is not a guarantee of your content not appearing on search engine results.

**_Redirect_**

Adding redirect functionality to your website is a way of ensuring that direct access to your content, media files etc, is restricted to logged-in users.

In essence, it performs a check against content type and whether the browser trying to access it has an active session. If both conditions are not met, it redirects the browser to a specified URL (typically the home or login page).

This tends to be an “all or nothing” approach and does not differentiate between user roles. It also does not have any impact on search engine indexing.

**_Plugins_**

If you need a more robust solution, then there are plugins available for WordPress that will give you the following:

- Media file protection
- File type protection
- Role-based access to media files
- disable right-click functionality
- Prevent hot-linking to your content
- Enhanced redirects
- Block search engine indexing of media files
- Media file encryption
- Manual or automated creation of private links so you can share media files, with timed expiry capability
- Bulk protection functionality, if you have a lot of existing content you want to protect
- Integration with other plugins to provide enhanced capability

## Summary

Ensuring that your business is compliant with the relevant legislation and industry standards is critical to its continued success in building trust.


Efficiency through automation


In today's fast-paced world, businesses need to have a range of tools to ensure they are current with contacts from potential clients, partners or employees.

A key challenge is the greater the number of tools, the greater the complexity. So how should businesses address this challenge?

A great way to get around this is to integrate priority business systems. This ensures a clear flow of information and alerts to the appropriate communication channels.

I recently completed a project with a fantastic client, addressing this very issue.

Their starting position was quite typical. They had three web forms that sent data to a content management system. The client then took this data and copied it to a CRM. Not very efficient.

![Design 1!](https://res.cloudinary.com/xenos-design/image/upload/v1650975932/Post_Content/JR_1_a51220fe2c.png 'Layout')

Thankfully my client is dynamic and always looking to improve how they work.

This is the point where I got involved with the project. The brief? Integrate our web forms (NextJS/Formik) with our CRM (ClickUp) and messaging tool (Slack).

![Design 2!](https://res.cloudinary.com/xenos-design/image/upload/v1650975858/Post_Content/JR_2_636b77aa4a.png 'Layout')

Once I had reviewed the documentation and experimented with the integration options, the way forwards became clear.

The agreed solution was to integrate the web forms to ClickUp using its REST API to POST the data, as new tasks, to specific 'Lists'.

Then, using its native functionality, integrate ClickUp with Slack so that notifications would be generated, in the correct channels, when a new ClickUp task was created.

![Design 3!](https://res.cloudinary.com/xenos-design/image/upload/v1650975858/Post_Content/JR_3_8fc663b939.png 'Layout')

This took relatively minimal effort. The most time-consuming part was refactoring the functions in the web forms, to the structure for ClickUp and then testing the end to end data flow.

My client was thrilled by the improved workflow and how much time it saved them in manual effort.

Automation can improve customer engagement, improve employee efficiency and reduce operating costs. It doesn't have to be a large project or cost a fortune.

If you want to improve your business's efficiency, get in touch to discuss your requirements.


Using images on your website


It is absolutely true to say that using images on your website is a great way to make it more interesting, break up large sections of text and generally improve the user experience. In this post, I will share some of my experiences to hopefully make you better informed.

## **When should I use images?**

When considering whether an image should be used you should ask yourself the following design question.

_“Will it improve what is already there in some way…?”_

Some great reasons to say yes are:

- You are marketing a product, want to show it off and demonstrate how it works
- You are creating content and want to illustrate it with relevant imagery
- You want to include images that are relevant to your business or brand&nbsp;

If the answer is no, then look no further. However, if your answer is yes, then read on.

## **Where should I get my images from?**

This depends on your answer to the following question.

_“Am I showing a proprietary product or service that I want to have specific images of on my website?”_

If YES, then either hire a professional photographer to take the images you want (make sure the price includes you owning the right to own/use) or, if you are a budding photographer, take the images yourself and store them securely.

If NO, then using stock images is a great way to go. Just make sure you read the licensing terms and understand whether you need to add an ‘attribution’ against each image or somewhere on your website.

Most stock image websites will have ‘free’ content where only attribution is needed as well as ‘premium’ content that you have to pay for on either a subscription or per-image basis.

Examples of stock image sites are:

- [https://www.unsplash.com](https://www.unsplash.com)
- [https://www.istockphoto.com](https://www.istockphoto.com)
- [https://www.stock.adobe.com](https://www.stock.adobe.com)
- [https://www.freepik.com](https://www.freepik.com)
- [https://www.shutterstock.com](https://www.shutterstock.com)
- [https://www.pexels.com](https://www.pexels.com)
- [https://www.gettyimages.co.uk](https://www.gettyimages.co.uk)

## **What is image optimisation?**

Image optimisation is all about ensuring that you only use the largest image needed on your website. The size of an image impacts two things:  
Speed – how fast your website loads when a user has lower bandwidth for their internet connection, and  
Quality – generally the small the image size the worse the quality of the image that is seen.

_Example: a 300 x 300 pixel is unlikely to look great if stretched to 1200 x 1200._

One of the great things about using WordPress is that it will, when you upload an image to the media gallery, automatically create, assuming your image is large enough, a number of different versions of the image in different sizes.

So when you go select an image, to include on a page or in a post, it will present you with these options.

This is the point where you need to think about where you are placing the image and how big it is likely to be on a screen. If the image will be nested within text then there is little point in selecting a high-resolution version. The opposite is also true, if you want the image to be the width of a page you need to select a suitably large image resolution.

If the standard resolutions that WordPress provides, as standard, are not enough do not worry. Custom image sizes can be added with a little development.


My freelance journey continues

It has been a couple of months since I began my adventure into the world of freelancing as a Fullstack Developer and it has been quite eventful.  

Whilst I have only been working part-time, due to continuing in my full time position as a IT Service Management Architect, I have picked up a few contracts covering Strapi CMS, ReactJS, PHP and HTM/CSS. Each of these gigs have provided good and bad experiences, which I thought it worth sharing....  

## The Good  

Being able to work on a range of projects, with clients on both sides of the Atlantic, has been amazing.  

I have worked with a Fitness Start-up, an Info Sec org, a publishers and an established legal services firm. Each has brought their unique challenges and opportunities to grow.  

I was able to \"play\" with technologies such as Strapi CMS (which I love), ReactJS with Redis-Server and MongoDB, PHP (which I always enjoy!) and use SFTP and SSH which I have only had limited experience of so far.  

I also found a solid, and completely irrefutable, reason to finally bite the bullet and buy a MacBook Pro (M1 chip of course), when I discovered a clients build would only run on one.  

## The Bad  

Picking up someone else's code and trying to unpick it can be a very hit and miss. This is just life, isn't it?  

However, what is not excusable, is a developer creating a half-arsed build with no documentation so that the next poor developer that comes along (yes, this was me...) has to waste time fixing it rather than focusing on delivering value to the client.  

If you happen to be one of these types of developers then move along...  

## The Other One  

There was one particular experience that qualified for a \"WTF...\" award.  

I had been doing some work for a client and committing to GitHub as I went along.  

Then came time to raise a PR to get the code merged in prep for deployment. It is worth pointing out that Unit Testing had not been possible at this stage.  

So, I dutifully raise a PR and let the Product Owner know so they could progress.  

The following morning I started seeing increasingly more urgent messages via Slack. An issue had been encountered in the production environment. \"Interesting\", I thought, but not for me to worry about as all I had done was raise a PR for Staging.  

Then I start getting direct messages asking me what had I done. So, somewhat bemused, I said what I had done and included a screenshot from GitHub.  

After various frantic calls and a screen sharing session the issue became clear. So I deleted my PR request and after 20 minutes calm had been restored.  

The reason for this kerfuffle was that the DevOps team had set up the pipeline to pick up all PR requests, regardless of status or target environment, and apply them to all environments in succession with no validation or sign-off.  

Well, once I had stopped laughing, I wrote a recommendation for the client on CICD 'good' practice and carried on with my task.  

Is the moral of this tale worthy of the Brothers Grimm? Assume nothing and always question what is meant to happen.  

## Summary  

I am a firm believer that we are the sum of our experiences, and that without 'bad' experiences we never really for a solid view of what 'good' looks like.  

So, treat every day as a new adventure and, even when things get stressful, try to find the funny side along the way.  

Oh, and caffeine... lots and lots of caffeine!  




Dynamic Metadata in NextJS


## Introduction

If you have ever wondered how you can introduce dynamic metadata into your projects using NextJS, then this article is exactly what you’ve been looking for!

I have recently built this into this very site, which is built using NextJS and Strapi CMS.

The same principle will work with any NextJS project that consumes data from a CMS.

## Getting Started

The first thing I did
approached trying to do this was to ensure that I had the correct setup in my Layout component.

This is the component that wraps all of the content within the pages of this site and uses the Head component of NextJS to allow for the passing of different values for the metadata e.g. title, description and keywords which are the main three used.

![Layout!](https://res.cloudinary.com/xenos-design/image/upload/v1650971173/Post_Content/nextjs_layout_9688014fb9.png 'Layout')

Although it is not essential, it is a good idea to add default props layout values for the metadata that you want to cover. This is shown at the bottom of the screen.

Following that, I updated the [slug] page, which is the page that displays an individual article when you click on the card, specifically where you can see that I find it in the title, description and keywords and pointed the value to 3 unique fields within the post content that is being extracted from the Strapi CMS.

![Layout!](https://res.cloudinary.com/xenos-design/image/upload/v1650971173/Post_Content/nextjs_slug_93d0e48f50.png 'stuff')

This allows me to pass in the values that I want, which are stored within each individual article record in the database.

By doing this you can create unique titles for each of your articles, which allows your audience to save them with meaningful titles without having to type something in.

You can also add in whatever page description and keywords they want, therefore making each individual article more usable to search engines.

Once this was done all I needed to was to create the three fields within the article record structure in Strapi CMS (metaTitle, metaDesc and metaKey). The name of the fields does not really matter, as long as it is meaningful to you and to whoever you may be getting to support implementation going forwards.

## Results

At this stage, you are in a position to test your code works as expected. I recommend using the Chrome dev tools. If you implement this correctly you should see the following:

![Results!](https://res.cloudinary.com/xenos-design/image/upload/v1650971173/Post_Content/nextjs_title_ed9402e5d0.png 'Results')

and

![Results!](https://res.cloudinary.com/xenos-design/image/upload/v1650971173/Post_Content/nextjs_meta_94e4f3704f.png 'Results')

as you will see each of my articles on this site have their own unique titles and metadata.

I hope you found this useful and gives you some inspiration to implement into your own projects. If you get stuck and need some advice for free contact me via email or Twitter.


I did it...

After procrastinating for a while ( ok a long while… ) I finally plucked up the courage to enter the Freelance market and these are my main takeaways so far.  

Firstly it is worth mentioning that the contracts I have picked up so far have all been through upwork.com, I chose it for no other reason than seeing people's positive experiences on Twitter.  

I also, due to still working full-time as a Service Management consultant, only put proposals in for small assignments/projects that I could do in the evenings and weekends.  

**Read the small print** – sounds obvious but most of us tend to skip Terms and Conditions. I mention this as there are charges that are not so obvious when using job listing sites such as upwork.com.  

**Be professional** – whether writing your proposal/cover letter or communicating with your client remember that you are a business. This does not mean that you cannot be convivial but at the same time try to maintain a level of detachment so you can be an objection to the work.  

**Don’t be afraid to say “No..”** – there will come times when, as I found out when you will have to take a stance with a client who is trying to change the scope of the work, on a fixed price contract, without paying extra (scope creep).  

I chose to terminate an agreement with a client after having repeated discussions where they kept trying to shoehorn extra work into what should have been a couple of hours of work at most. I didn’t feel great about doing it but the aggravation was just not worth the £££.  

**If you think you can do it, put a proposal in** – just because you are not a 100% match for the required skills don’t be afraid to take a leap of faith in yourself. Use it as an opportunity to grow your skillset whilst getting paid.  

Expect surprises – unless you get an opportunity to review the code prior to starting a project/assignment expect there to be surprises and added complexity.  

My first assignment was posted as creating a simple PHP template that needed styling to match a pdf design. What arrived on day 1 was a set of complicated and interconnected files that I spent the first 2 hours just going over to understand the data flow.  

Ultimately it was a great learning experience but initially, there was a definite “WTF…” moment.  

So in conclusion I am loving my first few weeks as a freelancer and am looking forward to continuing to learn and grow.  




Intro to Regex


So I thought it was about time I did some discovery and learned about the use of RegEx and what it can bring to a project.

To ensure that I got a structured introduction I undertook the course called **_REGULAR EXPRESSIONS FOR BEGINNERS – UNIVERSAL_** on Udemy by Edwin Diaz, which I thoroughly recommend as Edwin is great at boiling the essence of a topic down into something that is easily understood.

The following are the notes that I took while working through the course along with some worked-out examples, some of which were derived from the course and some of which I’ve implemented in other projects.

Hopefully, this will be of some use to you and give you a broad understanding of RegEx.

I recommend that you use an online tool for working through this as it will help bring it to life. Personally, I use https://RegEx101.com/ as it will work with a number of languages, has a dictionary of syntax and will actually explain to you what your expression is doing as you write it out.

## REGEX OPTIONS

In its most basic form RegEx will match against a specified set of characters within a target string:

Example:

_/car/g_ - will search for every instance of the string “car” within a target string of text.

_/car/gi_ - will do the same as the above but will be case insensitive.

_/car/gim_ - will do the same as above but will search across multiple lines of text.

_/car/s_ - will search within a single line using a full stop/period to identify the end of the line.

_/car/imgu_ - will be case insensitive, search across multiple lines, will search globally and look at Unicode characters.

It is important that you get the setting of these options correct in your expressions to ensure that you're matching against exactly what you want.

## META CHARACTERS

_/c.r/i_ - adding a full stop/period anywhere in your string is essentially adding a wildcard. This means that, under this example, the expression will match against anything that starts with the letter c and ends with the letter r. It will not care if there is a letter or a symbol in between them, so be careful if you specifically want to search for an actual full stop/period.

## ESCAPING

_/c\\.r/g_ - so if you want to search specifically for full stop/period, or if your search string includes something like a “/” because you are searching a URL for example, then you will need to escape that particular character. This is done by adding a “\\” in front of the character so as you will see an example the expression of only return matches to “c.r” some language engines will automatically escape characters so RTFD…

## MORE CHARACTERS

escaping can also be used to match against a whole host of different characters or actions within your RegEx expression for example _/C\\n\\t\\R/_ will specifically look for C, then a new line, then a tab and then an R.

But be mindful that the characters work in different ways depending on what language engine you are working with e.g. JavaScript or.net or PHP et cetera so refer to the documentation.

## RANGES

_[car]_ - treats this as a range of letters to search for and will return every instance of each individual letter.

_[a-z]_ - search for every alphabetical letter and return every match. This is case sensitive so example only search for lowercase letters whereas [A-Z] will only search for uppercase. They can both be combined in the same range. [0-9] will also do the same thing, but for the range of numbers zero and nine. The ranges do not have to start or finish as stated above just as easily be [b-f]&nbsp;for example.

_[abdq]werty_ - search for all of the letters within the range as well as anything that matches “werty”.

The range, start and endpoint can be anything you want it to be as long as it is separated by a [-] within square brackets.

## NEGATION

negation is when you tell the expression to exclude something and this is done using the ^ symbol (shift + 6 on Windows keyboard). An example of this would be _[^cat]_ which would tell your expression to ignore any of the letters within the range.

## SHORTHAND

so shorthand is, and don’t shout at me for this, a bit like a macro or short name function as you can type in \\ followed by a specific character or letter and it will produce the equivalent of typing out a longer expression range. I have added a couple of examples below but for full details refer to the documentation language engine;

_\\s_ - looks for any whitespace character.

_\\S_ - looks for any non-whitespace character.

_\\d_ - looks for any digit.

_\\D_ - looks for any non-digit.

_\\w_ - looks for any word character.

and the list goes on. What is good about this is that you combine them within ranges and negation to make your code shorter.

But be mindful as some of them produce slightly odd results such as _\\b_ which looks at the boundary of what it considers to be a word but will include digits e.g. it would match against all of Lettuce468.

These can also be used to create a pattern against which to match if you need to be very specific, for example;

_[\\w\\w\\w\\w\\w\\w@xenos\\-design\\.co\\.uk]_ would match against my email address, or any email address under the same domain where the word in front of the @ symbol is six characters long.

**REPETITION**

Quantifiers – these are meta characters when added tell you expression to select varying amounts of the character that proceeds it, for example;

_a?_ - will match zero or one of a, where a represents what you want to match against.

\*a\*\* - will look for from 0 to more of a. I have also seen as described as the Greedy quantify because it will match as many times as possible.

_a+_ - will look for one or more of a.

_a{x}_ - will look for the specified number of a where x equals a number.

_a{x,}_ - will look for xc or more of a where x is a number.

_a{x,y}_ - will look for the number of a’s between x and y.

_a\*?_ - This will match a from zero or more times, but as few times as possible. This is known as a lazy or reluctant quantifier.

These can be combined to create an expression that will search for a pattern, an example of this would be _\\d {5}-\\d {4}_ would match any set of values that look like this 12345-6789 an obvious use case for this could be if you’re searching for telephone numbers in a dataset where there is a specified format. The same could obviously be done for text strings as well or indeed combinations of both.

## GROUPING

must be done outside of the character/range set otherwise parentheses will just be escaped, however, characters set/range can be put inside grouping so _([0-9])_ will work but _[()]_ will not.

An example of how this would work is save(d)? which makes ‘d’ optional and therefore would match against both ‘save’ and ‘saved’.

## ALTERNATION

the use of the pipe symbol ‘|’ (shift + \\ on a windows keyboard) effectively works as an OR statement. However, some nuances of it are;

- whatever is written on the left takes precedence.
- global needs to be switched on for it to work.
- it can be used as many times as needed.

A more effective way to use this is to include grouping i.e. (Bat|Super)man will return against both ‘Superman’ and ‘Batman’.

Example to work in – _(\\w+|file\\d {3}\_export\\. file201_export._ remember that the right of the pipe sign takes precedence and will be classed as an eager function as is looking for all words so would return against an underscore but not a hyphen or a full stop.

Alternation can also be used in a nested group i.e. (soup (bowl|spoon)) will return against ‘soup bowl’ and ‘soup spoon’, be mindful of the spacing as this is quite key to a working.

## ANCHORS

_^s_ - will look for the first ‘s’ in a string e.g. it has to be at the beginning of the string.

_s$_ - as above but at the end of the string.

_^[a-z]_ - will look for any texturing that starts with a lowercase letter.

## WORD BOUNDARIES

_\\b_ - this will match up to the boundary of each word or word character.

_\\B_ -&nbsp;this will match twin non-word boundary, which is somewhat confusing, as it will not match on any string of less than three-word characters but on a string of more than three characters it will match as follows ‘test’ as it treats the beginning and the end characters as the boundaries themselves rather than the spaces around them as the boundary.

## BACK REFERENCES

is a way of referring to the string of text or digits within a grouping.

Typically most engines let you save up to 9 back-references, shown as follows day(light) \\1&nbsp;with the ‘\\1’ being the reference to the “variable”. This would only match if the texturing it is searching is written as follows&nbsp;daylight light.

## NON-CAPTURING GROUP

In this example we see yet another way a ‘?’ can be used to do something different within your expression.

(food) and (?:travel) and \\1 will match against “food and travel and food” because is repeating the first variable, whereas&nbsp;(?:food) and (travel) and \\2 will match against “food and travel and travel” because it is repeating the second variable which is travel.

Using the “?:” switches off that variable.

## POSITIVE AND NEGATIVE ASSERTIONS

_[A-Za-z]+(?=,)_ - this will search for any upper or lowercase letter that is followed by a comma.

_[A-Za-z]+(?!,)_ - this literally does the reverse (if != ,) e.g. does not equal comma and so will match every string of upper and lowercase letters that do not end with a comma.

## POSITIVE AND NEGATIVE LOOKAHEAD

_[A-Za-z]+(?&lt;=,)_ - very similar to the previous section except that by adding the “&lt;” you’re telling the expression to look at what comes before e.g. under this example it would look for every texturing that is preceded by a comma.

_[A-Za-z]+(?-_ - again, literally the reverse, where you are looking for everything that is not preceded by comma.

## MULTILANGUAGE SYMBOL SUPPORT

RegEx includes support for Unicode, so no matter what language you are searching against you will be able to use Unicode to create a match in your expression.

You can find the full Unicode listings at [https://home.unicode.org/](https://home.unicode.org/).

If it is to be included it in your ReEex expression as follows \\u2022 using the “\\” to escape the u so that it is turned into the Unicode character.

## EXAMPLES

Password Validation –&nbsp; the following is an example of an expression that could be used to validate against contents of the users chosen password to ensure that it matches against the policy in place on our project.

Expression: _/^(?=.*[A-Z])(?=.*[a-z])(?=.*\\d)(?=.*[!$£#])\\S{5,20}$/gm_

_(?=.\_[A-Z])\\_ – this validates against the password having at least one upper case character.

_(?=.\_[a-z])\\_ – this validates against the password having at least one lowercase character.

_(?=.\_\\d)\\_ – this validates against the password having at least one number.

_(?=.\_[!$£#])\\_ – this validates against password having at least one of the identified symbols within the square brackets.

_\\S{5,20}_ – this validates him the password being a minimum of 5 and a maximum of 20 characters.

Pretty URLs – the following example is something that I have deployed myself and is commonly seen on websites to make the URL in the browser more human readable. This example is specific to PHP running on an Apache server.

**_Step One_** - ensure your Apache server has the rewrite engine switched on.

**_Step Two_** - create a new file called .htaccess in your website’s root directory.

**_Step Three_** - opening with your code editor and add the following:

**_Step Four_** - RewriteEngine on, this switches the rewrite engine on

RewriteRule _^post/(\\d+)$ post.php?p_id=$1 [NC,L]_ -&nbsp;this tells the server to replace anything with a post.php?p_id=$1, where $1 equals the number identified in the group, and replaces it with post/post number e.g.&nbsp;domainname.com/posts/178, with the&nbsp;NC denoting that it is case insensitive and the&nbsp;L denoting but this is the last rule that should be processed.

## SUMMARY

Hopefully, this brief introduction to RegEx has sparked your interest to go and explore more for yourself and understand how this very powerful tool could be used in your projects.

I’ve enjoyed learning about something that seemed to be quite daunting before but now seems quite simple once you understand the syntax.

I have added some references below to language-specific documentation and a couple of tools that I found useful during this learning process.

## REFERENCES AND RESOURCES

[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/)

[https://www.php.net](https://www.php.net)

[https://RegEx101.com/](https://RegEx101.com/)


My first #100DaysOfCode!


Although I was never particularly academic at school, which is a bit of an understatement considering I bombed out of secondary school with but a handful of GCSEs, I have always considered myself a lifelong learner if for no other reason than having to constantly adapt and learn new ways of doing things as a result of my disability.

I started to learn to code in the summer of 2020 and by the end of the year had absolutely fallen in love with coding and being able to build cool stuff.

I wanted to give myself a challenge in the New Year, as let’s be fair 2020 was a pretty rubbish year for most people, and having read about the #100DaysOfCode challenge on Twitter decided that this would be a good opportunity to apply some focus to my learning.

So on January 1, 2021, I formally declared my intention to start my _#100DaysOfCode_ journey and this is the story of how I got on, some of the areas I covered and most importantly the lessons I learned along the way.

If you’re reading this I hope it is of some use to you in your journey.

## WHAT DID I LEARN?

**_Read the documentation_** – it cannot be overstated, and is frequently reiterated in Twitter discussions, then reading the documentation for a language/framework/tool et cetera should be your first port of call when trying to understand what you need to do with your project. That being said the level of documentation can vary quite a lot and you will end up going down rabbit holes and tying yourself in knots when the level of documentation is substandard. Whenever I got to that stage my immediate go-to is Google, as it is very likely that what you’re trying to do has been done before and someone will come across the same problem as you and there will undoubtedly be a whole raft of information, and if you’re lucky, a fix or code snippet that you can use.

**_Pause, rewind and absorb_**… - If like me, you like to learn through tutorials and following others building projects online then you may well find yourself getting lost mostly because the speed at which experienced developers build things during their tutorials/courses is rarely at a speed at which you as the viewer can follow along with and build along with, in parallel. What worked for me was watching the tutor and then either pausing the video so that I could bring my version of the project up to the same level or pausing the video before the tutor started to build something, trying to build it myself and then watching the rest of the video and adjusting my code as needed (you need to be reasonably comfortable with the language or framework to start with to do this). One key point around this is that if you are doing online tutorials then make sure you allow enough time to do the tutorial plus whatever time you think you will need for revisions/pauses and rewinds in your learning plan. I found that I needed to add at least 50% additional time to my plan, but my typing speed is absolutely abysmal.

**_TAKING A BREAK IS NOT A CRIME!_** - Whilst the main premise of the #100DaysOfCode challenge is to get you into a regular behavioural pattern of writing code, so that it becomes second nature, what everyone undertaking the challenge should realise is that it is very important to sometimes just say “I need a break” and walk away for a day or two if needed. If you can maintain 100 days of doing anything without needing a break then fair play to you. I couldn’t and, excluding having to stop for a few weeks due to getting Covid-19, would occasionally take a day off just to recharge the batteries and not feel like I was becoming a slave to the challenge. However what I did notice is that in the last 30-ish days of the challenge I started to become more enthused and, even on a day I told myself I was going to have a break, found myself at the keyboard fiddling about with one project or another.

## RESOURCES I USED FREQUENTLY

Documentation – I have said previously but it absolutely warrants reiteration. RTFD…

[https://www.google.com/](https://www.google.com/) – although it often comes across as a bit of a joke it is an absolute truism that any developer, no matter how senior, will often be turning to Google when they either get stumped all are looking for a new shiny toy to put inside their project. Throughout my journey, I have created a library of bookmarks in my browser, but it’s always worth googling to find what else is out there as the pace of change is unbelievable.

[https://stackoverflow.com/](https://stackoverflow.com/) – I will be honest and say that I have a bit of a love-hate relationship with this website. As a source of information or fixes, it is great, if there is an existing thread on the subject. However, my personal experience, of putting new questions to the community has not inspired me to do it again.

[https://developer.mozilla.org/](https://developer.mozilla.org/) – This is literally the standard for HTML, CSS and JavaScript and gives great examples of how to use the baseline code.

[https://www.php.net](https://www.php.net) – as previous but for PHP, this is a great resource when trying to find out what the language is capable of doing. https://www.reactjs.org – the font of knowledge for the baseline react framework. As with the previous two entries, this is a great source of knowledge if you want to get into react.

[https://www.getbootstrap.com](https://www.getbootstrap.com) – the bootstrap framework is absolutely essential when you are starting out and want to quickly prototype your designs without going into all the detail of CSS yourself. Personally, I love it, and the plethora of templates and frameworks that have been built up around it.

[https://www.cdnjs.com](https://www.cdnjs.com) – if you want to include something in your project but don’t want to install the package itself and this site is a great source for the code snippets that you will need to add in your header or footer for either the CSS or JavaScript inclusions.

[https://www.imagecompressor.com](https://www.imagecompressor.com) – if you are just building little projects to test your code that will only be deployed locally then image compression is probably not going to be an issue. However, if you intend to put your project anywhere near the Internet then compressing your images down to a reasonable size is an absolute must. I tried a few different sites over the last few months and found that this one responds the quickest and gives me what I need without going through the nuisance of creating accounts choosing numerous options et cetera. It also does bulk-load which is great.

[https://www.github.com](https://www.github.com) / Github desktop / GitHub pages – if you’re going to build and deploy code in any meaningful way then you will absolutely need some sort of versioning tool. I opted for GitHub and, although I did learn the basic command lines, choose to use GitHub desktop most of the time for convenience. I also like having the ability to put up Github pages to showcase a project without having to deploy it to our hosting provider, and most of my portfolio runs straight out of Github pages.

Vscode and [https://marketplace.visualstudio.com/](https://marketplace.visualstudio.com/) – there are a lot of code editors out there and the choice of which one you use is usually based on personal preference. After having looked at a few different ones I decided to use VS Code as I like the interface and the extension management capabilities. Currently I’m running with a number of extensions active all of which make my life coding a lot easier. These are:

- **_Auto rename tag_** – which automatically changes the opposite end of a tag when you are editing your code
- **_Brackets pair coloriser_** – I found this to be fantastic so you understand where you are within different blocks of code
- **_code spell checker_** – just because…
- **_Code highlight_** – again let’s you see where you are within your various blocks of code
- **_ESLint_** – great integration if you’re using ESLint in your code
- **_Live server_** – so you can see how your code is working in real-time
- **_IntelliSense_** or code snippets for any language you’re using as auto complete saves a lot of time
- **_Prettier_** – for formatting your code into more readable structures. I found this only works, or it could only get it to work, with HTML and JavaScript
- **_Snyk_** vulnerability scanner as this will run scans against all of your public repos but can also tell you if your code is going to work or not is a will highlight code blocks that are not doing anything or will not work
- **_VScode–icon_** – gives you pretty little icons for your file types, which can be quite useful

other than extensions it is or is worth checking out the different colour themes that are available and choosing one that suits your personal preference on colourisation of syntax.

**Multiple screens** – whilst you can absolutely free amazing code on a single screen I’d thoroughly recommend investing in a least one other screen. My personal setup is a 27 inch screen in portrait mode, a 34 inch Ultra wide and 24 inch that I can pivot to landscape or portrait depending on the need. The ability to have multiple applications open and visible at the same time will help you improve your code experience no end.

[https://www.a11yproject.com](https://www.a11yproject.com) - this is a great source of information and checklists that will help you make your web project accessible to everyone.

## WHAT WOULD I DO DIFFERENTLY?

I have reflected on this quite a lot in the last couple of weeks and I think the only thing I would definitely do differently, and in fact, will do differently on my next #100DaysOfCode, is to engage more with the community and put more effort into engaging by social media channels.

From what I’ve experienced so far the dev community is excellent (if somewhat argumentative, just don’t ask which languages are the best!) and is very supportive of us newbies.

## TUTORIALS I ENJOYED

I spent a lot of time during the hundred days learning from experienced developers through articles, YouTube videos, and tutorials. The bulk of my learning came from tutorials on Udemy.com and I thought I would share the list of my top five favorite courses that I completed during my hundred days.

Each of the below helps to enhance my understanding in terms of deepening my knowledge of specific languages as well as giving inspiration as to the different ways that projects can be built.

- 50 projects in 50 days, HTML, CSS &amp; JavaScript – Brad Traversy

- JavaScript Web projects: 20 projects to build your portfolio – Andrei Neagoie

- React front to back - Brad Traversy

- Django with React an e-commerce website - Brad Traversy

- PHP for beginners – become a PHP master – CMS project – Edwin Diaz

now there are obviously many other great content creators out there so this is just based on my personal experience from what I’ve covered so far.

Prior to my hundred days, I had spent a lot of time in courses and tutorials from LinkedIn Learning which has some awesome courses done by some very passionate instructors and I learned a lot of the basics of HTML, CSS, and JavaScript from these tutors.

We all learn differently so you need to be mindful of the best way that works for you when setting out on your journey.

## WHAT NEXT?

Having finished my first go-round of #100DaysOfCode I’m taking a short break body to get this blog going, but also to think about what I want to do next. At the moment it is a tossup between delving deeper into react or learning Python.

Either way, I know it will be a good laugh I will thoroughly enjoy (most of) it!


Late to the party...?

Since starting to learn to code and spending a lot of time interacting with my peers on Twitter it is fair to say that I have had many moments of contemplation as to whether or not I am too old to change careers and get into coding as a full-time profession.  

However, from my perspective, I think the answer has to be that as long as you are open-minded, cognisant of the fact that to start with you will be heavily reliant on others for knowledge, and have a natural interest in what you are doing and is never too late to start learning anything.  

I started my journey by watching courses on LinkedIn learning, which was provided by my employer, then moving on to sources of knowledge such as YouTube videos and Udemy courses/boot camps all of which I found absolutely fantastic as both sources of knowledge and as inspiration to go forward to build things on my own.  

One of the great things about online courses/tutorials is the references to tools and frameworks, that you have not yet tried or may not have known about, which all helps to enhance your wider appreciation of quite how diverse the tools available to you are.  

I personally found all of these references to different things helped me to map out the areas that I wanted to learn and fine-tune my personal learning experience e.g. you start with HTML then you must learn CSS then to do anything meaningful you must learn JavaScript which then leads you onto frameworks such as React/Angular/Vue can then lead to frameworks such as Django/Gatsby and the list goes on.  

Even having spent the best part of the year learning to code and having built all sorts of projects, some of which even got successfully deployed, it is difficult to get away from the “impostor syndrome” mentality and that I have come into this way too late.  

However, I take solace in the fact that during my career I have changed my profession three or four times each of which meant having a very steep learning curve in order to survive rather than sink.  

Therefore I am confident that I will be able to apply the same to coding and make a success of it, or at least have a really entertaining hobby, build some cool stuff and meet some amazing people along the way. I think unless you’re an egomaniac it is always difficult to believe in yourself 100% but what we always need to remember is that we have come this far so why turn back now…

This is me...


Hi..  

I thought it best that I introduce myself so you can have some idea of who I am, although my ramblings may give that away, and why I decided to start writing and publishing articles about my journey.  

I have been working in the IT industry since the late 90s but, other than a brief stint building a very basic website for engineers to access across GPRS, I am new to writing code for websites and applications.  

I started learning coding mid 2020 partly as a way of relieving boredom and partly to have something to focus on as a way of fighting depression/anxiety.  

I don’t have a particularly technical background but do have a broad understanding of application architecture from all the various projects I’ve worked on.  

I initially dipped my toe into Python but quickly switched to front-end development starting with the basics of HTML, CSS and then delving deeper into JavaScript/REACT.  

As I started to get a reasonable grip of the basics, or so I thought, then I started building more complex solutions using the MERN stack and the Django framework.  

I’ve mostly built little bespoke projects for my own amusement or to try out something that I have learnt, as well as having built e-commerce and CMS, I am talking to you from a Next.js / Strapi CMS / Postgresql stack (migrated from a bespoke LAMP stack) site that I built, applications following online tutorials.  

As New Year’s Eve came around in 2020 I decided that I wanted to give myself a challenge and, having heard about the #100DaysOfCode challenge from Twitter, decided to have a crack at that.
Having recently completed my first hundred days, albeit with a pause of a few weeks due to getting Covid-19, and having thoroughly enjoyed the experience I thought I would start to document my journey both reflecting on the last hundred days or so and going forwards as I continue my learning and efforts to move into a development role full-time.  

So this is me…  

Hopefully will find my posts of some use to you in your journey…


All tales from the deep...