You Don’t Need to Be an Expert to Build Authority

One common fear that holds people back from publishing content on the Internet is that they aren’t qualified to do so. The fear of writing something wrong can be paralysing. Who are you to write about a particular topic when you are far less knowledgeable than 1000’s of other people out there? What if they call you out in the comments highlighting what a terrible coder you are?

I think that this fear is enforced in tech communities specifically, where there exists a toxic elitist culture in parts of the community. If somebody were to publish a particular solution to a problem, there is a good chance that someone will attempt to shame them with their superior knowledge.

I think this holds back a lot of would-be educators and bloggers from making positive contributions to their community, and from benefiting from the time and effort they put into helping people. I want to discuss why it doesn’t matter if you struggle with writing for loops, or if you know the internals of the Angular change detection mechanism like the back of your hand. You can write content that is valuable to people and establish yourself as an authority.

Knowing less can make you a more effective teacher…

If you are taking a serious approach to technical blogging, then your goal is most likely to establish yourself as an authority. If you want people to keep coming back and reading your content, and eventually buying your products, then you need them to trust that you know what you are talking about.

It may then seem disingenuous to attempt to position yourself as some kind of authority when perhaps you have only just recently learned the thing that you are writing about. You don’t need to pretend you are an expert, though, you just need to teach things. You don’t need to know everything about a particular topic in order to effectively teach a subset of that topic.

I would argue a lot of the time it will serve your readers better as you will be closer to their skill level. Having a deep understanding of a particular topic can make the more basic things seem trivial – a more knowledgeable person might take their understanding of asynchronous vs. synchronous code for granted, and quickly gloss over issues related to that. Somebody who has only just recently learned these concepts for themselves would be more likely to realise that it is something people might struggle with.

There is no need to lie or pretend you are better than you are. You learn things and then you write about things so that other people can learn a little easier than you did. You learn more things, and teach more things, and learn more things, and teach more things. There is nothing ingenuine about that.

Naturally, people will assume you are a lot more knowledgeable than you are. When you are constantly writing about how to do various things, it can give the perception that you just somehow innately know these things like some kind of super genius. In reality, the articles you write will probably consist mostly of things you may have just recently learned yourself through the power of Google.

What if you get things wrong?

You will, but it really is not a big deal. As far as I am concerned… ‘Tis better to have taught and been wrong than to have never taught at all.

There may be a lot of people out there more qualified to write and teach than you are, but they are not doing it. If someone points out something wrong you did in the comments then that is great, it will be a learning experience for both you and your readers. If someone insults your coding skills when you are attempting to educate people for free, then they are an asshole and should be ignored – learning to ignore assholes is an important skill.

Perhaps you end up teaching something that works but isn’t the best way to do things. I don’t think teaching someone to use document.getElementById where @ViewChild would have been more appropriate in Angular is going to permanently scar their learning. Nobody learns a new framework or language and adheres to perfect best practice right away.

There are two potential circumstances if you get something wrong, and I think both are acceptable:

  1. You teach something incorrectly and somebody points out the issue. Perfect, this is a great learning opportunity for everyone and would likely highlight some particular nuance.

  2. You teach something incorrectly and nobody points out the issue – readers leave with potentially incorrect information. This is not ideal, but I would argue that occasionally inaccurate information is generally preferable to none at all.

The only exception I would add to this is in situations where that misinformation might be dangerous. I think some common sense would need to be applied here. Obviously, it is not a big deal if someone uses document.getElementById in their Angular application. It is a big deal if you are attempting to teach people how to build an authentication system and incorrectly advise people to store passwords without hashing them.

If you are dealing with topics where mistakes could be dangerous, costly, or jeopardise a user’s privacy, it would be best to avoid it.

What should you write about?

If you aren’t already an expert with a wealth of knowledge to draw from, what do you write about? It is generally easiest and most effective to write about things that you have just been learning yourself.

A lot of the blog posts I write about, even today, are formed like this:

  1. I need/want to figure out how to do something
  2. I research how to do it
  3. I organise everything I learned into a coherent blog post

It’s easier to stay motivated to write this way. I’m learning and growing as a developer, and I also get to create content out of it.

When I started blogging about Ionic (this was back during Ionic 1.x) I had literally just started using it. I did have some previous experience with other frameworks so I wasn’t starting from scratch, but I knew next to nothing of Ionic.

But this is fine, and perhaps even preferable. It gives you a unique perspective, and you can utilise that. I think it’s important not to lie or try to position yourself as if you are an expert when you are not, just be honest. The first series of articles I wrote about Ionic looked like this:

  1. Learning the Ionic Framework as a Sencha Touch Developer: Part 1
  2. Learning the Ionic Framework as a Sencha Touch Developer: Part 2
  3. Learning the Ionic Framework as a Sencha Touch Developer: Part 3
  4. Learning the Ionic Framework as a Sencha Touch Developer: Part 4
  5. Learning the Ionic Framework as a Sencha Touch Developer: Part 5

I had decided to start using the Ionic framework after some controversial licensing changes to Sencha Touch. The posts did not provide any false pretense, I was open about the fact that I was new to Ionic. But, I was able to put my own interesting spin on it as a former Sencha Touch developer – making learning Ionic for other Sencha Touch developers who may have been in a similar situation easier.

As I started learning more about various aspects of the framework, I started writing more generic posts:

This went on and on until I had 100’s of tutorials about Ionic, and over that period I did become an authority on the subject (as well as becoming very well versed in the framework myself). Despite the fact that I started blogging about Ionic when I knew next to nothing about it, my blog (rather quickly) became one of the most widely viewed Ionic blogs.


You spend all this time researching, and writing, and researching, and writing. In the beginning, you may not know all that much, and your status as an authority in your field may come more quickly than you “deserve”.

Over time, you will accumulate a wealth of information through writing these articles. By teaching, you will ingrain these concepts into your head more deeply, as you are forced to learn the ins and outs of particular topics in order to teach them. In a way, that fear of being called out can help you learn better. Once you have done this for long enough, your authority status will start to feel more genuine (but try to remain humble as your reputation grows).

Although I do feel as though I know enough about Ionic now for people to look to me for advice, I didn’t have to wait until I was good enough before I started writing. If you do wait until you are good enough, that day will probably never come.