Thank you HN
It will no longer be about you. It will all be about your team. Make sure you create a great team, nurture them, train them, teach them how to think critically (in doing so yourself).
Ask your team to write out everything they plan to do before they actually do it. Reason with them on what they wrote and what approach decisions they plan to take. Teach them to think long term. Writing before actually doing the task helps get a lot of clarity to them and also helps you in assessing what they were planning to build. (It also makes for a great log of what we did and why we did it. This will be the product documentation for your entire product tomorrow.)
Treat your team like your family. Do not stress them out with too much work. Be respectful of their time and effort. Give them breaks post completion of major tasks. Every second that you let them rest and breathe is a second you have invested in the future. They will recharge and put their best in the next task.
You have a tough job of standing up for the right long-term tech decisions. Stay loyal to your product. Work for your product - not your company. Take tough tech decisions that will stand for the long term stability and robustness of your product. But occasionally make allowance for your business team too.
Sometimes your teammates might shy away from a big daunting challenge - step in and work side by side with them to tackle it. But do this infrequently.
There is a lot to add to the above list but in general the idea is to help your teammates grow, help them think critically, stand for your product - make the tough calls.
All the best!
- Not delegating. New leads often feel that if they're not writing code (or doing whatever it means to be an individual contributor), they're slacking off. The definition of "work" has changed. It now means "helping your team succeed". If you try to be an individual contributor, you are doing your old job instead of your new one, and you'll get overwhelmed and sink.
- Not asking questions. New leads often think that being a lead means being an expert, so they're embarrassed to ask or consult someone else about their team's domain, for fear of looking inadequate. Your team and your peers are the experts— it is your job to ensure that expertise prevails, whether it's yours or someone else's. You'll look much more dumb if you're too insecure to admit what you don't know, or fail to ask basic questions that allow you to get the job done.
- Hiding problems. When things aren't going well (and often they don't), don't hide this from the leadership above you. They are there to help you and guide you, and can save you from crashing and burning. You will look much worse if a problem comes to light months after it could have been communicated and dealt with.
- Not communicating. Share what's going on with your team. Share what's going on in the big picture. Don't keep people in the dark, either above you or below you.
Some leads (moreso if they're prone to impostor syndrome) think they have to wait for permission to speak, or to be offered something that they need— don't do this. If you have something important to say/ask, it's your responsibility as a leader to say it and get what you need.
- Forgetting the big picture. As an individual contributor, you often only have to think about near-term or small-scope problems. It is an easy mistake to make as a new lead to spend priority on those things instead of keeping in mind what's necessary for the entire team to succeed at its high level goal.
Good luck!
1) You will not need to trust others to write better code/systems then you and that you will very likely be unable to code anymore.
2) Establish a good relationship with your team members. Seek for people who you can delegate to and trust. Trust and reliable people are really hard to find. When shit hits the fan - and it absolutely does - you'll need that.
3) You need people who will push and people who will follow. Having just one group and not the others is a recipe for disaster.
4) Establish what things you should care for and what not. The amount of shit is insane and it only gets worse you need to have a threshold on when and on what to react.
5) Do you own research as much as possible on key things.
6) Keep asking "why". It annoys me as f* but also forces you to go deeper with explaining and understanding of the problem. (don't wanna say google "Five whys")
7) Encourage people to go deeper, to learn more to become experts.
9) Have 1-on-1s. Regular. Scheduled. Talk about life/work. Try to find how you can make the place and challenges better. Help them grow in an organisation and professionally.
10) Sketch things out. Write em' down. Otherwise, you'll go insane repeating stuff.
I sincerely wish you good luck.
P.s.: People have more bugs and are sometimes even more broken than software. :D
1. https://pragprog.com/book/jsengman/become-an-effective-softw..., which had a good conversation here (https://news.ycombinator.com/item?id=22033129).
2. https://managinghumans.com/ by Michael Lopes
3. https://leadingsnowflakes.com/, which also has a good weekly newsletter - http://softwareleadweekly.com/.
4. https://www.udemy.com/course/practical-leadership/
5. https://tomdemarco.com/Books/deadline.html - quite old now, but it's still hugely insightful.
May I wish you the best of luck. It's an exciting and really difficult challenge, but can be hugely rewarding in the end.
They assume the best of others.
They lead by example.
They are a facilitate as much as they delegate, and they don't lose sight of the fact that you can't lead from the trenches.
A good leader remains objective when it's hard to do so, and doesn't take it personally when somebody disagrees with them.
A good leader is kind, humble, and willing to help.
A good leader doesn't back down from using a firm approach when it's needed.
A good leader doesn't apologize for doing things that have to be done (discipline, firing etc).
Being a tech lead is only partly about the tech, and mostly about the lead. You'll ultimately succeed or fail based on your team.
Being an effective leader requires a completely different set of skills than being an effective engineer. This, as silly as it sounds now, took me by surprise. You may have a decade-plus of dev experience but still be starting from zero when it comes to people. (Or not; some people will be better equipped for this than others. I wasn't so much.)
Find a mentor. Someone you can be completely honest with, and who will be honest with you. Bonus points if they know your team well too -they'll see things that you won't.
You may have to be pretty intentional about finding out what's going on in your team. Once you're in a position of authority, people won't always feel free to tell you.
Share as much context with your team as you can. They'll be more motivated if they understand why their work is important and has value. Even if you understand this... people aren't mind readers. They don't know what's in your head.
Part of your job now is to be available to people. This may mean you don't get to actually work on the tech yourself as much (or at all). It may mean you get interrupted more. That's may or may not annoy you, but you need to make the best choices you can for your team now, not (just) for you.
Share success when you can. You may find yourself in situations where people attribute your team's success to you... and while that's not wrong (you're the lead after all) it's also a great opportunity to share credit with those in your team. It's worth so much to people when you do this.
People are not interchangeable, and treating them as if they invites trouble. You can have great people, who still have a hard time working together for whatever reason. Be aware of inter-team dynamics; they can sink you. (Situations like this are why it's great to have a mentor.)
It's important to keep a close eye on how things are going, but don't confuse that with micro-management. Your best people are going to want some autonomy, and it's best for everybody if you find a way to give it to them. If things aren't going so well your instinct may be to tighten your grip... not necessarily wrong, but consider that may come across as a lack of trust on your part.
Above all: think of your job as less about being in control (though you may be) and more about fostering an environment where your team can do your best work. Get them what they need, shield them from the crap, give them what opportunities you can. Don't be selfish or mean. Be kind, be empathatic.
Good luck.
A leader is best when people barely know that he exists, not so good when people obey and acclaim him, worst when they despise him. Fail to honor people, They fail to honor you. But of a good leader, who talks little, when his work is done, his aims fulfilled, they will all say, “We did this ourselves.”
Your role is now defined by what your team needs you to be. Listen to them, care, and see what you can do to help them thrive.
As a manager, this won't be the case. You won't get that instant reward like you did as an engineer. It might be months or even years between when you started something and you see any reward for it. It might be weeks before you even get feedback that something changed at all. Hell, you might never get to see the reward for a project you have in the oven. This can be very challenging to deal with when you are used to getting near real-time reward for your work.
You will have to adjust to the new reward cycle as you step out of coding for a day job. It's okay to have mixed feelings about it too. Just know that you will have to find other ways to find reward in what you do.
You succeed when your team succeeds... if they don't, then you don't.
In my case, I don't have any authority other than influence. That's ok, it also takes a lot of responsibility off my plate.
If you have authority over people, know that you can tell them what to do if you have to, but if you reach the point where that's all you can do, you've failed.
People are the only thing that matters. Deadlines come and go, companies go bankrupt or get their entire C-suite arrested in midnight raids, competitors come in and break everything and turn the company into a zombie. The thing that endures is the people. If you have good people on your team, consider yourself lucky; being a great boss is one of the best ways to cement a lifelong connection to the best people, and you'll get way more benefit from it than you deserve.
Nothing is straightforward or face value. Understand this and don't try to change it. There's a lot that you'll have to learn for yourself, but keep your priorities and loyalties straight, don't buy into anyone's bullshit too far, and you'll be fine. Good luck.
I would say what that means is, internally, you run interference to shield your reports from management incompetence and thrash, you take responsibility for failures, and internally promote (in the "promoter" sense) them. And externally, proactively provide professional advice and support, even if that means losing someone important to your team.
More than anything else, those are the qualities I strive to as a manager. (Not saying I'm perfect at it)
I’m only half joking. Hopefully your company is ‘one of the good ones’ and it will work out, but they are few and far between.
The tech lead job varies a ton from one company to the next, but all too often it comes with high expectations without enough autonomy or authority to deliver on them. Make sure your boss provides clear expectations and work with them to clarify boundaries over time. I’ve been on both sides of this process and it is difficult and necessary.
Too often, tech leads are expected to wear more hats than they are able to wear well. Delegate all that you can and if there is still too much work to do, ask for help.
It’s all about communication so actively work on this skill.
1. Remind yourself daily that the metrics you've used to gauge your own productivity or success until now do not apply. It's really hard. Resist the temptation to do non-TL things if it will affect your TL responsibilities.
2. Find other people who have more/broader experience than you do, and pay attention to the perspective they provide. There are many people who know more than most TLs but don't want the role themselves. You can help each other.
3. Remember that lead is as important as technical in your job title. Your role is to bring people to a place they're not already. Figure out what's missing in your project and/or your team members' skillsets. Those are the things that it's your job to address.
Also, remember to reserve time in your day to deal with problems raised by the team. These will often occur when you are least expecting them. And some may be outside your own comfort zone.
On a positive note I found that being a tech lead made me a better team member for my own management, since I better appreciated some of the leadership challenges they were under. You'll sometimes be left stunned by how hard or well your team members are working to solve problems, and this can make it all worthwhile.
Make sure that technical decisions are documented (e.g. via an ADR), making sure to document what you and your team know and consider at the time of writing. This is a pushback to hype-driven development; you don't want to be stuck with a bad decision just because one team member showed up at work one day with a feature implemented in technology X without proving they've done the work for it. And you don't want to have to waste time with future employees explaining (again) why technology X is used - you can refer to the docs, and if they want to challenge it, have THEM come up with counterpoints, have them sell it to you and the team, and have them defend the time / effort investment to change the technology.
Re: hiring, always do a technical interview, even if you're hiring internally. Involve your existing team members, they have to work with the new candidate after all. Have the applicant do a small project (4-8 hours) representative of the technologies and context of your project in their own time, and challenge them during the interview (the goal being they can prove they wrote and understood the code they produced).
1. Read the book Extreme Ownership by Jocko Willink. I'm not the first to suggest this book but it has fundamentally shaped how I work and how I interact with others.
2. Try to write. I'd start with writing your "Manager Readme" file even if you don't plan to share it with anyone. Defining expectations is critical and it's start with understanding your own psyche. What is important to you? What are your expectations for someone? The internet is filled with examples of Manager Readme's along with posts that are totally for this idea and totally against. You can find mine without too much trouble if you check my comment history and find my GitHub.
Good luck.
2. your job is transitioning from "doing" to "enabling". You'll be responsible for issues of governance AND operation. Learn the ropes equally. As you introduce successful operational concerns (bottom up) start to generalise them so they can be used as a top-down concern (i.e. i do devops -> we all do devops here, it's part of the training)
3. leading by example doesn't scale - stop. Embrace a teaching method that ends in trust: i.e. 1. introduce a concept to dev A, 2. get dev A to demonstrate it back to you independently (monitor and prompt as appropriate), 3. from afar passively observe future implementations of said concept and revert to steps 1..2 if required, 4. inform dev A that they are trusted explicitly with this concept and that it is theirs to run with - encourage them to onboard dev B in a similar fashion.
4. at the top you're more responsible for team morale than you can possibly imagine - random acts of kindness and/or direct conversations go a long way... whether it's donuts or "a quick catchup" over lunch, do it... regularly (if you find your postponing these kind of meetings you've got a priority inversion issue to sort out ASAP).
5. if someone is dishonest in any way take it to HR before they walk over you and your team/product/department suffers. In other words, with HR's help, address slow/no work or unapproved "wfh" days as a threat.
6. push back against harmful designs and rushed/skipped processes.
* Code in production = value. *
And the following (I am not the original author):
Ship small (seek the shortest path to show and deliver value to your customers)
Ship imperfect products (perfection is the enemy of done)
Ship for your users, not for you
Ship every day (it creates momentum!)
Focus on finishing (shipping), not starting
A shipped product is worth a thousand of blog posts
Ship first. Then iterate
More practically: I write down feedback that is given to me regarding leadership style and write down things that I think about at the 'moment of impact' (assumptions, reasoning, and metrics for success/failure of decision) when decisions are being made. Read over these notes often enough that you are aware of those things when they happen again. Anecdote: Developers often want time to create a quality feature and if they are frequently pressed for time due to business requirements, they are unhappy and the product suffers, often in less than obvious ways. It was only really obvious that this was a problem when we tried other ways of planning and prioritizing because the assumption was that development pressure was a given for a tech company, turns out that some development work can be offloaded by better planning and prioritization based upon better thought out business objectives. These learnings came about because we kept took notes of decisions that were made, and could refer back to them as crucial points of pain/cost/failure.
If you don't have some structure to your approach, you'll find it difficult to call out specific changes that need to happen.
There's a lot more that could be said. Tech leads are often interfaces for other parts of the business so respecting the context of other's roles and aligning incentives is more important than proving your job is being done 'correctly'.
He also just published another article about quality technical communication, which I'd highly recommend both you and your team read through: https://medium.com/@tpagram/a-guide-to-improving-your-techni...
1. Listen - Learn to Listen to Your customer and Team Members. Understand the reasoning behind what they are asking for.
2. Show, not only tell - I used to sit next to devs and see that problem they are mentioning is actually is problem. Sometimes issue could be business requirement. If technical issue, explain throughly teach how to go about solving such kind of problem. If they are still not able to do it fine, work with them while continue to explain. You want to teach - how to go about "solving problem".
3. Learn, Learn More and Learn More and Keep Learning and then Share - Learn about the business domain. Learn about technical domain. Learn about everything which lets you 'get things done'.
4. Delegate - But delegate properly, once task is assigned, make sure the team member understand what needs to be done. And they understand 'how it will be done'. You don't want to figure out at end of day that because of misunderstanding or lack of information task was not done correctly or worse has to be redone from the start. Reworking sucks big time and will suck big amount of time for everyone - you, team member and customer.
5. Get Details - Try to get as much as detail as possible, based on information take decision based on 'who is right for this job'.
6. Don't play favorites.
7. You dealing with Humans. People make mistakes. Find way to reduce chances of happening mistake in first place.
8. Be cool. Never get Angry. Anger drives out reason.
Good Luck.
If you are going to do it, read a ton of books. Minimum in my opinion are: 1. The Managers Path -- general advise 2. Coaching Habit -- for performing 1 on 1s 3. Extreme Ownership -- for building an effective culture that delivers results.
I transitioned into a tech lead a year ago and at first it was kind of annoyed by all the requests from the team regarding technical assistance.
I realized there were two paths I could take. 1. Continue to be annoyed and try to get as much coding in as I can. 2. Sit down with each individual, help them, give examples of how things should work etc.
Luckily I chose the latter option and I have a great relationship with all the team, I have strong coders that are more self-sufficient, and I enjoy more time coding now.
I think the lesson I learned is that you get out of your team much more than you put in, strive to inspire your devs.
It's okay to make mistakes. Really, you're going to make loads of them, and your team is going to make loads of them and you're going to own those mistakes.
It's now going to be more about getting the best out of your team than it is about squeezing out more code. I spent a lot of time beating myself up over how much code I wrote dropping off, there is a nice sweet balance you'll find.
Learn to delegate, and learn to do it early. You'll burn yourself out super quickly otherwise.
My primary advice is a strong "most people asking this question should not do this".
Not because you won't be good enough or grow into the job, but because it's a completely different job - and one that many programmers who actually like programming don't enjoy and in many cases aren't well suited for.
There are two toxic traps I should confront. The first is that titles like "tech lead" and "CTO" flatter your ego and impress your friends and parents. The only thing I can think of that exceeds this on the "sounds amazing today; tomorrow you'll start the rest of your miserable life" is an idealist taking money from a VC. Find a different way to impress your dad.
The second is that many companies do not understand how to incentivize programmers beyond "junior/intermediate/senior" (even architect is mostly just a senior who has to spend time managing, eg are distracted and less productive most days than a senior with a closed office) and you get to the point where the upper reaches of the programmer food chain are managing other programmers. Very few things could be more destructive. Honestly, it's fucking obnoxious.
You know what the very best programmers should get? A salary twice as big as the next best programmer, a quiet private workspace with permission to work from home, paid childcare and spousal assistance, and firm dedication from the management to insulate them from as many meetings and distractions as logistically possible. There should be penalties for disturbing them. Now that's tech leadership.
Also, the folks saying that you're working for the product, not the company are high as a kite. They are painfully wrong.
Long story short: if you love what you do, thank them politely for considering you and ask them for a quiet workspace and insulation from meetings. Then get back to work.
2. Lead by example - be the change you wish to see
3. Focus on strengthening your team members (designers and product managers included!)
4. Ensure your engineers are given ownership and leadership opportunities
5. Do not be afraid to let someone else lead - actually encourage this
6. Do not overload yourself (surprisingly easy to do)
7. Expect the amount of time you spend developing to decrease
8. Expect the amount of time you spend in meetings to increase
9. Actually spend time learning the business your code supports
10. Become a resource to the non-technical ppl your team supports
A lot of good advice in this thread, but remember to have patience with both yourself and your team as you take on this new role. Nothing changes overnight and it might be a number of weeks/months until you find your groove.
Congratulations and best of luck.
If a team member comes to you and says that they feel disrespected, discouraged, ignored, or even _bullied_ by a more senior team member, take that seriously. Immediately schedule a 1-on-1-on-1 and don't give anybody any time to prepare. Create a safe space for people to voice their concerns, and express to _everyone_ that if they are not capable of treating others with respect, they can be made redundant.
I'm going through this right now and it sucks. I wish my team lead had my back, but they don't.
You doing their work is sometimes going to be needed, but a 'good team' has an equitable workload. Be willing to do any of it.
The biggest thing a team leader can do is help the team communicate with itself. The worst thing a team leader can do is create conditions where team members are not communicating.
If it's not safe enough to try, then understand when you use your authority to stop them there will be a strain on your trust relationship that you need to deliberately rebuild.
[0] https://randsinrepose.com/welcome-to-rands-leadership-slack/
- Treat your team like their adults, not children, and respect them like such.
- Also, be transparent and clear with them. Hiding things or beating around the bush just wastes everyone's time.
- Give them autonomy to explore new tech when they get the itch, and you'll likely get better results and keep your team active and engaged.
- Embrace the blameless culture. Failures and bugs happen. Being hostile about it means people are more likely to hide stuff and not be up front about things. Not to say it shouldn't be addressed if it becomes a problem, but everyone's going to mess up sometime. Also, it's your job to make sure that any heat from on-high doesn't come down on them.
1. have your team's back, no matter what. They (and you) are going to screw up but your team is counting on you.
2. make the team better, every single day. Whether it's technical, emotional, productiveness, it doesn't matter. The team just needs to be better every single day.
3. get rid of the assholes, acquire those who want to be better
4. see the forest through the trees. Understand and appreciate how the work your team does translates into dollars for payroll
also, a while back someone posted this link on leadership from the Army. It's more straightforward and clear than any airport bookstore leadership book you'll ever find.
If your project pipeline has a non-coding architect, they better be your subordinate. If they are not, be prepared to push back on their design decisions. Ideally they should have a stake in the project delivery.
When some estimate, deadline or feature complexity feels off to you, listen to your inner voice and stand your ground. No matter what others, with more seniority/authority/clout in the company think.
Take care of your team. Get rid of slackers, but don't overwork the others.
Accept responsibility for the failures, and share success with the team. "I failed", "we succeeded".
1. Collaboration is key:
1a. When there are differences in opinion on how to implement something, your desired outcome is that the right thing happens for the company, and that everyone feels like their opinion was heard and legitimately considered. You don’t want to alienate even the most junior engineers even if you have absolute power over them.
1b. You need a good relationship with your business partners/customers, with your boss, and with your direct reports. Make this a top priority. Productivity improves drastically when the customer loves you. You need the upward, downward, and lateral relationships healthy because it’s crucial that you and your people feel safe to talk about the truth and work on solutions together. Counter example: people don’t want to ask for help or talk about what they’re feeling uncomfortable about because they think they’ll be judged as incompetent or a problem child. It’s important that you don’t feel that way when talking to your customers or boss, and that your people don’t feel that way when talking with you and each other. Foster a culture of love, respect, and acceptance to help with this.
1c. Pick your battles. Figure out for example when a design decision really matters strategically and when it can go either way. Give your people as much latitude as you can to give them a chance to learn from their mistakes.
I drone on here about collaboration because some of my larger failures in the last few years are because of running afoul of these ideas. Forgetting these ideas often leads to winning the battle but losing the war.
2. Constantly work to empower your people And figure out how they need to grow. Figure out their target growth areas, keep notes on those, give them opportunities to grow and learn in those areas. Watch how they do, and give them feedback every chance you get about what they did well and how they can do better. Never miss an opportunity to show them how pleased you are with positive things.
https://hbr.org/podcast/2019/08/the-challenges-and-triumphs-...
The Making of a Manager: What to Do When Everyone Looks to You
There are people who have a very different life, which I deliberately choose to avoid. Talking to these people diverges into talking about myself as there is always something exciting happening somehow, and they do ask about it (maybe out of politeness, but I'm a bad judge for that). These people sadly form a majority of people around me.
However, there is a much smaller number of people who I can listen to for hours and I genuinely care about what they have to say, so I ask a lot too. These people are really excited about their lives and have stories to tell. In my experience, not a lot of people have that. Also, they tend to care about things that I can say least imagine someone caring about.
So overall, maybe there is nothing to fix on your side here. At least, I think, there is a possibility of this.
Do try to keep things simple. By that I mean if you have the choice between a simple rpc framework and "the netflix microservice architecture with message queues and scalable container orchestration", do learn the latter, set it up, scale it to multiple sites over a vpn, but in the end,
you know what to pick.
In addition to others' recommendations about reading "The Manager's Path" (this is a must-do! An excellent book) I would take a look at how the team makes technical decisions and make sure that's healthy, and also make sure you have an understanding of the core value your product is trying to deliver by talking with your Product Manager.
If you are the defacto Product manager, make sure you know what the business is trying to accomplish so you can build the right thing and prioritize appropriately.
The more I do this work, the more a clear, open, decisionmaking process and a clear understanding of the value increment power everything else. Context and a way to talk about it.
One other note: your job will change. Know that. Be OK with it.
Good luck!
Decisions which carry little risk and are easy to undo or pivot in the future, make them quickly and confidently.
Decisions which carry non-negligible risk but are easy to undo, give some thought but don’t fret too much. If the risk starts becoming reality, you can change your mind later.
Hard to change decisions with low risk are tricky. Make sure the time spent on research and decision making is proportional to the risk, which in theory is low, but that needs to be double-checked.
Decisions that are hard to undo and carry significant risk should be the ones you spend as much time as necessary thinking through, planning out, coming up with contingency plans, building in safety checks and making sure that you can avoid making those hard-to-make changes should you decision prove incorrect.
One additional resource I would recommend is https://devtomanager.com , which is a list of interviews with other developers on how their transition was like.
Good luck on your career move!
Your #1 priority is to be a _facilitator_ in order to keep things on track. Clear the hurdles and engage with developers on the problems they are solving. And be humble. Don't treat others like they are less than you just because you are a lead.
And congrats! Enjoy it and be fully engaged. Also don't step on your superiors' toes or make them look stupid in front of their superiors. If you disagree with them, make sure to do it in private.
If you don't know what to say or are feeling angry, don't say something just to have a response. Its super rare that you need to commit on the spot. If you get negative feedback from your boss, wait a day before you try to start panic-changing things on the team. Bosses are flighty and under pressure, try to keep it constructive.
Your main job is to keep the team productive. If you do this, you can leverage having a team that delivers into raises for yourself and your team -- eventually.
From my experience having kids helps a lot. Look into your past. Did you enjoy organizing stuff? Do you like to communicate with people? Do you have experience lobbing your ideas?
If you ain't scared of that then go and find yourself a mentor. Best would be if that is somebody you already respect.
This may sound very pedantic, but please spend a week reading “High Output Management” by Andy Grove.
The biggest change that happens when you move from a individual to a team lead is that suddenly you have a team which you can leverage to get the needle moving.
This is a great opportunity to punch above your weight but also fraught with peril if not planned well.
There is a need for a mix of comradeship and accountability which is not easy to grasp. But please spend a week reading the book
Meaning: Make sure that you're either running, or involved with, ticket triage. No ticket should go to an engineer without a basic review. (Edit: 2-3 minutes a ticket)
What are things that you should look for, before assigning a ticket to an engineer?
- Is the title and description coherent? Written in decent English (or whatever language your office uses.)
- Did whoever submit the ticket do an appropriate amount of troubleshooting for their role? (Or are they just trying to pass work off on your engineers?) Specifically, if this is a support escalation, did the submitter follow any troubleshooting steps that you've already documented?
- If this is a bug, do the steps to reproduce make sense?
- Do your processes require things like logs, screenshots, videos, ect? Are they present? (Edit: QE and support need to be trained on what kind of information to collect before passing a ticket to your team. Being a "team player" means holding other groups accountable for providing your engineers what they need to do their jobs.)
- Is this a duplicate of a well-known issue?
- Is the bug steered to your team appropriately, or should a different team take the first attempt?
- [Edit] Are there multiple bugs / support requests in a single ticket? (I have a firm one-bug-per-ticket, or one-escalation-per-ticket rule. It just gets too confusing otherwise.)
The above shouldn't take long. Specifically, during triage, you aren't trying to understand the bug or escalation. You're just making sure that whoever wrote the ticket put in enough knowledge that you're comfortable handing it off to your team.
When a ticket doesn't make sense, just send it back to whoever wrote it. You might need to meet with other managers to make sure that everyone understands what you need, and expect, prior to assigning work to your team.
The point is that you should be the filter blocking other teams from sending crap to your engineers. You can also involve your team members in triage, as long as your team members understand the difference between triage and actively working on a bug.
What happens when you don't triage well? Bugs pile up on your team and don't get solved. Some engineers will be good at asking for clarification for bad bugs, other engineers will just let them sit.
In this case, when tickets aren't being resolved, the solution is to re-triage and send back poorly-defined tickets.
In my experience, it makes a world of difference when you have someone you can reach out to and bounce some ideas off of..
If it's company large enough that it has managers who primarily talk to other managers, you're not going to be able to figure things out quickly enough to survive in that role.
Trust your team. Never break their trust. If you do that, you will not make it.
Never put yourself before your team (i.e. make your needs more important than the team's needs)
First thing to do is go to your new boss and get them to give you an exhaustive list of your new duties, responsibilities, what success look like, etc..
Also go to other people who have done well in that role at your company and ask them the same questions.
There's a lot of interesting discussion on that thread that might be useful to you as well.
Share new and fresh ideas with them and be attentive when they share time-tested techniques and horror stories.
The horror stories will teach as much, if not more, than all of the above.
- The Manager's Path
- Managing Humans
- Radical Candorhttps://www.bitlog.com/2017/10/12/what-does-a-tech-lead-do/
The TL;DR is that you are now responsible for anything that is not moving your team forward. If nobody knows what "forward" means, it's your responsibility to define it. If a code review is languishing, that's your responsibility. If a person has a technical question and they're junior enough that they don't know they can ask it, that's your responsibility. If your team doesn't have a good technical strategy, that's your responsibility. If your team is having trouble getting technical help from another team, that's your responsibility.
It's not your job to do all of these things, but it's your job to make sure they get done.
Your job will no longer be primarily about creating good code, it will be about making it as easy as possible for everyone else on your team to do so.
Writing well is very important. I literally spend half my day writing: tickets, pull request comments, upstream status reports, explaining the cost/benefit of various options to project managers.
Get basic functionality locked down early and then build from there.
Don't micromanage tech decisions but do make it easy for people to be consistent with one another by providing a style guide.
If all you do is prevent a few foundationally stupid decisions from making their way into the project, you're already way ahead. [hint: most really stupid decisions are not actually any one person's conscious decision].
After all else: listen.
1- Put your team before anything else.
2- Be as honest as you can about deadlines and limitations.
3- There is time for crunch mode, not all the time is crunch mode.
Be very good than most team members in your tech skills and demonstrate it when chance presents, that will make them respect your judgement. If your tech skills are not on par with some of the team members that's fine, but you need to handle them differently. Time and time again i have seen skilled members of the team will question authority if they don't get along with team leads. Remember the cost of replacing a manager or techlead is low compared to skilled people because they get paid lower usually. You may have to delegate work but you must be the most skilled guy in the team or you should have a very likable personality.
There will always be a backlog of tickets, and you can't hit inbox zero. But you can hack it. Executives need to increase the Average Sales Price (ASP) and Reduce Churn. Your team will want to fix technical debt.
Your job is to bridge the gap: help your team understand how their work impacts customers. Help the business understand how your team's successes impact ASP and churn rates.
Tell your team they hit the goal. Tell the organization your team hit the goal. Tell the organization where your team can see you telling the organization. Many engineers aren't known for their salesmanship, and they can and should improve, but you can step in and rapidly build trust with them and the organization by selling their work on their behalf.
Instead of asking for time to fix tech debt, explain to the organization what the tech debt actually fixes: Reliability (churn), Operations/Chores (COGS), Resistance to Future Change (ASP), Infrastructure Bills (COGS), App Performance (churn), and like that.
The weekly 30-minute O3 is your new best friend, especially with non-technical stakeholders. As a team lead, I usually meet with engineers every other week—you're a team lead, not their manager.
Understand the differences between Accountability, Responsibility, and Authority. Responsibility is "yup, we're on it." Accountability means the business expects you to accept "consequences" for failure. Don't accept Accountability without both Authority to make decisions and compensation for the job risk. More than likely someone else is accountable (an actual manager or maybe a product owner.) Engineers are too difficult to hire to be holding them accountable. As an ambitious founder-turned-tech-lead I bristle a bit at this, but at least you can be aware of how things are set up.
But this also means you'll have limited authority, and you'll have to achieve alignment rather than dictate solutions. Which brings me to:
Pre-wire meetings. If you need a decision to go your way, meet with each attendee individually first and get their feedback on your proposal. Don't put together the meeting with everyone until you're confident it's a formality.
You can push back on processes that don't work for you: too many meetings, scrum ceremonies, taps on the shoulder. "I understand the importance of schedules and status updates to the business. My team needs protected time to achieve our best results. Will you help me batch our meetings into tighter windows so we're able to both put in the work and keep the business informed on our progress?"
Set up systems. Don't take on all the chores yourself. Set up a schedule for a "triage" engineer, include yourself in the schedule. I like rotating out weekly. This engineer intakes all of the bugs/questions/fire drills and provides answers and verifies things aren't on fire. They are assigned less critical tasks that week because they'll be interrupted. This gets you protected time to think.
Set up engineering "pairing office hours" 4-5x a week. You're not a manager: you still need to be on a Maker's Schedule. Your engineers will need help and rubber duck sessions, but if you drop everything every time they ask or get stuck, you won't ever be able to get in the zone yourself. Likewise, they'll know when you're available to help. Tell them you expect them to come prepared with a list of things they've already tried.
http://www.paulgraham.com/makersschedule.html
Read every MR your team submits. Don't comment on the direction 8 times out of 10 (unless you're directly assigned to a review.) You're looking for opportunities to ask Ben to talk to Samantha because they are both changing related areas. Great software is built by gardening over months, quarters, and years. You don't need every MR to be perfect (and that's subjective, anyway), and you'll achieve better results month over month if your engineers feel like they have ownership over their work.
On the flip side, if you're the one being micromanaged, try accepting responsibility for larger time frames. "We will achieve this specific thing by next Friday. We will provide confidence updates on Tuesdays and Thursdays." Then do it. Every time, if you can. The reason the CEO can go play golf on a Tuesday afternoon is because he accepts responsibility for improving the valuation of the whole company by 120% by the end of the year. The junior engineer accepts responsibility for one JIRA ticket, and is likewise expected to be available from 9-5 most days.
Read both Peopleware and The Mythical Man-Month. You're not a manager, but they will help you articulate your frustrations and give you tools to talk to management.
Email and twitter in profile, let me know how I can help.
https://www.youtube.com/channel/UC4xKdmAXFh4ACyhpiQ_3qBw/vid...
(more seriously, it's mostly just amusing)
Don't let ambition get in the way!
1.) Delegate. Have nothing to do.
This is not about being "lazy" or not doing "actual work," it's about giving autonomy to your team. If you do not delegate, your team will constantly be blocked by you and you will not retain them. If you delegate properly, and trust your team, it'll feel like you (sometimes) have almost no job at all.
A pretty solid way to delegate, is to find out where people want to go next in their career, and offer up decisions/work based on helping people get there. It also prevents #2 on my list...
2.) Do not horde work.
It's shitty, I've done it, and learned from it. Every-fucking-time I accidentally did it, it sucked, it would (a) take forever because meetings can eat your life, (b) stress you out because of the time constraints, and (c) MOST IMPORTANTLY someone on my team would have benefited from, and enjoyed, doing the work more.
3.) Hire people smarter than you.
Don't be afraid to hire people with more experience than you or who are "smarter" in some specific field of expertise than you.
You will learn so much by being open to others knowledge, your team will benefit even more by having other people able to guide/mentor/coach them.
4.) Blame process, not people.
When shit hits the fan, you should ALWAYS be cool as a cucumber. It doesn't matter what the reason is, if someone pressed the wrong button, configured something badly, whatever it was cannot be undone.
What you need to do (AFTER) is a root cause analysis; I have always been a fan of the "Five Whys" but to each there own (you can probably google that to get started if its new to you or to find others). You can then implement, document it, and develop new process so that shit storm doesn't happen again.
Just in case the focus here on process wasn't clear, let me spell out the other part to be clear: do not every fucking blame your team. Do not ever blame an individual. You will fix nothing, and your team will grow to hate you as you toss people under the bus.
5.) Shit rolls down hill, it also rolls up hill, and you're always stuck pushing it.
Depending on where you are in the org, this isn't quite so heavy, but truthfully, as a manager/lead the bullshit you weather for your team is what defines you. The more you prevent rolling downhill onto your team, and the more you prevent rolling uphill to your boss(es), the more loved you will be by both.
At some places, without bullshit densities strong enough to make a strange-quark, this won't be an issue... At other ones, this will very likely be what keeps your bosses and your team happy in an otherwise (i.e. other departments) not-fun workplace.
6.) Be kind and be honest.
Don't treat people like family. Treat them better. Families have bullshit, families hide things, families have history, families might be kind, but they can also be brutal. You also can't fire your "family," but you might have to your co-worker... So, just fucking don't.
What to do instead? It turns out, when push comes to shove more than anything they want (a) honesty about the state of the company and their status, (b) to be communicated with kindly. Don't yell at people, or talk about them behind their backs, don't marginalize people or groups you don't think are in the room (I cannot believe what some people will fucking say when they think "no one" is listening)...
And we all can have a bad day and maybe rudely reply to someone or do something not our best-selves, and in those situations you just gotta learn to proactively and meaningfully say "I am sorry." It's even good for you if people find out you did, because it means you're not an asshole, and again they'll trust you more.
The best will be when people give you that same respect because you've set the standard and they want to uphold it...
7.) Your title doesn't mean anything, your experience does, it is the real investment here and completely defined by what you do and how much you put into it.
8.) If it truly fucking sucks, leave. Don't be afraid to jump shit; with a "lesser title." See #7 again, as long as you've done it right, you'll very likely be getting paid more anyway :)
- not kidding
So, a few (sorry, not that few) notes:
* Too much information around You will feel lost in a sea of information. There's an infinite number of posts, blogs, threads talking about tech lead. You will want to read everything before doing any action. However, it's impossible, and you'll quickly feel overwhelmed with all that info.
* Listen your team and know their pains More than knowing everything about tech lead, what's really important is to know your team and where you're going. 1on1's with everyone will bring the knowledge for that. They will tell you their frustrations and pains. These will be the first insights on where to start your job.
* Delegate and communicate Just because you're not coding, it doesn't mean you are not working. To me, that was a big issue. So, in order to sort it I try to communicate regularly so that the team has visibility of what I'm doing. Also, most of the times you will have too much on your plate. Feel free to delegate. I'm pretty sure that you will have volunteers for certain areas (in my case, infrastucture, front-end,...)
* Iterate fast Iterate and fail fast. One of the biggest pains I felt was the fear of releasing something which was not perfect or that I was not secure of. However, it will never be perfect. Your team is not like any other team described in blogposts. Teams are always different, which mean different approaches. Instead of waiting too long for releasing something almost perfect, release, fail and improve more often. Be aware that if you iterate once each quarter, at the end of the year you have 4 iterations and 4 data points. If you iterate monthly you will have 12 iterations. Way more precision to fine tune your team.
* Are we engineers, or are we humans? (terrible pun with The Killers song) Each person of your team is different, each one of them has a different life with different problems. We all have our own different battles in life and sometimes we need to spend energy and focus on other things rather than work. Keeping that in mind some are more shy, some not. Some will think that they own you something, that they are behind schedule and hurting the team. Usually these people won't feel comfortable about talking their pains. Be their leader and help them. Actively listen each one, give them space and support when necessary.
* Align expectations Make sure that there's a common goal, and that everyone understands it in a crystal clear way. At Whitesmith, more than knowing how to master a couple of techs, our team must be critic about the product. Our good engineers will then find the best tools for the job and then you can step in to define boundaries on which tech is better for that specific problem. But it depends a lot on the company. Question yourself what's your most common project type and what's your best set of tools. Do you want to be really good at just that? Or do you prefer to be more flexible and allow other tools? Define standards, some role models of your team so that people know where the team is going and consequently where they are going too. It kind of reminds me of Ryanair. All planes are 737 to minimize differences, processes and overall complexity.
* Growth aka learning, enineering manager, space for your team to improve Give your people space to grow. Try to find time for them to learn something new. However, it's also important to find a place for this knowledge to be applied. Learning without a purpose and not being able to apply it regularly, seems to be almost as furstrating as not growing at all.
Sorry for the long post. A lot of things coming to my mind atm. Feel free to reach out and disagree. That's actually what I do as a tech lead with my team. Also, I've been told the book "The Phoenix Project" is a really nice read for tech leads.
All the best!
1. Checklists make everything easier. What needs to be in the checklists should be the most common issues that come up during code review or have been related to defects that made it past the dev environment.
2. Good agile documentation means all business rules/application behavior requirements should be in the story/task and in a centralized wiki. This makes it possible for new team members to familiarize themselves with application behavior quickly, and that list of behaviors is also the documentation on what needs to be tested so QA can implement integration and regression tests.
3. Every major code review needs an organized explanation of code changes per business rule. I've got my team using a OneNote where they initially write down each stories business rules at a high level for non-technical people in a list format and add sub items that describe an architectural overview of changes like design patterns and technologies used, and an addition sub level briefly describing code changes. I also have them provide links to an articles they used to make decisions or that describe design patterns used rather than needing to rewrite them. This rarely takes longer than an hour for a large story and it provides a semantic map between business logic and technical terminology for non-technical people and a sort of historical stream of consciousness that can be looked back at to get a feel for the history and direction for a given project.
4. Assess how team members are doing with technologies they use and get them whatever training they need.
5. No matter how experienced a developer might be before they join your team, new team members should always start out by getting the project to run and fixing bugs. Expecting too much too fast is a guaranteed way to lose high quality talent.
6. Always keep your ego out of everything and if someone is getting defensive about code, remind them that there is no such thing as perfect code. There is always room for improvement, and the focus on any changes or development/architectural decisions must always be about the potential future cost of each decision. Principals like Dry and Solid are important, but over implementing them will always result in difficult to maintain code. Abstraction is only good if it doesn't lock you into a design pattern that might not apply to the future state of all application behaviors you might need in the future. Also, reflection based code is cool to implement and a huge pain to get right let alone maintain or update.
7. Always beware implementing anything you're excited about. Code should always be focused on efficiency and maintainability, never on how cool or familiar a specific tool is. This is sort the same as keeping your ego out, but more about keeping your excitement out of things.
8. Developers should talk to customers, and logging should be implemented in ways that enable analyzing feature usage and user feedback. Many feature request come from managers, but the end users are the people that really need to feel like your software improves their lives.
9. Beware any list that has a psychologically pleasing number of items because it is definitely padded out or shortened to reach that number.
Doesn't ask from the team things that he wouldn't or isn't capable of doing.
And as many of the other comments have said you are there for the team. They will produce the real value.
What can you do to get them all the things they need to succeed? What can you do to shield them from the nonsense? Poor requirements, unnecessary meetings.
I think you want to give chances to fail but also provide that safety net so they don't fail too hard.
As a former Google tech lead (and I know this sounds like a YouTube parody): my advice is don't be a "tech lead" for long. Either be a dev or move into management. Make up your mind. Google "tech lead" is defined above.
As a tech lead in such informal position, you'll end up doing 2 jobs and you'll eventually find that the level of effort required is not commensurate with compensation. You can make much more and have a faster career progression as a manager. You can make the same money with less effort and headache as a dev. Your IC career won't move any faster just because you're a "tech lead", indeed the opposite could be true, because now a non-trivial fraction of your productive capacity is taken up by intangibles which are very difficult for an IC to articulate the value of come performance review time. Being a tech lead makes no logical sense whatsoever, at least not at Google, unless you're aiming for a manager position in the near future, and you need to demonstrate your "leadership qualities".
Other companies may differ, of course, but I bet it's like that at most places that have "tech" leads. In contrast, at Microsoft there's "dev lead", not "tech", and it's a frontline manager position, with reports and authority, and with the aim to move upwards on the management ladder.
Google-like informal "tech lead" is not even a title, it's just a SWE too stupid to understand that they're basically doing more valuable work, and more of it, for the same money.
What have your experiences and tasks been so far as a mid-level developer? What were you in charge of? Did you have a regular rapport with other departments, with clients, stakesholders? Did they talk to you directly when they "wanted things done"?
What are the sizes of the companies that you've worked in already? How big over all, how big were the teams you were on?
I'm surprised no one is asking these questions to see what existing experience you do have can contribute to this, because it is possible that this might be a natural extension of what you already do. It's company-size specific, but good to ask all the same.
In smaller companies, being a mid-level developer means occasionally having to make a call that directly impacts the bottom line and talking to the CEO and clients in a very matter-of-fact way. You wouldn't know that from just the title of a person however.
If you ask them to put work ahead of family or faith or rest, or if you somehow expect more than 100% effort from them, you're going to drive away the ones who have other options. And the reason they have other options is because they're the best ones.