Webmasters Gallery

A solid, data-driven media buying strategy is the driving force behind any successful marketing campaign. Effective media buying will enable you to reach high-value audiences, scale up conversions, and reduce acquisition costs. When you’re maximizing the effectiveness & efficiency of your campaigns, everything else will fall into place. 

But smart media buying isn’t just about purchasing ad inventory. 

It’s about leveraging the right data points, implementing a consistent strategy, and making crucial adjustments that deliver outstanding results. In this guide, we’ll be outlining 13 proven media buying tips that will help you achieve your marketing objectives and generate optimal returns from your budget.

1. Define clear & measurable campaign objectives 

Before you dive into any granular media buying tactics, you’ll need to establish clear and realistic objectives for your campaign. 

Without measurable objectives in place, you’ll struggle to implement the right optimizations and gauge the success of your ads. 

Clarity is key here, as vague objectives will be very difficult to track. For example, rather than aiming to just ‘increase clicks’ to your website, you might aim to exceed your benchmark CTR by 10% or increase average click volumes by 20%. Your objectives should also be easy to measure. Confirm the data sources you’ll be using to track performance (e.g. Google Analytics, Facebook Ads Manager) and make sure you’re confident accessing them and downloading reports. 

Finally, don’t be afraid to break down wider business objectives into more manageable campaign KPIs. By clearly defining individual goals (e.g. boosting reach, improving CTR, increasing conversions) and frequently reviewing progress, you can avoid feeling overwhelmed, celebrate smaller milestones, and make in-flight adjustments to strengthen performance. 

2. Cherry-pick platforms that align with your target audience 

One of the most important aspects of media buying is reaching your target audience in the right digital environments. It doesn’t matter if you’re launching next-level creatives or making diligent optimizations – if your audience isn’t available on a certain platform, you won’t be able to achieve the best results! 

Start by defining clear audience personas using insights from social media platforms, market research, and your own customer data. What does your target audience look like in terms of their demographics, interests, and behaviors?

Once you have a better idea of your target audience, you can begin to identify the right platforms to reach them on. 

For example, if you’re looking to target Gen Z shoppers, TikTok is likely to provide you with strong reach. However, if your target audience is business professionals and decision-makers, then LinkedIn is the place to be. You’ll also need to consider the targeting capabilities of your chosen platforms. 

Is broad demographic targeting right for your audience? Or will you require more granular, in-market targeting to reach your ideal customers? The more you know about your desired audience and targeting requirements, the easier it will be to identify the most effective platforms. 

3. Approach every campaign with a test & learn strategy 

Frequent, data-fuelled testing will be a game-changer for your ad campaigns. 

By regularly experimenting with different creatives, audiences, and tactics, you can gather invaluable insights that will allow you to fully optimize your media buying. 

For instance, by comparing the conversion rates of two different audience segments, you’ll be able to figure out where to invest your budget to achieve superior results. Not only will this help you to reduce inefficient impressions, but it will also enable you to increase revenue and optimize your strategy. 

To ensure that you’re launching effective tests and harvesting useful data, you should always: 

• Set clear and measurable KPIs to compare between test variables 
• Allocate sufficient test budgets for different creatives, audiences, etc 
• Avoid testing too many variables at once to prevent confusion
• Ensure that you have equally sized sample groups/audiences 
• Make optimizations based on what the data is telling you 

As you consistently test different tactics & audiences, you’ll be able to discover high-performing strategies and refine your media buying. 

4. Make consistent, data-driven optimizations 

While the word ‘optimize’ is thrown around a lot in the world of digital marketing, the importance of effective optimizations should never be underestimated. 

If your media buying strategy is fuelled by rigorous optimizations, you’ll be in a much better position to achieve your marketing objectives and improve performance. 

But how can you ensure that you’re implementing the right optimizations? Firstly, always focus on your primary objective/KPI when making campaign optimizations. If your main goal is to generate website traffic, for instance, then you’ll need to prioritize metrics like clicks and CTR rather than video views. 

Patience is also crucial whenever you’re making optimizations. 

Whether you’re advertising on the Google Display Network or Instagram, give the platform algorithm time to adjust to any changes. It can take a few days for new optimizations to make an impact, so don’t panic if you’re seeing fluctuating results or slow progress initially. (However, while patience is important, you’ll also need to make decisive optimizations when the data is clear. Don’t hesitate to cut underperforming ads and shift your budget towards better-performing tactics!) 

5. Transform raw data into practical insights with analytics tools 

There’s a huge difference between just checking your performance data and truly analyzing your performance data. Interpreting raw data, and transforming it into actionable insights, is critical for successful media buying. Rather than just looking at numbers on a screen, you’ll need to figure out how you can use them to discover new tactics and optimize your campaigns. 

For example, let’s say your latest campaign delivered an average CPA of $10. 

Without context, it’s very difficult to know what this number means. But let’s say that your previous campaign delivered an average CPA of $20 – well, you’ve now successfully reduced your CPA by 50%, proving the success of your media buying strategy.

Contextualizing data is incredibly important, whether you’re comparing results year-on-year or looking at industry benchmarks. Always put your reporting data in context!  On top of this, try to figure out which elements are driving improvements or issues with your campaigns. A declining CTR is obviously bad news, but if you can attribute this to a new creative headline, you can make adjustments to try and reverse the trend. 

Calculating additional metrics can help you to extract highly valuable insights from your campaign reports. For example, comparing total conversions between different audiences can be useful, but calculating the ROAS of these audiences will give you a much better understanding of customer value and marketing efficiency. 

If you’re looking for a fast and easy way to drill down to these actionable insights, analytics tools are a fantastic option. These tools are designed to inject much-needed automation into your reporting process, so you can instantly access key metrics like CPA and ROAS. Once you’ve discovered an analytics tool that you’re comfortable using, you can set up custom reports, review cross-channel performance, and connect different data sources (e.g. Facebook Ads and Google Analytics) to build a clearer picture of performance. With all of your campaign data accessible through a single dashboard, it becomes much easier to optimize your media buying and increase ROI. 

6. Keep your ears to the ground on the latest platform evolutions 

The world of digital marketing is constantly shifting, and to maintain high-performing media buying, you’ll need to stay ahead of the curve. 

New audience trends, advertising tools, and platform features are always emerging across marketing networks. Advertisers who react quickly to these changes and capitalize on new opportunities can often find themselves gaining a competitive edge. These platform evolutions can also have a major impact on campaign management & marketing performance. For example, the iOS 14.5 update was hugely disruptive for Facebook advertisers – while some marketers worked swiftly to find effective workarounds, others were left in the dust. 

To stay up-to-date with the latest developments, be sure to keep an eye on industry news and actively look for product releases. 

Sign up for digital marketing newsletters, keep in touch with platform account managers, and set up news alerts wherever possible. Although keeping up with the ever-changing world of digital marketing is a daunting task, if you can keep your finger on the pulse, you’ll have a great chance of seizing new opportunities – and avoiding oncoming disasters. 

7. Experiment with multiple ad formats across platforms 

So, you’ve launched a successful media buying strategy. You’re seeing positive results with your current ad formats, and things are looking good. Time to sit back and put your feet up, right?

Well, not quite. 

While it can be tempting to stick with a proven media buying formula, if you want to consistently attract new customers and maintain efficiency in the long run, you’ll need to broaden your horizons. 

Experimenting with different ad formats is a fantastic way to elevate your creative messaging and discover profitable new tactics. 

For example, if you’re running an e-commerce store with multiple SKUs, then Facebook’s Advantage+ Catalog ads could help you to skyrocket product sales. If you’re retailing a product with clear and compelling user benefits, then short-form videos packed with UGC will help you to build credibility and generate clicks. 

Every marketing platform will offer a unique range of ad formats, designed to help brands achieve different objectives. Not only will experimenting with new formats prevent creative fatigue, but it will also allow you to develop a full-funnel strategy to maximize clicks and conversions across key platforms. 

8. Collaborate with external agencies 

Crafting, launching, and evolving your own media buying strategy can be very challenging at times. While many marketers like to be in total control of their advertising spend, setting up campaigns, analyzing reports, and implementing optimizations can all be extremely time-intensive tasks. 

This is where connecting with external agency partners can be a massive help. 

By partnering with expert marketers, you can simultaneously free up resources and dramatically increase ROI. Agency account teams will help you define your target audience, launch cross-platform strategies, and optimize ads to maximize conversions. 

Enlisting the help of an agency can also allow you to tap into long-standing platform relationships, meaning you can unlock preferential rates and customer support. On top of this, you’ll also be able to take advantage of in-depth media buying knowledge, as most agencies will employ specialists in everything from paid social to paid search. While there’s undoubtedly a lot you can do to improve the performance of your media buying, sometimes there’s nothing better than discovering the right agency partner. 

9. Use ad libraries to keep a close eye on your competitors 

The digital marketing landscape is intensely competitive, and you’re likely to be competing with a large number of rival advertisers looking to win over the same audiences. 

However, while your competitors can be a nuisance at times, they can also provide you with valuable insights to help you optimize your media buying. 

Tools like Facebook Ads Library and TikTok Top Ads are the places to stake them out. These give you an invaluable look at the types of ads other brands are running, and TikTok will even give you an indication of how they’re performing, too. 

Not only will this give you fresh ideas for creatives to test, it can also give you a heads-up on competitors who’ve launched new products that expose gaps in your offerings. So, build a list of rival brands and regularly check in on them via platform ad libraries to see if what they’re testing can help you refine your own tactics. You may see a competitor trialing a new ad format or content strategy that’s driving a high level of engagement. Take inspiration from these examples, adapting ideas and leveraging the best elements from competitor campaigns to your own advantage. 

10. Tailor your creative assets to different platforms 

Every platform is unique, and generic copy-and-paste ad creatives aren’t going to help you stand out in a cluttered market. If your creative assets feel bespoke to your chosen platform and target audience, they’re more likely to resonate with consumers. 

For example, short and punchy UGC videos can be very impactful on TikTok, particularly if they capitalize on trending audio snippets or social media challenges. LinkedIn, on the other hand, encourages more polished creative assets – formats like carousels can deliver high levels of engagement, particularly if they contain high-quality, informative visual content. 

Below are some of the key creative elements to consider when you’re repurposing assets for different platforms: 

• Aspect ratios: Make sure that you’re paying close attention to the technical ad specs for different platforms to avoid stressful (and costly) last-minute edits! 
• Video lengths: Ensure that the lengths of your video assets are aligned with platform best practices. For example, while longer-form videos can perform well through YouTube skippable campaigns, they’re unlikely to hold the attention of TikTok users. 
• Tone-of-voice: Different platforms attract diverse audiences, so consider who you’re reaching across ad networks and how you’ll address them. Tweak your ad copy and headlines to ensure you’re delivering relevant, appropriate messages. 

Whenever you’re launching creatives across multiple networks, think carefully about platform best practices and the preferences of your target audience. Media buying goes hand-in-hand with creative strategy, and if you can get the two working in perfect harmony, the results will speak for themselves. 

11. Ensure your ad delivery is aligned with your campaign goals & preferences 

Optimizing your ad delivery is one of the best ways to improve the efficiency of your media buying and maximize conversions. However, it can be difficult to know which delivery tactics are going to drive optimal results for your business. 

Taking Facebook Ads as an example, let’s look at the ad delivery options available on the platform and explain how each approach can impact your campaigns. 

Ad Set Budget Optimization (ABO)

With ABO ad delivery, you’ll set a specific budget against every individual ad set in your campaign. The Facebook algorithm will then optimize delivery within each of these ad sets based on your target audience and objectives. For example, let’s say you’re looking to manually test various audiences, placements, and creatives across multiple Facebook ad sets. 

With ABO, everything is controlled and managed at the ad set level. You can track the delivery of each ad set in detail, tweak budgets based on performance, and make ad optimizations in real time. 

If you want budget flexibility and the ability to make manual adjustments to your ad sets, ABO is the route for you. 

Campaign Budget Optimization (CBO)

Campaign Budget Optimization, on the other hand, is an ad delivery option that allocates and optimizes budgets across multiple ad sets. 

You’ll set a campaign-level budget for your activity, and the Facebook algorithm will automatically allocate budget to the ad sets with the best performance. This is a simpler form of ad delivery because you don’t need to make manual tweaks to individual ad sets – instead, you’ll rely on machine learning to manage ad spend across your campaign. 

CBO can be especially useful for advertisers managing large-scale campaigns with many different ad sets live at the same time. 

While ABO places the emphasis on granular control at the ad set level, CBO places the emphasis on campaign budget fluidity and convenience for advertisers. 

The right type of ad delivery depends on your campaign goals and preferences as an advertiser. 

Whether you’re keen to retain control of your ad sets or allow the Facebook algorithm to put in the hard yards, make sure you’re comfortable with your ad delivery and happy with the outcomes you’re seeing. 

12. Focus on high-performing campaign bidding strategies 

The more efficient your bidding tactics are across ad campaigns, the easier it will become to reduce your acquisition costs. The key here is to understand the different bidding options available to you and select the approach that aligns closely with your objectives. 

The first decision you’ll need to make is Auto Bid vs Manual Bid. 

On marketing platforms like Facebook, you’ll need to decide whether you want to automate your bidding or maintain manual control. With automated bidding, you can select a spend-based approach (maximizing conversions/conversion value) or a goal-based approach (achieving a set CPA/ROAS target.) 

You can also opt for a manual bidding approach, where you’ll set manual ad bids rather than allowing the Facebook algorithm to do so. This is often utilized by experienced advertisers with a solid understanding of their conversion values. If you’re unsure of which bidding strategy you should be using, you can always duplicate ad sets and see if automated or manual bids are delivering the most cost-efficient results. 

You’ll also need to consider Cost Cap vs Bid Cap within your bidding strategy. 

In simple terms, a bid-cap places a firm limit on your cost-per-bid while a cost-cap averages out all of your bids to achieve your desired overall CPA. 

If you’re more concerned with limiting the cost of specific actions (e.g. clicks, conversions) then a bid cap will keep your spending under tight control. However, if you’d rather maximize results and stay flexible with your total budget, then a cost cap will help you boost conversions while maintaining a set CPA. Every advertiser is different, and there’s nothing wrong with testing out different bidding tactics to find your best-performing options. Just make sure you’re actively trying to improve performance rather than assuming automated bidding is delivering optimal results! 

13. Experiment with Dynamic Creative Optimization 

Although it’s crucial to maximize the efficiency of your ad delivery, it’s also hugely important to ensure that your creatives are working as hard as possible for your brand. 

However, that doesn’t necessarily mean you need to spend hours tweaking every individual element of your creative assets. In fact, with Dynamic Creative Optimization (DCO) you can automate this entire process to optimize performance. DCO is available on several marketing platforms (e.g. Facebook, Amazon) and while the setup process may vary slightly, the concept is always the same. 

DCO enables you to rapidly launch a large number of ad variations, with assets personalized to different audiences and tested at scale to identify the strongest iterations. 

Dynamic advertising offers a number of unique benefits, including:

• Cost-effectiveness – since ads are dynamically generated and automatically optimized, you can quickly narrow down your assets based on their efficiency. 
• Personalization at scale – everything from your headlines to your CTAs can be adjusted in real-time based on customer responses, interests, and behaviors. 
• Effective retargeting – DCO allows you to understand the products/messages that resonate with your audience, so you can optimize retargeting ads to maximize sales. 

DCO essentially supercharges the ‘test & learn’ process, enabling you to scale up your campaigns while maintaining ad relevance and cost-efficiency. 

However, DCO isn’t necessarily for everyone. The process needs a healthy budget to achieve the scale required for effective testing, and you’ll also need enough products/assets/messages to produce a large number of ad variations. If you’re looking for innovative ways to improve the ROI of your media buying, and you have enough budget available to scale up your ad campaigns, then DCO can deliver exceptional results for your business. 

By fuelling your media buying with these proven tactics, you’ll be able to achieve consistently strong results – whatever your objective might be. 

Whether you’re looking to grow brand awareness or generate cost-efficient product sales, it all starts with a solid media buying strategy. Focus on clear objectives, tap into as much data as possible, and be ready to make speedy adjustments when needed. Good luck! 

Featured image by Bri Tucker on Unsplash

The post 13 Media Buying Tips For More Effective & Efficient Ad Campaigns  appeared first on noupe.

Even though JavaScript’s name was coined from the Java language, the two languages are worlds apart. JavaScript has more in common with Lisp>) and Scheme>), sharing features such as first-class functions and lexical scoping.

JavaScript also borrows its prototypal inheritance from the Self>) language. This inheritance mechanism is perhaps what many — if not most — developers do not spend enough time to understand, mainly because it isn’t a requirement to start working with JavaScript. That characteristic can be seen as either a design flaw or a stroke of genius. That said, JavaScript’s prototypal nature was marketed and hidden behind a “Java for the web” mask. We’ll elaborate more on that as we go on.

JavaScript isn’t confident in its own prototypal nature, so it gives developers the tools to approach the language without ever having to touch a prototype. This was an attempt to be easily understood by every developer, especially those coming from class-based languages, such as Java, and would later become one of JavaScript’s biggest enemies for years to come: You don’t have to understand how JavaScript works to code in JavaScript.

What Is Classical Object-Oriented Programming?

Classical object-oriented programming (OOP) revolves around the concept of classes and instances and is widely used in languages like Java, C++, C#, and many others. A class is a blueprint or template for creating objects. It defines the structure and behavior of objects that belong to that class and encapsulates properties and methods. On the other hand, objects are instances of classes. When you create an object from a class, you’re essentially creating a specific instance that inherits the structure and behavior defined in the class while also giving each object an individual state.

OOP has many fundamental concepts, but we will focus on inheritance, a mechanism that allows one class to take on the properties and methods of another class. This facilitates code reuse and the creation of a hierarchy of classes.

What’s Prototypal OOP In JavaScript?

I will explain the concepts behind prototypal OOP in Javascript, but for an in-depth explanation of how prototypes work, MDN has an excellent overview on the topic.

Prototypal OOP differs from classical OOP, which is based on classes and instances. In prototypal OOP, there are no classes, only objects, and they are created directly from other objects.

If we create an object, it will have a built-in property called prototype that holds a reference to its “parent” object prototype so we can access its prototype’s methods and properties. This is what allows us to access methods like .sort() or .forEach() from any array since each array inherits methods from the Array.prototype object.

The prototype itself is an object, so the prototype will have its own prototype. This creates a chain of objects known as the prototype chain. When you access a property or method on an object, JavaScript will first look for it on the object itself. If it’s not found, it will traverse up the prototype chain until it finds the property or reaches the top-level object. It will often end in Object.prototype, which has a null prototype, denoting the end of the chain.

A crucial difference between classical and prototypal OOP is that we can’t dynamically manipulate a class definition once an object is created. But with JavaScript prototypes, we can add, delete, or change methods and properties from the prototype, affecting the objects down the chain.

“Objects inherit from objects. What could be more object-oriented than that?”

— Douglas Crockford

What’s The Difference In JavaScript? Spoiler: None

So, on paper, the difference is simple. In classical OOP, we instantiate objects from a class, and a class can inherit methods and properties from another class. In prototypal OOP, objects can inherit properties and methods from other objects through their prototype.

However, in JavaScript, there is not a single difference beyond syntax. Can you spot the difference between the following two code excerpts?

// With Classes

class Dog {
  constructor(name, color) {
    this.name = name;

    this.color = color;
  }

  bark() {
    return I am a ${this.color} dog and my name is ${this.name}.;
  }
}

const myDog = new Dog("Charlie", "brown");

console.log(myDog.name); // Charlie

console.log(myDog.bark()); // I am a brown dog and my name is Charlie.

// With Prototypes

function Dog(name, color) {
  this.name = name;

  this.color = color;
}

Dog.prototype.bark = function () {
  return I am a ${this.color} dog and my name is ${this.name}.;
};

const myDog = new Dog("Charlie", "brown");

console.log(myDog.name); // Charlie

console.log(myDog.bark()); // I am a brown dog and my name is Charlie.

There is no difference, and JavaScript will execute the same code, but the latter example is honest about what JavaScript is doing under the hood, while the former hides it behind syntactic sugar.

Do I have a problem with the classical approach? Yes and no. An argument can be made that the classical syntax improves readability by having all the code related to the class inside a block scope. On the other hand, it’s misleading and has led thousands of developers to believe that JavaScript has true classes when a class in JavaScript is no different from any other function object.

My biggest issue isn’t pretending that true classes exist but rather that prototypes don’t.

Consider the following code:

class Dog {
  constructor(name, color) {
    this.name = name;

    this.color = color;
  }

  bark() {
    return I am a ${this.color} dog and my name is ${this.name}.;
  }
}

const myDog = new Dog("Charlie", "brown");

Dog.prototype.bark = function () {
  return "I am really just another object with a prototype!";
};

console.log(myDog.bark()); // I am really just another object with a prototype!"

Wait, did we just access the class prototype? Yes, because classes don’t exist! They are merely functions returning an object (called constructor functions), and, inevitably, they have a prototype which means we can access its .prototype property.

It almost looks like JavaScript tries to hide its prototypes. But why?

There Are Clues In JavaScript’s History

In May 1995, Netscape involved JavaScript creator Brendan Eich in a project to implement a scripting language into the Netscape browser. The main idea was to implement the Scheme language into the browser due to its minimal approach. The plan changed when Netscape closed a deal with Sun Microsystems, creators of Java, to implement Java on the web. Soon enough, Brendan Eich and Sun Microsystems founder Bill Joy saw the need for a new language. A language that was approachable for people whose main focus wasn’t only programming. A language both for a designer trying to make a website and for an experienced developer coming from Java.

With this goal in mind, JavaScript was created in 10 days of intense work under the early name of Mocha. It would be changed to LiveScript to market it as a script executing “live” in the browser but in December 1995, it would ultimately be named JavaScript to be marketed along with Java. This deal with Sun Microsystems forced Brendan to accommodate his prototype-based language to Java. According to Brendan Eich, JavaScript was treated as the “sidekick language to Java” and was greatly underfunded in comparison with the Java team:

“I was thinking the whole time, what should the language be like? Should it be easy to use? Might the syntax even be more like natural language? […] Well, I’d like to do that, but my management said, “Make it look like Java.”

Eich’s idea for JavaScript was to implement Scheme first-class functions — a feature that would allow callbacks for user events — and OOP based on prototypes from Self. He’s expressed this before on his blog:

“I’m not proud, but I’m happy that I chose Scheme-ish first-class functions and Self-ish prototypes as the main ingredients.”

JavaScript’s prototypal nature stayed but would specifically be obscured behind a Java facade. Prototypes likely remained in place because Eich implemented Self prototypes from the beginning and they later couldn’t be changed, only hidden. We can find a mixed explanation in an old comment on his blog:

“It is ironic that JS could not have class in 1995 because it would have rivaled Java. It was constrained by both time and a sidekick role.”

Either way, JavaScript became a prototype-based language and the most popular one by far.

If Only JavaScript Embraced Its Prototypes

In the rush between the creation of JavaScript and its mass adoption, there were several other questionable design decisions surrounding prototypes. In his book, JavaScript: The Good Parts, Crockford explains the bad parts surrounding JavaScript, such as global variables and the misunderstanding around prototypes.

As you may have noticed, this article is inspired by Crockford’s book. Although I disagree with many of his opinions about JavaScript’s bad parts, it’s important to note the book was published in 2008 when ECMAScript 4 (ES4) was the stable version of JavaScript. Many years have passed since its publication, and JavaScript has significantly changed in that time. The following are features that I think could have been saved from the language if only JavaScript had embraced its prototypes.

The this Value In Different Contexts

The this keyword is another one of the things JavaScript added to look like Java. In Java, and classical OOP in general, this refers to the current instance on which the method or constructor is being invoked, just that. However, in JavaScript, we didn’t have class syntax until ES6 but still inherited the this keyword. My problem with this is it can be four different things depending on where is invoked!

1. this In The Function Invocation Pattern

When this is invoked inside a function call, it will be bound to the global object. It will also be bound to the global object if it’s invoked from the global scope.

console.log(this); // window

function myFunction() {
  console.log(this);
}

myFunction(); // window

In strict mode and through the function invocation pattern, this will be undefined.

function getThis() {
  "use strict";

  return this;
}

getThis(); // undefined

2. this In The Method Invocation Pattern

If we reference a function as an object’s property, this will be bound to its parent object.

const dog = {
  name: "Sparky",

  bark: function () {
    console.log(`Woof, my name is ${this.name}.`);
  },
};

dog.bark(); // Woof, my name is Sparky.

Arrow functions do not have their own this, but instead, they inherit this from their parent scope at creation.

const dog = {
  name: "Sparky",

  bark: () => {
    console.log(`Woof, my name is ${this.name}.`);
  },
};

dog.bark(); // Woof, my name is undefined.

In this case, this was bound to the global object instead of dog, hence this.name is undefined.

3. The Constructor Invocation Pattern

If we invoke a function with the new prefix, a new empty object will be created, and this will be bound to that object.

function Dog(name) {
  this.name = name;

  this.bark = function () {
    console.log(`Woof, my name is ${this.name}.`);
  };
}

const myDog = new Dog("Coco");

myDog.bark(); // Woof, my name is Coco.

We could also employ this from the function’s prototype to access the object’s properties, which could give us a more valid reason to use it.

function Dog(name) {
  this.name = name;
}

Dog.prototype.bark = function () {
  console.log(`Woof, my name is ${this.name}.`);
};

const myDog = new Dog("Coco");

myDog.bark(); // Woof, my name is Coco.

4. The apply Invocation Pattern

Lastly, each function inherits an apply method from the function prototype that takes two parameters. The first parameter is the value that will be bound to this inside the function, and the second is an array that will be used as the function parameters.

// Bounding `this` to another object

function bark() {
  console.log(`Woof, my name is ${this.name}.`);
}

const myDog = {
  name: "Milo",
};

bark.apply(myDog); // Woof, my name is Milo.

// Using the array parameter

const numbers = [3, 10, 4, 6, 9];

const max = Math.max.apply(null, numbers);

console.log(max); // 10

As you can see, this can be almost anything and shouldn’t be in JavaScript in the first place. Approaches like using bind() are solutions to a problem that shouldn’t even exist. Fortunately, this is completely avoidable in modern JavaScript, and you can save yourself several headaches if you learn how to dodge it; an advantage that ES6 class users can’t enjoy.

Crockford has a nice anecdote on the topic from his book:

“This is a demonstrative pronoun. Just having this in the language makes the language harder to talk about. It is like pair programming with Abbott and Costello.”

“But if we want to create a function constructor, we will need to use this.” Not necessarily! In the following example, we can make a function constructor that doesn’t use this or new to work.

function counterConstructor() {
  let counter = 0;

  function getCounter() {
    return counter;
  }

  function up() {
    counter += 1;

    return counter;
  }

  function down() {
    counter -= 1;

    return counter;
  }

  return {
    getCounter,

    up,

    down,
  };
}

const myCounter = counterConstructor();

myCounter.up(); // 1

myCounter.down(); // 0

We just created a function constructor without using this or new! And it comes with a straightforward syntax. A downside you could see is that objects created from counterConstructor won’t have access to its prototype, so we can’t add methods or properties from counterConstructor.prototype.

But do we need this? Of course, we will need to reuse our code, but there are better approaches that we will see later.

The new Prefix

In JavaScript: The Good Parts, Crockford argues that we shouldn’t use the new prefix simply because there is no guarantee that we will remember to use it in the intended functions. I think that it’s an easy-to-spot mistake and also avoidable by capitalizing the constructor functions you intend to use with new. And nowadays, linters will warn us when we call a capitalized function without new, or vice-versa.

A better argument is simply that using new forces us to use this inside our constructor functions or “classes,” and as we saw earlier, we are better off avoiding this in the first place.

The Multiple Ways To Access Prototypes

For the historical reasons we already reviewed, we can understand why JavaScript doesn’t embrace its prototypes. By extension, we don’t have tools to mingle with prototypes as straightforward as we would want, but rather devious attempts to manipulate the prototype chain. Things get worse when across documentation, we can read different jargon around prototypes.

The Difference Between [[Prototype]], __proto__, And .prototype

To make the reading experience more pleasant, let’s go over the differences between these terms.

• [[Prototype]] is an internal property that holds a reference to the object’s prototype. It’s enclosed in double square brackets, which means it typically cannot be accessed using normal notation.
• __proto__ can refer to two possible properties:
  • It can refer to a property from any Object.prototype object that exposes the hidden [[Prototype]] property. It’s deprecated and ill-performing.
  • It can refer to an optional property we can add when creating an object literal. The object’s prototype will point to the value we give it.
• .prototype is a property exclusive to functions or classes (excluding arrow functions). When invoked using the new prefix, the instantiated object’s prototype will point to the function’s .prototype.

We can now see all the ways we can modify prototypes in JavaScript. After reviewing, we will notice they all fall short in at least some aspect.

Using The __proto__ Literal Property At Initialization

When creating a JavaScript object using object literals, we can add a __proto__ property. The created object will point its [[Prototoype]] to the value given in __proto__. In a prior example, objects created from our function constructor didn’t have access to the constructor prototype. We can use the __proto__ property at initialization to change this without using this or new.

function counterConstructor() {
  let counter = 0;

  function getCounter() {
    return counter;
  }

  function up() {
    counter += 1;

    return counter;
  }

  function down() {
    counter -= 1;

    return counter;
  }

  return {
    getCounter,

    up,

    down,

    __proto__: counterConstructor.prototype,
  };
}

The advantage of linking the new object’s prototype to the function constructor would be that we can extend its methods from the constructor prototype. But what good would it be if we needed to use this again?

const myCounter = counterConstructor();

counterConstructor.prototype.printDouble = function () {
  return this.getCounter() * 2;
};

myCounter.up(); // 1

myCounter.up(); // 2

myCounter.printDouble(); // 4

We didn’t even modify the count internal value but instead printed it double. So, a setter method would be necessary to manipulate its state from outside the initial function constructor declaration. However, we are over-complicating our code since we could have simply added a double method inside our function.

function counterConstructor() {
  let counter = 0;

  function getCounter() {
    return counter;
  }

  function up() {
    counter += 1;

    return counter;
  }

  function down() {
    counter -= 1;

    return counter;
  }

  function double() {
    counter = counter * 2;

    return counter;
  }

  return {
    getCounter,

    up,

    down,

    double,
  };
}

const myCounter = counterConstructor();

myCounter.up(); // 1

myCounter.up(); // 2

myCounter.double(); // 4

Using __proto__ is overkill in practice.

It’s vital to note that __proto__ must only be used when initializing a new object through an object literal. Using the __proto__ accessor in Object.prototype.__proto__ will change the object’s [[Prototoype]] after initialization, disrupting lots of optimizations done under the hood by JavaScript engines. That’s why Object.prototype.__proto__ is ill-performant and deprecated.

Object.create()

Object.create() returns a new object whose [[Prototype]] will be the first argument of the function. It also has a second argument that lets you define additional properties to the new objects. However, it’s more flexible and readable to create an object using an object literal. Hence, its only practical use would be to create an object without a prototype using Object.create(null) since all objects created using object literals are automatically linked to Object.prototype.

Object.setPrototypeOf()

Object.setPrototypeOf() takes two objects as arguments and will mutate the prototype chain from the former argument to the latter. As we saw earlier, switching an object’s prototype after initialization is ill-performing, so avoid it at all costs.

Encapsulation And Private Classes

My last argument against classes is the lack of privacy and encapsulation. Take, for example, the following class syntax:

class Cat {
  constructor(name) {
    this.name = name;
  }

  meow() {
    console.log(`Meow! My name is ${this.name}.`);
  }
}

const myCat = new Cat("Gala");

myCat.meow(); // Meow! My name is Gala.

myCat.name = "Pumpkin";

myCat.meow(); // Meow! My name is Pumpkin.

We don’t have any privacy! All properties are public. We can try to mitigate this with closures:

class Cat {
  constructor(name) {
    this.getName = function () {
      return name;
    };
  }

  meow() {
    console.log(`Meow! My name is ${this.name}.`);
  }
}

const myCat = new Cat("Gala");

myCat.meow(); // Meow! My name is undefined.

Oops, now this.name is undefined outside the constructor’s scope. We have to change this.name to this.getName() so it can work properly.

class Cat {
  constructor(name) {
    this.getName = function () {
      return name;
    };
  }

  meow() {
    console.log(`Meow! My name is ${this.getName()}.`);
  }
}

const myCat = new Cat("Gala");

myCat.meow(); // Meow! My name is Gala.

This is with only one argument, so you can imagine how unnecessarily repetitive our code would be the more arguments we add. Besides, we can still modify our object methods:

myCat.meow = function () {
  console.log(`Meow! ${this.getName()} is a bad kitten.`);
};

myCat.meow(); // Meow! Gala is a bad kitten.

We can save and implement better privacy if we use our own function constructors and even make our methods immutable using Object.freeze()!

function catConstructor(name) {
  function getName() {
    return name;
  }

  function meow() {
    console.log(`Meow! My name is ${name}.`);
  }

  return Object.freeze({
    getName,

    meow,
  });
}

const myCat = catConstructor("Loaf");

myCat.meow(); // Meow! My name is Loaf.

And trying to modify the object’s methods will fail silently.

myCat.meow = function () {
  console.log(`Meow! ${this.getName()} is a bad Kitten.`);
};

myCat.meow(); // Meow! My name is Loaf.

And yes, I am aware of the recent proposal for private class fields. But do we really need even more new syntax when we could accomplish the same using custom constructor functions and closures?

So, Classes Or Prototypes In JavaScript?

In Crockford’s more recent book, How JavaScript Works (PDF), we can see a better option than using Prototypes or Classes for code reuse: Composition!

Using prototypes feels like using a half-finished feature, while classes can lead to overcomplicated and unnecessary hierarchies (and also to this ). Fortunately, JavaScript is a multi-paradigm language, and forcing ourselves to only use classes or prototypes for code reusability is constraining ourselves with imaginary ropes.

As Crockford says in his more recent book:

“[I]nstead of same as except we can get a little bit of this and a little bit of that.”

— Douglas Crockford, How JavaScript Works

Instead of a function constructor or class inheriting from another, we can have a set of constructors and combine them when needed to create a specialized object.

function speakerConstructor(name, message) {
  function talk() {
    return Hi, mi name is ${name} and I want to tell something: ${message}.;
  }

  return Object.freeze({
    talk,
  });
}

function loudSpeakerConstructor(name, message) {
  const {talk} = speakerConstructor(name, message);

  function yell() {
    return talk().toUpperCase();
  }

  return Object.freeze({
    talk,

    yell,
  });
}

const mySpeaker = loudSpeakerConstructor("Juan", "You look nice!");

mySpeaker.talk(); // Hi, my name is Juan and I want to tell something: You look nice!

mySpeaker.yell(); // HI, MY NAME IS JUAN AND I WANT TO TELL SOMETHING: YOU LOOK NICE!

Without the need for this and new and classes or prototypes, we achieve a reusable function constructor with full privacy and encapsulation.

Conclusion

Yes, JavaScript was made in 10 days in a rush; yes, it was tainted by marketing; and yes, it has a long set of useless and dangerous parts. Yet is a beautiful language and fuels a lot of the innovation happening in web development today, so it clearly has done something good!

I don’t think we will see a day when prototypes receive the features they deserve, nor one in which we stop using classical syntactic sugar, but we can decide to avoid them when possible.

Unfortunately, this conscious decision to stick to the good parts isn’t exclusive to JavaScript OOP since, between the rush into existence, the language brought a lot of other dubious features that we are better off not using. Maybe we can tackle them in a future article, but in the meantime, we will have to acknowledge their presence and make the conscious decision to keep learning and understanding the language to know which parts to use and which parts to ignore.

References

• Brendan Eich Personal Website (N.D.)
• JavaScript: The Good Parts, Douglas Crockford (O’Reilly, 2008)
• How JavaScript Works, Douglas Crockford (Virgule-Solidus, 2018)
• Douglas Crockford Personal Website (N.D.)
• Brendan Eich’s Interview Conducted by Eric Knorr
• Brendan Eich’s Interview Conducted by Lex Fridman
• Mozilla Foundation Documentation (N.D.)

As we near the end of 2023, we wanted to take a look back over all the tools we collected over the past year, to pick out our favorites.

Unlike the software development life cycle, the product death cycle is an important constraint that shouldn’t be overlooked by startups. 

Many startups avoid it and fail to grasp good market opportunities along with untapped profits they could make.

Frequent analysis of product cycles is essential for startups to sustain good value in the market with loyal customers so they can serve better and better every day. 

But what if you encounter a product death cycle in between? How can startups avoid the product death cycle? Let’s find out in this article. 

Understanding Product Death Cycle 

But first, what is the product death cycle all about? 

In the age of competitiveness, startups often encounter a crucial phase known as the “Product Death Cycle.” 

This cycle refers to a stage where a product continuously loses its market relevance and faces the risk of losing potential buyers along with trust and values. 

Significantly for startups this stage is crucial and cannot be avoided as a risk of business failure. Hence, understanding and effectively navigating this cycle is vital for their survival and success.

Causes For Product Death Cycle 

Certain causes can cause your product to experience a death cycle and those are discussed below. 

Lack of Market Research

Poor market research is one of the significant causes of the product death cycle.

Startups sometimes fail to understand the evolving needs and preferences of their target audience. Might leave them in the creation of products that may not align with market demands.

Aggressive Competition

Startups are well familiar with the ratio of competitiveness in the modern days. If not studied properly could impact them brutally. 

Constantly explore your competitors and similar selling brands’ strategies they incorporate in time. Many companies fail here and as a result, are replaced by competitors’ more innovative solutions. 

Inflexibility in Adaptation

The inability to bring change or too rigid policies can trap in the product death cycle. A good product always nurtures market demand and the constant preference of customers to serve better, every day. 

The inability to adapt to market shifts or technological advancements can lead to irrelevance.

Strategies To Escape Product Death Cycle

Indeed, a good strategy is needed to solve or escape the product death cycle. Here’s a comprehensive explanation of these strategies:

Agile Business Model

Using an agile business model is essential. 

It allows companies to be perfect, responsive, and flexible in adapting to changing market dynamics. 

It brings new development, regular feedback loops, and quick adjustments based on customer feedback. 

By following business models as planned startups can remain relevant in the ever-evolving market.

Customer-Centric Approach

Prioritizing the customer is fundamental. 

By deeply understanding their needs, preferences, and pain points. Startups can better serve them to match their expectations in time.

Regular interaction, feedback collection, and a focus on user experience contribute to a more successful product in the market. 

Innovation and Adaptation

Innovation is the essence of a savior. Therefore, if startups fail to imply innovation they might not be able to escape the product death cycle. 

Startups need to continually innovate and adapt to emerging trends, technologies, and market shifts. 

Also, this helps them stay forefront and step forward from their competitors. As much as possible, invest in research and development to innovate new features. 

Working on the aforementioned strategies would help your business escape from product death cycle. 

I have drawn an example assuming myself as a product manager of a reputed U.S. based firm. Let’s draw a strategy to tackle the product death cycle scenario. 

How Product Manager Escape The Product Death Trap?

Being a product manager is a responsible job and a situation like a product death trap makes you more liable to escape to ensure better continuity and demand for your product in the market. 

In order to tackle product death cycle, you must navigate challenges, and stay adaptable, and very important thing is that the product remains relevant and successful. 

Here are some key strategies to anticipate to trump over the product death cycle. 

Customer-Centric Approach

• Stay connected with your customers. Regularly gather feedback through surveys, interviews, and analytics.

• Understand their pain points and needs. Prioritize features and improvements based on customer value.

Agile Methodology

• Use an agile approach to development. Break down projects into smaller, manageable tasks.

• Adapt quickly to changes in market conditions, technology, or user requirements.

Continuous Improvement

• Create a culture of continuous improvement. Encourage your team to learn from both successes and failures.

• Periodically to identify areas for improvement in processes and products.

Market Research and Trend Analysis

• Stay informed about industry trends, emerging technologies, and competitors.

• Conduct regular market research to identify new opportunities and potential threats.

Data-Driven Decision Making

• Take decisions considering data rather than assumptions. Use analytics tools to gather insights into user behavior and product performance.

• Set up key performance indicators (KPIs) to measure the success of your product.

Cross-Functional Collaboration

• Foster collaboration between different departments, including development, marketing, sales, and customer support.

• Break down silos to ensure everyone is aligned with the product vision and goals.

Risk Management

• Identify potential risks early on and develop mitigation strategies.

• Regularly reassess risks and adjust strategies based on changing circumstances.

Product Lifecycle Management

• Understand the various stages of the product lifecycle. If required re-plan for updates, and new features.

• Allocate resources accordingly to each stage of the product’s life.

User Experience (UX) Design

• Prioritize a seamless and intuitive user experience. A well-designed product can contribute significantly to its success.

• Gather user feedback on the usability of the product and make improvements accordingly.

Communication Skills

• Clearly communicate the product vision, goals, and progress to all stakeholders.

• Be transparent about challenges and solicit input from team members to find effective solutions.

Flexibility and Adaptability

• Be open to change and ready to pivot if market conditions or user needs shift.

• Avoid becoming overly attached to a specific solution and be willing to explore alternatives.

By incorporating these strategies, a product manager can increase the chances of their product thriving in the dynamic and competitive business environment, avoiding the pitfalls that can lead to the product death trap.

Conclusion 

Product death cycle is an important factor to examine. To keep running the product life cycle flexible and smooth. It is important to rectify a product’s loophole before it threatens business failure. 

Consider the signs leading to the product death cycle and implement proactive strategies to escape this phase. 
Think of the best innovation labs in the world and rehearse the competitive landscape to avoid product death cycle.

Featured image by Israel Andrade on Unsplash

The post How Should Startups Escape From Product Death Cycle? appeared first on noupe.

Generation Z is a unique generation. They are identified as the first true digital generation to witness a digital world. The internet and social media rule their world, and instant communication is the norm. The ever-growing world of technology has increased the challenges for marketers. Generation Z includes those who were born from 1997 to 2012.

Over time, they have become the most influential consumer block. This article reviews the five best strategies to reach them effectively. It will cover the importance of having clear values and a vital mission. Furthermore, it will highlight the importance of being transparent and accountable. It is equally important to know about the power of a distinct brand personality and the importance of being entertaining and building a community. All these can create lasting connections with Gen Z consumers. It’s about handling future marketing matters related to Generation Z.

Establish Clear Values & Mission

Gen Z cares about what a brand stands for. Their support goes to brands reflecting their values. A clear mission tells them what a brand is about. It’s not just about selling. It’s about making a statement. They back brands that stand on issues like LGBTQ+ rights, diversity, and social responsibility. These are more than just nice-to-have. They are must-haves for Gen Z loyalty.

This generation looks for more than products. They seek out brands that fight for change. For them, buying is voting. Each purchase is a vote for the world they want to see. Brands that should pay attention to this will stay caught up. Those that get it, like Parade, thrive. Parade isn’t just selling underwear. They’re promoting body positivity, inclusivity, and rights for all. It makes them more than a brand to Gen Z. They’re a movement. This alignment of values and actions wins Gen Z’s hearts and wallets. It’s a powerful connection. A bond not easily broken. That’s why values and mission are everything in marketing to Gen Z.

Be Transparent & Accountable

Gen Z values honesty. They’ll dig deep into a brand’s history, values, and even slip-ups. They respect a brand that owns its mistakes and speaks openly. Trust is big for them, sometimes even more than price. They stick with brands they believe in. Cocokind, a skincare company, showed how it’s done. They promised to share their team’s diversity stats. This was to let their customers check if they walked their talk. It was a bold move that showed they weren’t just about words but also actions.

Gen Z noticed and respected that. They want to see real, ethical action behind the scenes, not just in the ads. This clear, open way wins over Gen Z. They don’t just buy a product. They buy what the brand stands for. When a brand is upfront, it stands strong with Gen Z.

Establish Your Brand’s Personality

To grab Gen Z’s attention, brands must stand out. A strong personality is key. This means being bold and daring. Gen Z wants brands that speak their language and share their vibe. The old ways do not support it.  It is no longer a matter of polished, perfect looks that drew millennials. For Gen Z, being real, raw, and relatable is better. 

Take Starface for example, they sell pimple patches, but their fun, bright yellow star-shaped branding shines. When considering how to appeal to this generation, exploring branding statistics can offer valuable insights into effective strategies.

It’s not just a product; it’s a statement. Their vibe is playful and unapologetic. This fresh approach draws in Gen Z, who see their quirks reflected in the brand. Then, there’s the Crocs and KFC collaboration. It’s so out there it’s genius. These brands mixed comfort with fast food in a shoe.

Also, when it comes to reaching out to potential customers, adopting a similarly genuine and personalized approach, like crafting a well-thought-out cold email, can make a lasting impression.

Sounds crazy, right? But it worked. It caught the eye. Gen Z loves that—it’s weird and different and breaks the mold. That’s the shift. It’s not about looking perfect. It’s about being unique and echoing what Gen Z values—authenticity, creativity, and fun. Brands that get this will win their hearts.

Be Entertaining

To seize the fleeting focus of Generation Z, content must radiate with energy and immediacy. This demographic moves with swift clicks and swift judgment across digital landscapes, only pausing for content that strikes a chord of genuine interest. To halt their rapid-fire tab-switching, marketers must craft engaging but also punchy and memorable videos. Consider the approach of viral challenges and concise tutorials, which are not just watched but experienced and shared.

Fenty Beauty exemplifies this brilliantly with their tutorials that are more than quick—they are a burst of vibrancy, a feast of motion and hue, arresting the Gen Z scroll and sparking a moment of active engagement.

Build a Community

Generation Z’s concept of community is intrinsic to their interaction with brands. They seek connections that resonate personally, not just transactions that end at the checkout. Brands, therefore, must evolve into communities, places where dialogue and personal stories are as integral as business goals and the products offered. This generation values the authenticity found in real stories and relatable faces over the distant allure of influencer endorsements.

It’s about creating a space that feels less like a marketplace and more like a meeting ground—a haven where voices are heard, and individual narratives intertwine with the brand’s ethos. This is where liking a brand evolves into living with it, in a space where Gen Z finds products and a sense of place and community.

Conclusion

To wrap up, marketing to Gen Z means being upfront about your brand’s values and mission. Be clear and own up to mistakes. Show off your brand’s true personality. It should be lively and genuine. Keep them entertained with content that pops up and makes them pause. Don’t forget to build a community. It’s about connection.

These five strategies are key to winning over Gen Z. They value honesty, boldness, fun, and a sense of belonging. Get these right, and you’ll not just reach Gen Z.

Featured Image by Thought Catalog on Unsplash

The post Marketing to Gen Z: Strategies for Reaching the Next Generation of Consumer appeared first on noupe.

Few modern companies could operate without some element of remote working. Remote employees enable a company to get the best people, without the barriers of location or the cost of transport and office space. There are undoubted benefits to remote staffing. Managed well, remote employees can augment your business’s available skills and productivity. 

But how do you ensure that remote employees are well-trained enough to play their part in your company’s success?

Source: Pixabay

As with in-person tuition, training remote employees requires a good teacher, great materials, and reliable technology. But remote training has some unique considerations and best practices that are worth considering. 

We’re going to look at five best practices for training remote employees that a business must get right.

What are the advantages of remote training?

Because remote working is embedded in the way most businesses operate, firms have adapted processes and procedures to serve remote employees, even offering remote work stipends to help new hires optimize their home work environment. As well as ways to onboard remote staff, video meetings, and flexible hours, companies have changed the way training is conducted. 

These changes have been necessary, but remote training also has clear advantages for the business as a whole.

Available anywhere

Training delivered remotely doesn’t need a classroom. It’s available to any employee no matter where they are located. This is as much an advantage for remote workers as for in-house staff based in different locations.

Saves time

Recorded sessions, available when it suits the individual remote worker, meaning they can easily accommodate training into their day. Multiple staff members can also study the material at any time, removing the necessity of booking a room at a certain hour. Even for live sessions that do have a set time, employees can watch a recording, and send in any questions before or afterwards.

Personalized and flexible

With the online training software now available, running remote training sessions can be both personalized and flexible. Topics can be divided into digestible segments that remote workers can access when convenient. Employees can also receive sessions tailored to their particular roles and needs. 

Provides data 

A huge advantage of online training sessions is that data gathered from interactive activities and tests, can easily be logged. This data provides a clear picture of where employees are doing well or struggling, and where they might need extra training. Data also shows how well the learning materials are doing their job, and where improvements are needed.

Free to use image sourced from Unsplash

What are the challenges of remote training?

It’s unrealistic to paint a picture of training remote employees as always seamless. There are practical challenges to not having everyone in a room together. A trainer can’t spot those who are falling behind so easily. 

Employees can’t work together on activities as comfortably in separate locations. Different time zones and shifts mean employees are often studying alone, without input from fellow learners, and having to compete with the distractions of their home environment.

Technical issues

The biggest challenge of training remote employees is getting the technical support right. Learners can unwittingly be on mute, content can’t be viewed properly on-screen, or audio isn’t clear. Sometimes recordings of sessions aren’t enabled or subtitles are missing or incorrect.

Content lacking

The quality of learning materials is an issue for both in-person training and remote sessions. But quality is particularly vital for online learning. Without the presence of a trainer and their ability to interpret and enliven the content for learners, the materials will have to work much harder. 

Information inaccessible

With remote employees, each learner will be accessing the training materials separately from their home; this can add an extra challenge. If learning content isn’t logically and centrally stored, where each learner can easily locate it, it can lead to training being missed or incomplete. It can also make the learning experience frustrating and demotivating, and can waste employees’ valuable time.

Hard to Monitor Learning

When learners are not in the same physical space as their trainer, it can be much harder to monitor exactly how they are progressing. Tests and activities can help, but that simple human ability to look at a person and see that they are confused or struggling is absent. It’s also much harder to gauge which learners are falling behind and which are leaping ahead.

A trainer simply can’t supervise the learners in the same way as with an in-person class, and this has to be carefully factored in when designing remote training sessions.

How do you train remote employees? 5 best practices

We’ve looked at the advantages and the challenges of training remote employees; now let’s focus on five ways you can ensure your remote staff get the training they, and your business need and deserve.

1. Plan and set clear goals

Whatever the nature of the content you want to share with your remote team, whether it’s hardcore technical training or softer skills such as time management for remote workers; planning and setting goals is a must. 

Even a social or introductory section of the course should have a purpose, i.e, to introduce the topic and help learners familiarize themselves with the course structure.

Every aspect of the training you design should have clear objectives which are measurable. Short tests or quick, fun activities can follow each segment to make sure objectives are being met.

Be realistic about what a learner can digest and accomplish in a particular time-frame. Make a schedule that will impart all of the content at a pace that a person can comfortably fit into their busy working day.

Free to use image sourced from Unsplash

2. Include orientation

Nobody likes starting a task without having some idea of how long it will take and what will be involved. Make sure your learners have a clear plan of the time commitment and style of the activities before they start. 

Establish where to get technical help, supply secure remote support, and let learners know how to ask a question or raise a concern. Show them some examples of the type of activities you are expecting them to do, how to complete them, and what to do if they have any difficulties.

Above all, try the whole course out for yourself, put yourself in a learner’s shoes. Make a note of anything you would like to know or need to have explained. Include all of this in an orientation package.

3. Make content engaging

Great content should be tailored to the learner’s needs and style of learning. The materials should be engaging and user-friendly, and specific to the job requirements. Info dumping, in other words giving employees pages of text to read is not advisable.

Interactive content helps learners take in information and apply what they have learned.

Variety of content keeps learners engaged. For example, videos, games, stories, and audio content, as well as short texts. Longer texts can be broken up or downloaded to read later.

Include a social element, even for employees who are not studying at the same time. A chat facility can be accessed at any time, and can give learners the chance to talk to each other and exchange questions and observations.

4. Ensure access

Making sure employees have access to technical support with a remote desktop connection manager is key. Check that each employee’s home tech setup is suitable and that sessions function on multiple devices in case one fails to work. 

Ensure all relevant links and passwords are sent to learners ahead of time. Give them ample opportunity to iron out any access hitches before training begins. Everything they will need in terms of content should be stored in a logical, intuitive manner, with clear instructions about how to access it sent in advance.

Consider creating a cheat sheet with all the most important elements learners will need to access the virtual classroom. Include passwords and the locations of the most relevant materials.

Above all, accommodate every learner, and find out about disabilities and special requirements well ahead of time. Send a questionnaire to assess your needs before designing your training sessions.

Additionally, make sure to pay special attention to the onboarding experience for new remote employees. A well-structured onboarding process is crucial to ensure they start their remote work journey on the right foot and feel integrated into the company culture.

To ensure a seamless implementation of these best practices, collaborate closely with your coworking space manager or shared office management, if applicable, to accommodate the unique needs of remote employees in these environments.

5. Track results and collect feedback

Another advantage of the virtual classroom is that it provides data. This is valuable not only in tracking your learners’ progress but also in improving future training. Post-training surveys provide insights into where learners got the most out of the training and where they needed better content. 

If data shows learners all struggled in one particular area, this guides you to run more training for all employees on that topic. However, if only a few had challenges, it’s an opportunity to reach out to those individuals, providing additional help.

Ask what learners enjoyed the most about the training, and find out if there were any other areas not covered in the sessions that they would like help with. This information can steer you to design more useful and fulfilling future training.

Effectively train your remote employees 

There are undoubted challenges in training a remote workforce. It can be hard to create the buzz and connectedness of having everyone together in a physical space. But as we have seen there are also many advantages.

Your remote employees are as integral to your business as those you see at the coffee machine every day or share an office with. Remote training, effectively designed, planned, and executed, can help the business and its employees wherever they are based, have the skills and know-how to work towards a common goal.

Featured image by LinkedIn Sales Solutions on Unsplash

The post 5 Best Practices for Training Remote Employees appeared first on noupe.

In today’s fast-paced business world, adapting to modern practices is essential for achieving excellence in performance reviews. The onboarding process and performance reviews are two critical components in nurturing a high-performing workforce. This comprehensive guide, “The Onboarding Revolution: Achieving Excellence in Performance Reviews,” delves into embracing modern onboarding trends, fostering feedback and communication in performance reviews, leveraging technology for both onboarding and reviews and building a culture of continuous improvement. By the end of this article, you’ll be well-equipped to revolutionize your organization’s approach to onboarding and performance reviews.

Embracing Modern Onboarding Trends

To excel in performance reviews, it’s imperative to embrace contemporary onboarding trends that adapt to our ever-evolving work landscape. Modern onboarding is characterized by the following key components:

Firstly, Personalization and Tailoring take center stage, where the onboarding process is customized to cater to individual employee needs, aligning with their role, skills, and preferences. The shift towards Virtual and Remote Onboarding becomes vital as remote work continues to rise. Embracing technologies like video conferencing, digital training materials, and virtual office tours ensures a seamless virtual onboarding experience. Inclusivity and Diversity are fundamental, emphasizing the importance of accommodating the diverse backgrounds and needs of new hires. Gamification and Interactive Learning make learning enjoyable and memorable, fostering engagement and participation in the onboarding journey. Additionally, Employee Well-being is at the forefront, acknowledging the significance of work-life balance and mental health support for new hires. Modern onboarding extends beyond the initial days and weeks, evolving into a Continuous Onboarding process that spans the first few months to facilitate a seamless transition and long-term success. These trends collectively form the cornerstone of contemporary onboarding, essential for achieving excellence in performance reviews.

Feedback and Communication in Performance Reviews

Effective feedback and communication are pivotal in the success of performance reviews. To make them central to your review process, consider these strategies:

Promote Frequent Check-Ins between managers and employees. These 1 on 1 meetings serve as a platform for continuous communication and feedback, enabling timely adjustments and ongoing dialogue. Fostering a culture of Open and Honest Dialogue is essential during performance reviews. Creating an environment where employees feel comfortable sharing their thoughts and concerns ensures that feedback is genuine and constructive.

When providing feedback, focus on its Constructive nature, emphasizing improvement. Specific, balanced, and future-oriented feedback guides employees toward growth. Incorporate Peer Feedback into the review process to gain a well-rounded view of an employee’s performance and promote a sense of teamwork. Including Self-Assessment as part of the review allows employees to reflect on their progress and achievements. Last but not least, remember to express Recognition and Appreciation for employees’ accomplishments. Positive feedback serves as a powerful motivator, reinforcing good performance and encouraging continued excellence. By integrating these elements into your performance review process, you’ll foster a culture of productive feedback and open communication, even when addressing areas that require improvement.

Leveraging Technology for Onboarding and Reviews

Harnessing the transformative potential of technology has the capacity to revolutionize not only modern onboarding practices but also the landscape of performance reviews. Elevating these essential processes involves the strategic integration of innovative technological tools. A paramount step is the adoption of Digital Onboarding Platforms as a foundational investment. These platforms empower new hires to seamlessly navigate paperwork and training online, offering a centralized repository for onboarding resources while meticulously tracking their progress. Simultaneously, the implementation of Performance Management Software is indispensable for simplifying the review process. This software efficiently schedules evaluations, gathers comprehensive feedback and closely monitors ongoing employee development.

Adapting to the prevailing trend of remote work necessitates the utilization of Video Conferencing tools. These tools facilitate virtual onboarding experiences and remote performance reviews, mitigating geographical constraints and ensuring the benefits of face-to-face interactions are preserved. Furthermore, the strategic integration of eLearning Solutions for training and skill development ensures that employees have convenient access to materials, promoting a self-paced learning environment.

For gaining valuable insights into employee performance and areas for improvement, the incorporation of Data Analytics tools is imperative. These tools provide a data-driven approach to monitor progress towards established goals. Lastly, online Feedback Surveys offer a dynamic avenue for collecting employee input on both onboarding experiences and performance reviews. Analyzing the feedback data gleaned from these surveys becomes instrumental in driving necessary enhancements. By wholeheartedly embracing these advanced technological solutions, organizations can optimize efficiency, foster engagement, and ensure resounding success in both onboarding and performance review endeavors.

Building a Culture of Continuous Improvement

Fostering a culture of continuous improvement in onboarding and performance reviews is essential for organizational excellence, with a key focus on enhancing employee engagement. Here’s how to make this journey a part of your company’s DNA:

Start by establishing Feedback Loops, enabling the continuous collection of insights from employees and managers. Use this feedback to make iterative improvements to both onboarding and performance review processes, ensuring they align with evolving needs and goals. Schedule Regular Reviews of your onboarding program to keep it current and effective. This may involve updating training materials, reevaluating orientation procedures, and enhancing the overall onboarding experience.

Benchmark your processes against industry best practices, identifying areas for improvement to stay competitive and on the cutting edge. Invest in Training and Development to equip both employees and managers with the skills needed to succeed and adapt to new trends effectively.

Lastly, don’t forget to Celebrate Success by acknowledging and celebrating achievements and improvements in onboarding and performance reviews. Recognizing progress motivates your team and reinforces a culture of excellence, making continuous improvement a shared and valued endeavor that contributes to enhanced employee engagement.

Conclusion

The evolution of onboarding and the pursuit of excellence in performance reviews are indispensable for any forward-thinking organization. Embracing contemporary onboarding trends, fostering robust feedback mechanisms, utilizing cutting-edge technology, and nurturing a culture of continuous improvement are all pivotal in propelling your organization to new heights of success. As you embark on this transformative journey, it is crucial to recognize that this is a continuous process, demanding an unwavering commitment to excellence. Welcome to the onboarding revolution, where performance reviews become the linchpin for achieving and sustaining excellence in your organizational landscape. This commitment ensures that your organization not only keeps pace with industry advancements but becomes a trailblazer in setting new standards for success.

Featured image by Duncan Meyer on Unsplash

The post The Onboarding Revolution: Achieving Excellence in Performance Reviews appeared first on noupe.

There are times when mistakes happen, and useful and important files are deleted by error or lost from your file system irrevocably (or seemingly, at least). Version control systems make it difficult to permanently lose files, provided they have been either added to staging or committed to a remote repository, because Git allows you to undo or revert changes and access previous versions of the saved files.

It is also possible to erroneously erase files from both the working directory and the Git repository. I’ve certainly done that! I imagine you have, too, if you’re reading this, and if that’s the case, then you will need a way to recover those files.

I have a few methods and strategies you can use to recover your deleted files. Some are more obvious than others, and some are designed for very specific situations. And while it is indeed possible to irrevocably lose a file, even then, you may have a path to at least recover a copy of it with third-party software if it comes to that.

How Git Works With Files

Before we dive into all of that, let’s explore how your files journey from your local computer to your remote repository.

Your files are initially only located on your computer’s storage, known as your working tree or working directory, and Git has no idea they exist yet. At this point, they are at their most vulnerable state since they are untracked.

Adding files to the staging area — also known as the index — so that Git is aware of them is what the git add (or git add -A for all files) is for. What actually happens under the hood when pushing files to staging is that Git hashes the content and creates a blob for each file based on the file’s content and proceeds to store them in the /objects subdirectory located at .git/objects. Run git status to confirm that the files you want to commit have been added to your staging area.

Once the files are staged, Git is at least aware of them, and we can include them in commits. When including a file in a commit, Git creates a new tree object to represent the state of the repository at the time the commit happens. The tree object contains the following information:

• SHA-1 hash of the tree object that represents the state of the repository;
• SHA-1 hash of the commit’s parent commit object if it has a parent;
• Author and committer information;
• Commit message.

It’s at this point that the files are git push-ed to the remote repo, wherever you happen to be hosting it, whether it’s GitHub, Beanstalk, Bitbucket, or whatever.

How Files Can Get Deleted From A Working Tree

So, the key pieces we’re talking about are your project’s working tree, staging area and commit. It is possible for files to be deleted at any one of these points, but it’s the working tree where it is most irreversible, or at least tough, to restore a lost file.

There are some very specific Git commands or actions that tend to be the biggest culprits when a file is deleted from the working tree.

git rm

I’m sure you have seen this one before. It’s a command for removing (rm) files from the working tree. It might be the most commonly used command for deleting files.

git reset

Anytime a reset happens, it’s very possible to lose any files you’ve been working on. But there are two types of Git resets that make this possible:

1. git reset --hard
   This command is sort of a nuclear path for resetting a working tree and the staging area. If you’ve made any changes to tracked files, those will be lost. That goes for commits, too, which are discarded altogether. In fact, any files or directories that are not in the HEAD commit are removed from the working tree.
2. git reset
   This is a lot less damaging than a hard reset, but it does indeed remove the specified file from the working tree. But it’s worth mentioning that the file is not pulled out from the staging area. So there’s a path back, which we’ll get to.

git clean

This removes untracked files from the working tree. Untracked files are not in the Git staging area and are not really part of the repository. They’re typically temporary files or files that have not yet been added to the repository.

One key distinction with a clean command is that it will not remove files that are included in a project’s .gitignore file, nor will it remove files that have been added to the staging area, nor ones that have already been committed. This can be useful for cleaning up your working tree after you have finished working on a project and you want to remove all of the temporary files that you created.

Like git reset, there are different variations of git clean that remove files in different ways:

• git clean
  Used to remove specific files from the working tree.
• git clean -d
  Removes untracked files from a specific directory.
• git clean -i
  This one interactively removes files from the working tree. And by that, I mean you will be prompted to confirm removal before it happens, which is a nice safeguard against accidents.
• git clean -n
  This is a dry run option and will show you the files that would be removed if you were to run the original git clean command. In other words, it doesn’t actually remove anything but lets you know what would be removed if you were to run an actual clean.
• git clean -f
  This one forces the git clean command to remove all untracked files from the working tree, even if they are ignored by the .gitignore file. It’s pretty heavy-handed.
• git clean -f -d
  Running this command is a lot like git clean --f but wipes out directories as well.
• git clean -x
  This removes all untracked files, including build products. It is best used when you want to wipe your working tree clean and test a fresh build.
• git clean -X
  This only removes files ignored by git.

Of course, I’m merely summarizing what you can already find in Git’s documentation. That’s where you can get the best information about the specific details and nuances of git clean and its variants.

Manually Removing Files

Yes, it’s possible! You can manually delete the files and directories from your working tree using your computer’s file manager. The good news, however, is that this will not remove the files from the staging area. Also, it’s quite possible you can undo that action with a simple CMD + Z/CTRL + Z if no other action has happened.

It is important to note that manually removing files from the working tree is a destructive operation. Once you have removed a file from the working tree that has not been added to a commit, it is almost impossible to undo the operation completely from a Git perspective. As a result, it is crucial to make sure that you really want to remove a file before you go this route.

But mistakes happen! So, let’s look at a variety of commands, strategies, and — if needed — apps that could reasonably recover deleted files from a working directory.

How Files Can Be Recovered After Being Deleted

Git commands like git checkout, git reset, git restore, and git reflog can be helpful for restoring files that you have either previously added to the staging area or committed to your repository.

git checkout

If you have not committed the changes that deleted the files and directories, then you can use the git checkout command to checkout a previous commit, branch, or tag. This will overwrite the working tree with the contents of the specific commit, branch, or tag, and any deleted files and directories will be restored.

git checkout HEAD~ <filename>

That will take things back to the last commit that was made. But let’s say you’ve made several commits since the file was deleted. If that’s the case, try checking out a specific commit by providing that commit’s hash:

git checkout <commit-hash> <filename>

Oh, you’re not sure which file it is, or there are more files than you want to type out? You can check out the entire working tree by committing the filename:

git checkout <commit-hash>

git reset

If you have committed the changes that deleted the files and directories, then you can use the git reset command to reset the HEAD pointer to a previous commit. This will also overwrite the working tree with the contents of the specific commit, and any deleted files and directories will be restored in the process.

git reset <commit-hash>

git restore

If you want to restore deleted files and directories without overwriting the working tree, then you can use the git restore command. This command restores files and directories deleted from the staging area or the working tree. Note that it only works for tracked files, meaning that any files that weren’t git add-ed to the working tree are excluded.

git restore --staged <filename>

To jump back one commit, you could go back to the --worktree instead of the staging area:

git restore --worktree <filename>

And, of course, leave out the filename if you want to restore all files in the working tree from the previous commit:

git restore --worktree

Another option is to restore all of the files in the current directory:

git restore .

git reflog

There’s also the git reflog command, which shows a history of all recent HEAD movements. I like this as a way to identify the commit that you want to checkout or reset to.

git reflog

Last Resorts

When files that are neither present in the staging area nor committed are deleted from the working tree, it is commonly accepted that those files are gone forever — or oti lor as we say in Yoruba — without any hope of recovery. So, if for any reason or by error, you delete important files from your project’s working tree without ensuring that they are either in the staging area or have been previously committed, then you may be thinking all hope of getting them back is lost.

But I can assure you, based on my experiences in this situation, that it is usually possible to recover all or most of a project’s lost files. There are two approaches I normally take.

File Recovery Apps

File recovery tools can recover lost or deleted data from your storage devices. They work by running a deep scan of your device in an attempt to find every file and folder that has ever existed on your storage device, including deleted and lost files and folders. Once the files have all been found, you can then use the data recovery tool to restore/recover the files of your choice to a new location.

Note: Some of the deleted and lost files found may be corrupted and damaged or not found at all, but I am certain from my experience using them that the majority will be found without any corruption or damage.

There are a variety of file recovery tools available, and the “right” one is largely a subjective matter. I could spend an entire post exclusively on the various options, but I’ve selected a few that I have used and feel comfortable at least suggesting as options to look into.

Wondershare Recoverit is capable of recovering more than 1,000 file formats. Its free tier option allows you to run a scan to find files on your computer’s storage, but to actually recover the files, you will have to do a paid upgrade to one of its paid plans starting at a $69.99 annual subscription or a one-time $119.99 license. There’s a premium plan for more enhanced recovery methods for things like videos and files, as well as fixing corrupted files that go well beyond the basic need of recovering a single lost file.

• Pros: High success rate, free tech support, allows partition recovery.
• Cons: Free tier is extremely limited.

EaseUS Data Recovery Wizard is perhaps one of the most popular tools out of what’s available. Its free tier option is quite robust, running a deep scan and recovering up to 2GB of data. The difference between that and its paid subscription (starting at $119.95 per year, $169.95 lifetime) is that the paid tier recovers an unlimited amount of data.

• Pros: Fast deep scans, file preview before recovery, easy to use, generous free tier.
• Cons: Paid plans are significantly more expensive than other tools, Windows and macOS versions are vastly different, and the macOS software is even more expensive.

DM Disk Editor (DMDE) makes use of a special algorithm that reconstructs directory structures and recovers files by their file signature when recovering solely by the file system proves impossible. DMDE also offers a free tier option, but it is quite limited as you can only recover files from the directory you have selected, and it only recovers up to 4,000 files at a time. Compare that to its paid versions that allow unlimited and unrestricted data recovery. Paid plans start at $20 per year but scale up to $133 per year for more advanced needs that are likely beyond the scope of what you need.

• Pros: High recovery success rate, generous free tier, reasonable paid tiers if needed.
• Cons: I personally find the UI to be more difficult to navigate than other apps.

As I said, there are many, many more options out there. If you’re reading this and have a favorite app that you use to recover lost files, then please share it in the comments. The more, the merrier!

Last Resort: git fsck

First off, the git fsck command can be dangerous if used incorrectly. It is essential to make sure that you understand how to use the command before using it to recover files from the working tree. If you are unsure how to proceed after reading this section, then it is a good idea to consult the Git documentation for additional details on how it is used and when it is best to use it.

That said, git fsck can indeed recover files lost from the working tree in Git and maybe your absolute last resort. It works by scanning the Git repository for “dangling” objects, which are objects that are not referenced by any commit. The Git docs define it like this:

dangling object:

“An unreachable object that is not reachable even from other unreachable objects; a dangling object has no references to it from any reference or object in the repository.”

This can happen if a file is deleted from the working tree but not committed or if a branch is deleted, but the files on the branch are not deleted.

To recover files lost from the working tree using the git fsck command, follow these steps:

• Run git fsck –lost-found, which is a special mode of the git fsck command.
  It creates a directory called .git/lost-found and moves all of the lost objects to that directory. The lost objects are organized into two subdirectories: commits and objects. The /commits subdirectory contains lost commits, and the /objects subdirectory contains lost blobs, trees, and tags. This command prints the dangling objects (blobs, commits, trees, and tags) if they exist.

• Run the git show command for each dangling object that is printed.
  This will print the content of the object and enable you to see the original content of the hashed object so you can identify the dangling objects in the case of files dangling blobs that correspond to the files that you want to recover.
• To recover a dangling object, you can manually copy the content of the printed in the console when you run the git show command or run git show > command to save the content of the hashed object to the file you specified in the command. You can also use the git checkout command to restore the file to the working tree.

Once you have recovered the files that you want to recover, you can commit the changes to the Git repository as if nothing ever happened. Phew! But again, I only advise this approach if you’ve tried everything else and are absolutely at your last resort.

Conclusion

Now that you know how to recover files lost from your working tree, your mind should be relatively at ease whenever or if ever you find yourself in this unfortunate situation. Remember, there’s a good chance to recover a file that may have been accidentally deleted from a project.

That said, a better plan is to prevent being in this situation in the first place. Here are some tips that will help you prevent ending up almost irrevocably losing files from your working tree:

• Commit your files to your Git repository and remote servers as quickly and as often as you create or make changes to them.
  There is no such thing as a “too small” commit.
• Routinely create backups of your project files.
  This will help you recover your files if you accidentally delete them or your computer crashes.

Further Reading On SmashingMag

• “A Guide To Undoing Mistakes With Git (Part 1),” Tobias Günther
• “How To Make Life Easier When Using Git,” Shane Hudson
• “Improving The CI/CD Flow For Your Application,” Tom Hastjarjanto
• “Getting The Most Out Of Git,” Tobias Günther

If you haven’t been able to keep up with my blistering pace of one blog post per year (if that), I can’t blame you. There’s a lot going on right now. It’s a busy time. But let’s pause and take a moment to celebrate that Elon Musk destroyed Twitter. I can’t possibly say it better than Paul Ford (how could I?) so I’ll just refer you there:

Every five or six minutes, someone in the social sciences publishes a PDF with a title like “Humans 95 Percent Happier in Small Towns, Waving at Neighbors and Eating Sandwiches.” When we gather in groups of more than, say, eight, it’s a disaster. Yet there is something fundamental in our nature that desperately wants to get everyone together in one big room, to “solve it.” Our smarter, richer betters (in Babel times, the king’s name was Nimrod) often preach the idea of a town square, a marketplace of ideas, a centralized hub of discourse and entertainment—and we listen. But when I go back and read Genesis, I hear God saying: “My children, I designed your brains to scale to 150 stable relationships. Anything beyond that is overclocking. You should all try Mastodon.”

It’s been clear for a long while now that the social media strategery of “jam a million people in a colosseum and let them fight it out with free speech” isn’t panning out, but never has it been more clear than now, under the Elon Musk regime, that being beholden to the whims of a billionaire going through a midlife crisis isn’t exactly healthy for society. Or you. Or me. Or anyone, really.

I tried to be fair; I gave the post-Elon Twitter era a week, thinking “how bad could it possibly be?” and good lord, it was so much worse than I could have possibly ever imagined. It’s like Elon read the Dilbert pointy-haired-manager book on management and bonked his head on every rung of the ladder going down, generating an ever-growing laundry list of terrible things no manager should ever do. And he kept going!

It’s undeniably sad. I really liked Twitter, warts and all, from 2007 onward. In fact, it was the only “social network” I liked at all. Even when it became clear in the Trump era that Twitter was unhealthy for human minds, I soldiered on, gleaning what I could from Twitter. I’m not alone in that; Clay Shirky’s moribund signoff at the end of 2022 was about how I felt:

Indeed, Twitter was murdered at the whims of a billionaire high on Ketamine while it was (mostly) healthy, because of the “trans woke virus”.

I encourage you, all of you, to disavow Twitter and never look at it again. No one who cares about their mental health should be on Twitter at this point, or linking to Twitter and feeding it the attention it thrives on. We should entomb Twitter deep in concrete with this public warning on its capstone:

In the end, I begrudgingly realized, as did Paul Ford, that Elon unwittingly did us a favor by killing Twitter. He demonstrated the very real dangers of becoming beholden to any platform run by a king, a dictator, a tyrant, a despot, an autocrat. You can have all your content rug-pulled out from under you at any time, or watch in horror as your favorite bar… slowly transforms into a nazi bar.

I’ve been saying for a long time that decentralization is the way to go. We can and should have sane centralized services, of course, but it’s imperative that we also build decentralized services which empower users and give them control, rather than treating them like digital sharecroppers. That’s what our Discourse project is all about. I propose collective ownership of the content and the communities we build online. Yeah, it’s more work, it’s not “free” (sorry not sorry), but I have some uncomfortable news from you: those so-called “free” services aren’t really free.

Which, again, is not to say that “free” services don’t have a place in the world, they do, but please don’t harbor any illusions about what you are giving up in the name of “free”. Grow up.

I take a rather Tron-like view of the world when it comes to this stuff; in the software industry, our goal should be to empower users (with strong moderation tools), not control them.

So I encourage you to explore alternatives to Twitter, ideally open source, federated alternatives. Is it messy? Hell yes it’s messy. But so is democracy; it’s worth the work, because it’s the only survivable long term path forward. Anything worth doing is never easy.

I’m currently on Mastodon, an open source, federated Twitter alternative at https://infosec.exchange/@codinghorror – I urge you to join me on the Mastodon server of your choice, or quite literally any other platform other than Twitter. Really, whatever works for you. Pick what you like.

To encourage that leap of faith, I am currently auctioning off, with all funds to benefit the Trevor Project which offers assistance to LGBTQ youth, these 10 museum quality brass plaques of what I consider to be the best tweet of all time, hands down:

(Blissfully, @horse_ebooks is also on Mastodon. As they should be. As should you. Because everything happens so much.)

If you’d like to bid on the 10 brass plaques, follow these links to eBay, and please remember, it’s for a great cause, and will piss Elon off, which makes it even sweeter:

https://www.ebay.com/itm/225895658859
https://www.ebay.com/itm/225895658395
https://www.ebay.com/itm/225895657953
https://www.ebay.com/itm/225895656856
https://www.ebay.com/itm/225895655560
https://www.ebay.com/itm/225895655243
https://www.ebay.com/itm/225895654889
https://www.ebay.com/itm/225895654391
https://www.ebay.com/itm/225895654002
https://www.ebay.com/itm/225895653408

I will sign the back of every plaque, because each one comes with my personal guarantee that it will easily outlive what’s left of Twitter.

We operate in a business space wrought with misalignment between business objectives and customer needs. It’s fascinating to see that while 69% of business leaders are pushing more budget towards personalization, 72% don’t actually consider customer needs in their personalization.

To that end, today I thought I’d give you a quick overview of some low-effort, high-return customer success tactics to better bridge the gap between you and your clients. 

Within business and SaaS particularly, meeting customer outcomes is consistently proven to be a key driver of growth. So let’s review how you can learn, understand, and adapt to service those goals.

1. Implement feedback forms throughout your product

Implementing context-aware product feedback forms represents one of the most efficient ways to get high-impact, low-effort feedback tied to specific product functionalities. By adding these short in-product surveys, you’re:

• Giving customers every opportunity to voice their feedback
• Enabling an understanding of how customers feel about specific features and functionalities
• Allowing single users to voice their unfiltered feedback without going through the account owner
• Reassuring customers that you value their opinions
• Reaffirming that by implementing high-value feedback and then going back to notify the original customers who provided said feedback.

Here’s an example of a feedback form from Jotform that you can use inside the product:

2. Launch a voice of the customer initiative

If you want to go even further from in-product forms, you can build on those to design a full voice of the customer (VoC) program within your organization. A VoC initiative does wonders for company-wide customer success alignment, allowing you to efficiently boost retention and revenue with ease just by zeroing in on what actually matters for customers.

Here’s a breakdown of things to keep in mind for a VoC process:

One of the biggest advantages of a VoC initiative is that it keeps all relevant stakeholders in the loop and allows for increased velocity for deploying product updates. Just take a look at the simple steps of a typical voice of the customer program: 

• gather the feedback
• handpick the most insightful suggestions
• forward those to stakeholders and those who can act on it
• make related adjustments and changes
• close the VoC loop by going back and informing the customer once you’ve reached a resolution or product update

Of course, the process will change based on your business specifics, but the core elements remain the same and can be applied at scale.

3. Proactively reach out based on account data

Proactivity is one of the great pillars of customer success. It holds customer relationships up by allowing CSMs to see potential issues before they happen.

Now, proactive engagement within SaaS can mean different things based on your engagement model and account specifics. The overall approach involves:

• Setting up your customer success platform to monitor account activity and identify friction points.
• Creating a trigger for your CS tool to notify you whenever those common friction points resurface for a specific customer.
• Stepping in manually or through automation to check in with the customer and make sure they’re okay and not stuck mid-product flow.

The distinction between manual engagement and automated messages varies mostly based on the engagement model and CSM workload:

• For high-touch SaaS, CSMs must step in manually and talk to the customer directly, preferably via their most common channel for communication.
• For tech-touch and low-touch, automation flows can deliver solutions in a timely manner, but you should go one step further and ask customers if they’ve actually helped them or if they require the assistance of a real person.

4. Hold very high-touch onboarding and implementation meetings

For this point on our list, you need to be in that tech-touch-to-high-touch range for your engagement model. Otherwise, it may be a waste of your time and budget to attempt it for upwards of hundreds of accounts.

However, I believe high-touch onboarding to be essential when you’re in a type of business that services very demanding customers. Similarly, that’s also the case when you have a complex product or range of services. The more your customers have to work to get to their desired outcomes, the more you should be in touch with them during the onboarding stage.

Think of it like this:

• There’s no better way to know a customer than to sit down and talk about their problems.
• If you’re there with them as an ally in those initial stages, that relationship is only going to get better.
• If you can ensure their product implementation works and serves their goals, they’ll easily turn into retained, ideally loyal customers.
• The work to optimize onboarding into a positive experience will drive up your onboarding costs. However, it will also decrease your customer retention cost by a lot, so pay close attention to the balance and always remember retention is a constant effort and cost you need to support, while onboarding only happens one time per customer.

5. Use your customer success dashboards and analytics

While customer success will get you far once it gets going, it won’t get nearly as far as it could without a proper customer success toolset. Here’s a list of the usual suspects for kickstarting your CS machine:

•  A customer success platform with customizable dashboards and weighted health scores, allowing you to monitor customer activity in a goal-conscious way.
• A comprehensive list of communications tools and channels at the ready: from email to Skype, Zoom, Slack, Discord, and anything in between. Make sure you do your research and are prepared with the appropriate channels.
• Multiple ways for customers to request support: your SaaS users need to have ways to reach out at their disposal, from a live chat on the website and other support solutions set up and activated for their accounts.
• A product tour solution for low-touch accounts: not every SaaS can afford lofty one-to-ones with customers during onboarding. For low-touch products and overextended teams, a product tour can mean the difference between your customers immediately churning and becoming loyal.
• Account tools that prevent involuntary churn: a good portion of customers that leave do so passively due to expired payment options or because they simply forgot to renew. To actively prevent this, try using an account updater tool as well as dunning emails.

6. Encourage customer reviews and read what customers are saying

Last but definitely not least, you should encourage your customers to leave reviews on platforms such as G2, Capterra, and other similar ones. That way, you’re not just attracting new clients by putting the spotlight on you and growing your online presence; you can also use that feedback (which, by and large, tends to be brutally honest) to better understand customer needs and get to work improving your product.

Even if you don’t encourage customers to leave reviews, they might do so anyway. So check common review places and even the uncommon ones. Many SaaS make the mistake of ignoring reviews that don’t come through the usual channels – such as Google Maps reviews.

Summing Up

Putting customer needs ahead of your own in SaaS is not easy. Because of our bottom line and the KPIs assigned to us, it’s easy to start with what we want and try to get the customers to help us deliver. But it’s not a good way of doing business. Instead, we should actively help customers achieve their outcomes and, by extension, complete our own goals. Successful customers will always bring in more ROI than those left to their own devices – a simple 5% increase in retention rate has been shown to drive up profits anywhere between 25% and 95% (State of Customer Messaging in 2023). So, how are you making sure your customers’ needs are heard?

Featured image by Judy Beth Morris on Unsplash

The post How to Understand Customer Needs Using Customer Success appeared first on noupe.