🥳 You have completed all topics in the Handbook. Click here to claim your certificate!

1. Software development

Writing code is one thing. Contributing code to an existing project with other programmers and developers is a different ballgame altogether. What tools and processes do developers in modern, digital organizations rely on?

If you’ve worked in digital marketing for any amount of time, especially agency-side, you’ve probably encountered friction when interacting with developers in your organization.

This friction might manifest as much too complicated processes for something as simple as a Data Layer change on the page. You might also face constant deprioritization of your marketing-related tasks in favor of other, more “tangible” or “value-adding” tasks in the developers’ task queues.

Whatever the case, it’s important to understand one thing:

Communication breakdown between IT and marketers is due to lack of shared goals and lack of mutual understanding of each other’s work.

For the first, the main solution is transparency and cooperation. You need to make yourself available to the developers so that they can better understand the purpose of your requirements and how they contribute to the overall goals of the organization.

For the second, this Handbook Topic will hopefully help you understand the developers’ mindsets better. And maybe you can ask the developers to consult the other Chapters of this Handbook so they can get a deeper appreciation of your work, too!

Whatever the case, as a technical marketer you have the unique position in your organization to liaise between the process-driven, technical world of IT and the hectic, service-driven world of digital marketing.

Admittedly, much of this Topic revolves around stereotypes. Just like there are a gazillion different types of technical marketers out there, there’s an equal number of diverse IT organizations that might or might not operate on the principles outlined in this Topic.

Even so, it’s important to understand some of these key processes employed by modern developer-led organizations, so that you can feel comfortable (as a technical marketer) when interacting with these teams.

Task queues and prioritization

One of the first blockers in your path to getting your marketing tasks approved by developers is the task queue itself.

Now, there are many ways of maintaining a list of priorities for developers. There’s dedicated software (e.g. Jira, Asana, Trello…), whiteboards full of post-its, or even an email inbox for individual developers.

To get your technical marketing tasks even included in the mix requires that you take the time to learn the processes of task assignment in your organization.

Most often this revolves around crafting use cases and promoting your task so that it will be easier for developers to prioritize them.

It’s important to avoid assumptions and to follow the processes diligently. You might be intimately familiar with Data Layer as a concept, but your company’s developers might not.

Writing the task so that it has all the information developers need requires quite a bit of technical understanding from you. If you just link the developers to an online resource, it’s likely they won’t prioritize the task any time soon, as having to go through pages upon pages of developer documentation for a platform the developer has never used before can be seen as unnecessarily time-consuming.

In a perfect world, you would find a trusted developer in the team, work with them to design the tasks while at the same time explain to them what the tasks mean. This is a great way to distribute information, but it does mean that you need a) a trusted developer, and b) availability from this person.

Another option is to insert yourself into the developers’ task prioritization meetings so that you can explain the backlog items to the entire team. This is again a great way to disseminate information to a larger group of interested parties, but it does require that a) these meetings exist, and b) you have the knowledge and skills to explain your requirements properly.

Remember that the developers need to follow their prioritization processes so that they would always focus on the most relevant topics in any given sprint or unit of work. Don’t get frustrated if your tasks aren’t always prioritized. If you have time-sensitive tasks (such as an upcoming campaign), then that is a prioritization factor, and you need to be able to clearly state that when forwarding your requirements to the developers.

Deep Dive

How to write tasks and requirements

While there’s no perfect way to get your task prioritized, there are a handful of good practices to follow when crafting your requirements.

A good exercise for you is to always split each requirement into atomic parts. You can then offer the main requirement as a “user story”, and then you can link the smaller tasks to it. It’s always going to be easier for developers to take on a task like “Add the cart contents into the items array in the dataLayer” than “Build a proper purchase dataLayer“.

A task template typically needs to answer the “who”, “what”, and “why”. It also needs acceptance criteria, and you need to add all the relevant information to it so that it’s a self-contained task.

Here is a sample template you can use when crafting tasks and user stories.

Use whatever best practices your organization runs with. Remember to make the task self-contained. Ideally, by reading the task the developer would not need to consult you further, but do note that cooperation and participation are the best ways of getting tasks done, even if your role is to simply provide support.

Don’t miss this fact!

Your chances of getting your tasks approved and prioritized by your developers correlates with how well you understand and respect the developers’ processes. Take the time to understand these, get into good terms with the developers, and make sure you follow all guidelines designed for task generation and prioritization in your organization.

Coding processes and tools

If you are confident enough with your technical skills, you might be tempted to write the code for your tasks yourself.

After all, if all the developers are busy with other tasks, who better to roll up their sleeves and do the work than you?

However, contributing code to an existing software project (such as your website or your app) is more than just writing some lines of code in a code editor somewhere.

Your organization is probably using a version control system (such as Git) with isolated development and production environments.

There might be frameworks (such as React) or language extensions (such as Typescript) in use, and you need to know what the project structure looks like and what the process for adding new components is (or where the marketing-related components are maintained).

There is hopefully a style guide available for coding practices in your organization. This spells out how code should be formatted, what best practices are observed in your organization, and how code contribution happens. If no such style guide exists, then trying to identify development principles from existing code or by interviewing developers are available options, too.

You do not have to be an expert in programming or even well-versed in your company’s coding practices to be able to get your tasks prioritized. However, the better you understand the technical frameworks used by your developers, the more well-adjusted tasks you’ll be able to create.

Remember that developers are the ones who will read your tasks, and they’ll read them with their “developer brains”. They’ll have certain preconceptions about digital marketing, and if they need to align what they see in the task description with their existing processes without any further help or input from you, it’s possible your tasks will get deprioritized.

Deep Dive

Step-by-step for contributing code in a project

If you do want to contribute code to a project, here are general steps on how to proceed.

  1. Request access to the project repository. The company is probably using a software management service like GitHub, GitLab, or Bitbucket. It’s a good idea to learn the basics of how they work first and to have a good understanding of versioning systems like Git in general.
  2. Read the project README carefully. Hopefully, the project has a proper README file as well as additional documentation available. If not, you’ll need to get through the following steps by having a developer at your side walking you through what you need.
  3. Install the project locally. This way you can write code on your own computer and test it in the local development environment without having to worry about messing stuff in the remote repository.
  4. Carefully follow style guides and additional instructions. Often, there are best practices in your organization for how to write the code itself, how to organize the files, how to document, and how to write tests. If you want to start contributing code, you need to be aware of all of these things so that you don’t create extra work for the reviewers.
  5. Isolate related work in its own feature branch. By using branches, you ensure that the code you write does not modify the code in the main, production branch. When your feature is done, you can then submit a request to integrate your branch into the main branch and thus make it available in production.

While versioning systems like Git have built-in protections for avoiding merge conflicts (where the same part of the software is simultaneously changed in different branches) and for quickly rolling back changes if problems arise, you still need to be very careful when contributing code you’ve written.

Check, double-check, and triple-check that you’ve understood the contribution guidelines in your project.

Contribution guidelines in the Hugo project

Ready for a quick break?

To contribute successfully in your knowledge accumulation project, an important build step is to take a break right now. Walk around for a few minutes, get a glass of water, and when you return your learnings will be merged into your main knowledge hub (brain).

Automated tests and quality control

There’s more to writing code than just, well, writing code.

Your company might utilize quality control measures to make sure that whatever code is produced doesn’t break the build.


Modern companies typically employ continues integration / continuous development (CI/CD) pipelines where instead of monolithic releases every few weeks, code is constantly being deployed to production.

To avoid this code from being disruptive to existing, working processes, the build steps, where the code is compiled and deployed, typically introduce quality control procedures that must successfully pass in order for the build to complete successfully.

A typical example of code quality assurance is linting. Linting refers to automatic checks for syntax and style errors in your code. At its most basic, a linter will quickly alert you if your code has obvious syntax problems that prevent it from working properly. But a properly configured linter comes with embedded style instructions, too, such as Always use single quotes instead of double quotes and Always use spaces instead of tabs. These might seem superficial, but writing code consistently is a service to others who contribute to the project.

Another important quality control step is testing. When code is tested, it means that there are test cases written against the code in the project. If a test fails, it means that something has broken in the code that invalidates the test results. At that point either the code needs to be fixed or the test needs to be rewritten.

For example, one of your changes might be to update where the value for an Ecommerce purchase is derived from in the dataLayer object. However, in your haste to make the change, you didn’t notice that the value now uses a comma as the decimal separator rather than a period.

// Before
  ecommerce: {
    value: '195.10',

// After
  ecommerce: {
    value: '195,10',

When writing the code, you didn’t notice this. Luckily, the test coverage extends to these dataLayer interactions, and the test fails because one of the conditions is that currency values must always use a period and not a comma as the separator.

This issue is caught by the quality assurance step in the build pipeline, and the task is returned to you to fix before the build can be completed.

Writing proper test coverage, utilizing linters, and making use of all the other available quality assurance tools in your software project will ensure that your code has smooth sailing from writing to deployment.

Again, if you do not want to contribute the code yourself, understanding what QA processes your company uses will help you design your tasks so that they are resilient to potentially breaking changes in the future.

When you write a task, try to anticipate what types of tests might be best to write against that task. Make the developers’ work easier by being proactive about this. You’ll also ensure that your code doesn’t break with future deployments!

As a technical marketer, you might find that your marketing-related tasks are frequently deprioritized by developers. Don’t be discouraged! Remember that it’s more about communication and shared goals than anything else. Make sure that you have a good understanding of how the development processes in your organization work, and do your best to increase awareness about digital marketing needs for other parts of your organization, too.

Key takeaway #1: Communication and collaboration are key

In any organization, healthy communication structures are of utmost importance. With technical marketing, this is even more poignant. Technical marketing is an overlapping discipline – it has similarities with many different parts of a modern, digital organization. For this reason, being able to communicate fluently with different professionals is an absolutely vital part of the technical marketer’s skill set.

Key takeaway #2: Learn how developers work

Technical marketers that want to improve their collaboration with developers need to understand how the developers work. Marketers need to have an idea about the coding systems and style guides developers adhere to. Marketers need to know what project organization tools and processes developers use. Marketers need to be sensitive to prioritization principles, and they need to know how to submit use cases, bug reports, and feature requests so that they aren’t immediately deprioritized.

Key takeaway #3: Automated tests help ensure quality of marketing efforts

Tag management solutions make it tempting to add marketing tags and code to the site without involving developers. However, collaboration with site and app developers can lead to a stronger implementation especially if the developers include marketing-related code within the coverage of automated tests. Most marketers have been in a situation where some dataLayer code that used to work broke with a site update. This is because the code was not included in the test coverage when the site release was built. By working with developers, technical marketers can improve the prospects of data quality a great deal.

Quiz: Software Development

Ready to test what you've learned? Dive into the quiz below!

1. What is the biggest benefit of a version control system like Git?

2. Why are digital marketing tasks often deprioritized by developers?

3. Why are code tests written?

Your score is


What did you think about this topic?

Thanks for your feedback!
Next up

Unlock Premium Content

Simmer specializes in self-paced online courses for technical marketers. Take a look at our offering and enroll in one or more of our courses!