It is true that a senior software engineer usually takes on larger projects or complicated chunks of a much bigger project, displays independence in handling various aspects of the software development process, possesses decision-making ability and authority on architectural matters and is, in general, more skilled. However in my experience, what helps a software developer, let us call her Dana, transition into a senior software developer is on the job learning and assimilation of many practices:
Use of experience in making implementation decisions. Dana’s last web application was found to have an XSRF vulnerability that she fixed on being notified during pentest. Rather than mechanically updating the code to work around this particular vulnerability as per suggestion by pentesters, she took the time to understand the underlying pattern, went through all her code and fixed similar issues and made it a habit to avoid coding practices that caused this bug. Another example of similar learning is in showing error messages to users that could reveal too much internal implementation details, for she had seen similar issue reported as a bug in one of her colleagues’ code.
Being on the lookout for the right tools and making them part of her toolset. During early years of her software development career, Dana used to rely solely on printf or equivalent calls for debugging her code. Over time, she became familiar with debuggers, profilers, and Integrated Development Environments. With the help of these, she can spot and correct logical issues much more quickly.
Thinking of how users would use the software and design accordingly. Gone are the days when Dana relied completely on a detailed description of how the software should behave and then focus on just writing the code, entirely consumed in just making the program work. Now she works in close collaboration with product managers to understand the intent of the software and proactively participates in defining how the software should behave to make user’s life as easy as possible, making useful suggestions along the way. Her mastery of programming techniques ensures that these get translated into working code quite quickly.
Active participation in team discussions. Dana used to be a keen observer of team discussions involving requirements, design decisions, and implementation approaches, mentally mapping those to what she had learned in her computer science courses and by reading books. Now she actively participates in these discussions, persuasively presenting her views with rational justifications, often in support of an existing point of view, but sometimes also to counter an a suggested approach.
Reaching out to experts. During her early years, Dana would spend hours, sometimes even days, trying to solve a particular problem, say optimizing a complex SQL query. Now she often reaches out to a DB expert for getting advice.
Mentoring others. Dana is always available to those who seek her advice in areas of her expertise. In fact, she makes it a point to spend time with the new members of the team and makes sure that they know what she can do for them.
Dealing with stakeholders. Here is an area where Dana has changed most. Her earlier expectation was to directed into what software was being developed, which integrations to work. Now her focus is more on what stakeholders want, often talking to them in their language, and then translating those into software requirements. She also enjoys the process of designing a system that leverages modules and functions from a large number of existing systems.
Being aware of latest trends and tools and using them wherever applicable. Dana makes it a point to spend a few hours every week reading relevant and influential blogs to keep track of what is going on in her field. Every once in a while she tries the tools that get good reviews, and many of these have become an integral part of her toolset.
Knowing what to do. Most importantly, Dana seems to always know what needs to be done — be it writing code, reaching out to an expert, working with a co-worker, getting help from someone in a different division, reviewing others’ code, whatever.
Although most software developers eventually transition into senior developers, some do it much faster than others. I have also seen those who are never quite able to make the transition. They do become excellent at their day to day job of writing code but somehow fail to attain one or more of critical abilities listed above.