The responsibilities of a Salesforce Developer can range from typical code-based tasks, through to work that requires architectural concerns (understanding the wider context of what their code is for).
What Does a Salesforce Developer Do? Let’s start by outlining what we mean by ‘entry-level’, ‘mid-level’, and ‘senior’ developers. Years of experience is not the be-all end-all indicator. Developer career progression focused more on skill set rather than experience. In the list below, take the years as a suggestion:
- Entry-level developer: Writing code based on specific requirements, (e.g. basic Apex triggers), testing (0 – 2 years’ experience, possibly longer).
- Mid-level developer: Integrations, composition, encapsulation, and invocable methods (2 – 4 years’ experience).
- Senior developer: Solution design, DevOps, advancing testing strategies – and most importantly, being fully engaged with the rest of the team (5+ years’ experience).
“The points at which someone moves on from being a junior developer to a mid-level or to a senior, are often removed from “years”, and instead are based on experience. Many people who would consider themselves senior developers (years on the job) have been stuck at the junior level for years, not progressing. Growing to have the knowledge, thinking in these ways, then you will progress through the development career path”
– Alex Crisp, Senior Developer, Seven20.
Become a Salesforce Developer
- Transferable knowledge: Have experience in web development/Java, or you are a Computer Science graduate.
- Learn Apex: The best development language to learn because it is fundamental to Salesforce (plus, it’s a lighter “vanilla” version of Java).
Why is Java important? If you know Java, you will be able to grasp Apex faster. Plus, you’ll be able to adapt to Salesforce’s development framework, Lightning web components (LWC), very easily.
What Entry-level Salesforce Developers do:
As a junior Salesforce Developer, you’ll be writing code based on specific requirements. You’ll be continually guided by the more experienced Salesforce developers in your team.
- Apex triggers: Writing basic triggers, e.g. roll-ups, and Apex record validation.
- Lightning pages: Basic pages that have a single purpose.
- Salesforce DX: If you are a developer and you’re still developing in the development console inside of Salesforce (the one in the browser) you’re doing something wrong. Begin to understand the benefits of, and use, the Salesforce CLI to enhance your development experience.
- Database design: Have an understanding of databases and relationships – parent relationships, child relationships – and how they can use those throughout the development. It’s less about the Salesforce data model, (i.e. function of objects) – from a developer’s point of view, the relationship between contacts and accounts is exactly the same as if they had custom contacts and custom accounts.
- Governor limits: A Salesforce platform concept that’s fundamental to code design. When you’re starting to learn, governor limits seem a big deal; once you understand what your code is doing, governor limits become a non-issue – in fact, they’re rarely talked about once one reaches mid-level, except in situations where something very specific needs to be done.
- Security considerations: Gaining an understanding.
- Testing: Simple unit tests.
- Admin overlap: Point-and-click configuration, with the assumption that Flow will be used. Admins may lean on developers when their capacity is stretched, and the overlap is also applicable to developers working in a small organization/solo.
- No focus on solution design at all.
Develop the Right Mindset
Mindset – the way you think, act, and reflect – is key. Not having the right mindset will hold you back from progressing in your Salesforce developer career.
- Allow “hand-holding”: You’re likely to always have a mentor; while it may be independent working, you’ll be supervised. Absorb from these people who have walked the same path. Mid-level developers need next to no supervision.
- See everything as an iterative process: E.g. When writing a trigger, you may work on the same trigger three times because you do it once, receive the learnings from more senior team members, then redo your piece of work. While it’s a slower development cycle, the cumulative effect of improvement is going to result in progression, and more free time to learn more advanced concepts.
- Reflect on your own work: Treat everything as a learning experience. Simply saying “I don’t have time” is not a valid excuse – in fact, a bad fallacy – spend an extra 20% on this task now but it will save you 5% time/effort next time. The cumulative effect is going to add up to having a lot more free time to learn.
- Don’t take feedback personally: The sooner that you can disassociate yourself from your work, you’ll be on your way to becoming a mid-level developer. Not being defensive reflects the importance of knowledge sharing.
- Knowledge share with other members, including more senior members.
Definition: Composition and Encapsulation
Before we move on, let’s introduce these two concepts that are key to progressing as a Salesforce developer:
Involves building large components from multiple smaller components.
If you were to give a task to an entry level developer, e.g. to build a screen page component, they would create two very large (hundreds of lines of code) for that one screen.
A mid-level developer, on the other hand, should be breaking that down into sections. You’ll still end up with one component but that component is made up of (e.g. five) smaller components which each have a function.
Start considering how your code is going to be used in the wider scheme. Take advantage of design patterns and programming techniques, and have the thought process to make code modular and potentially reusable when building. Invocable actions are an example of composition (which we’ll cover in this guide).
Involves breaking code down into smaller parts, that each address an individual function.
Example: You needed to change a search panel on the left-hand side of a page. With proper code design, you would just go and change that component. It will continue to give an output to the other page components that don’t care what changes have been made – they’re just expecting output.
The benefits of encapsulation, i.e. having smaller code blocks, components or modules are:
- Easier to maintain: They have their own function, and can be maintained separately from the rest of the components (e.g. on a page).
- Easier to test: Allows you to write tests that can validate a specific block of code, when given X, leads to Y. That’s when tests become truly valid.
- Can be reused elsewhere. (Note: There are some cases when you can’t reuse elsewhere e.g. something very bespoke).
Progress to a Mid-level Salesforce Developer
You will be considered a mid-level developer with the right skills and mindset. Mid-level developer skills include:
- Integrations: Be able to integrate Salesforce with a third-party system, exploring integration patterns.
- Composition: Start considering how your code is going to be used in the wider scheme. Take advantage of design patterns and programming techniques, and have the thought process to make code modular and potentially reusable when building.
- Encapsulation: The practice of breaking code down into smaller parts, each addressing an individual function. Easier to maintain, test, and reuse.
- Invocable actions (an example of composition): Be able to create invocable actions and Lightning components (to go in Flows). Rather than requesting you write the entire trigger – a single query can be an invocable action, which the admin can utilize. This is key for developers to make themselves valuable to their team, therefore, enhancing other people’s work (while reducing the number of tickets raised for you to action!)
- Advanced triggers: E.g. custom lead conversion process. If you have triggers going across multiple objects, that can be a symptom of bad design.
- Working with large sets of data.
- Implicit Bulkification: Considering that your code may likely be run against larger, and potentially growing datasets, and keeping that scenario in consideration from the get-go.
- Security considerations: Have a complete grasp of these concepts and how they need to be reflected in your code.
- DevOps: Be using source control and have an automated release pipeline (even if it’s simple to validate a deployment will work).
- Testing strategies: Design code around it being easy to test – and utilizing dependency injections and design patterns to facilitate testing. Developers should be writing tests to validate that their code does what it’s supposed to do in both positive and negative scenarios. When starting to think about encapsulation this allows you to write tests that can validate a specific block of code, when given X, leads to Y. That’s when tests become valid because any bad changes to the system will be detected early when tests fail. Tests should be done to consider integrations – not necessarily in relation to the integration, but also the interaction between blocks of code. Integration design within best practice means testing becomes a non-issue.
Move from Entry to Mid-level Developer
- Practice composition and encapsulation: Have a design mindset. Think about how to break code down into smaller parts that are easier to maintain, and that aid testing. Entry level developers will write their code in monolithic blocks, which means that tests are a nightmare to write. As a result, tests may not be totally valid.
- Master governor limits: Be designing code in a way that completely avoids you having to consciously consider governor limits.
- Work independently: Mid-level developers need next to no supervision. They would have successfully absorbed information from their mentors or senior team members (people who have walked the same path).
What Senior Salesforce Developers do:
Here comes the question: Do you want to progress your career in a technical domain, or oversee a development team?
Senior developer is the final step before one can “split off” into other domains e.g. the architect route. Some people may split off earlier than senior developer status.
- Lead Developer: Focused on the code base and enabling the team, these people act as a force multiplier for their team, enabling other team members to work more effectively. In terms of coding, writing less, while reviewing more. They are responsible for creating a technical vision for the team – planning into the future.
- Technical Architect: Focused on the higher level, always keeping the big picture in mind. Their remit, in simple terms, relates to how different parts of the system interact with each other and how data flows between them, be they systems built inside Salesforce or external systems.
As a senior Salesforce Developer, you’ll take ownership of all programmatic requests for your organization. In most organizations, you will have the opportunity to mentor a team of developers (or build a team).
However, it’s not only coding prowess that will get you here. There’s a special awareness, beyond yourself, that will be required:
- Lead-developer-technical-architect: You should understand both what a lead developer would do, and a technical architect (low-level codebase and architecture).
- Solution design: Architecting includes the considerations, limitations, and the impact. (‘Technical Consultant’ is a typical label here).
- Ability to make others’ code reusable: How can code benefit the wider context of your organization? Given a component or Apex, a senior developer will be able to identify if, and how, it can be reused. They’d go action with minimal delay!
- DevOps: Implementing DevOps practices in your team to, ultimately, have an automated release pipeline.
Advancing testing strategies: Designing code to test with ease, utilizing dependency injections and design patterns.
- Fully engaged with the rest of the team: Should be willing and able to support, be someone the rest of the team can rely on. If someone approaches them saying, “I’ve been doing this and I’m not entirely sure”, the senior developer is responsive and directs them – which may be a help article – so they can build up those skills themselves. If people in the team are coming to them for help, and they’re turning them away, they’re not a senior developer – they may be a good developer, but they’re not a senior developer.
- Encapsulation: A greater topic; an example of a senior vs a mid-level developer’s approach follows below.
Approach to Encapsulation (Mid vs Senior Developer)
The ability to make code modular, repeatable, maintainable is when developers go “up” a level. Let’s take an example: A header bar on a record page.
- Mid-level developer: Would make a bespoke version for a specific component, copy the SLDS designs, make it look good. It’ll be functional – and that’s perfectly valid.
- Senior developer: Would make a completely generic version of that header bar, essentially, taking it down another level. It would be its own standalone component, which can be used elsewhere. There’s precognition of where it might be needed in the future. Then, through composition, plug the data in for this specific use case.
Can You Accelerate Your Developer Career?
“Absolutely – with the right team, the right environment, some people go from being a junior to a mid-level in a year. On the other hand, in a bad environment they may never progress.”
– Alex Crisp, Senior Developer, Seven20.
Now you know more about what it takes to climb the ladder, let’s finish up with a typical Salesforce Developer career path: