Many junior developers struggle to find their first professional role. If you're self-taught, or fresh out of a bootcamp, it can be really intimidating hitting the software job market for the first time. With so many other developers in the same position as you, it can seem impossible to stand out to recruiters and hiring managers.
Let's look at my top tips for standing out as a junior software developer.
There are some things that you probably won't come across when learning on your own, although a bootcamp graduate might have used them to some extent.
Git is a distributed version control system that allows developers to track changes in their codebase, collaborate with others, and manage different versions of their projects. It provides a mechanism to create branches, make commits, and merge changes between branches. Git allows developers to work on different features or bug fixes simultaneously without conflicting with each other's code. It provides a history of all changes made to the codebase, making it easy to revert to previous versions if needed. With Git, developers can work offline, commit changes locally, and synchronize their code with a central repository when connected to the internet.
GitHub, on the other hand, is a web-based hosting service for Git repositories. It adds a collaborative layer on top of Git, providing a platform for developers to share, collaborate, and contribute to open-source projects. GitHub allows developers to create public or private repositories, manage issues and project boards, and track changes through pull requests. It enables seamless collaboration by providing features like code reviews, branching workflows, and the ability to fork and contribute to other projects. GitHub also serves as a social platform where developers can showcase their work, build a portfolio, and engage with a large community of developers.
Junior software developers often don't have the need to use Git when learning on their own since they have nobody to share their code with. However, setting up GitHub and publishing code to repositories will not only give you a place to demonstrate the code that you've written, it will also show that you are ready to work with Git as a version control system.
In software development, data structures are essential components that help organize and manage data efficiently. They provide a framework for storing, retrieving, and manipulating data in a way that supports the specific needs and requirements of the application or system being developed.
Data structures play a vital role in areas such as managing user information, handling server-side data, and optimizing data processing. For example, when designing a user registration system for a web application, a common data structure used is a database table. The table structure organizes user data into rows and columns, making it easier to store, query, and update user information.
In software development, data structures like arrays, lists, and dictionaries are commonly used to store and manipulate collections of data. Arrays provide efficient random access to elements, lists offer flexibility in adding or removing items, and dictionaries enable fast key-value pair lookups. These data structures are crucial in scenarios such as managing lists of blog posts, tracking user preferences, or processing large datasets.
By understanding data structures and their appropriate use in web and software development, developers can optimize data storage and retrieval, improve algorithmic efficiency, and enhance overall system performance. Properly chosen data structures enable developers to design more scalable and maintainable applications, ensuring efficient data handling and seamless user experiences.
Data structures are often overlooked by junior web developers who are trying to enter the industry, meaning that learning and understanding basic and advanced data structures can really set you apart in your job hunt. Even though I rarely recommend sites like LeetCode or CodeWars for more advanced developers, these sites will give you a good foundation in many types of data structures.
Teamwork is crucially important for web developers as it fosters collaboration, enhances productivity, and leads to the development of high-quality and successful web projects. Web development often involves multiple team members, including frontend and backend developers, designers, project managers, and quality assurance professionals.
Effective teamwork allows for the exchange of ideas, pooling of diverse skill sets, and efficient division of tasks, resulting in the creation of well-rounded and user-centric web solutions. Collaboration within a team enables problem-solving, knowledge sharing, and continuous learning, ultimately leading to the delivery of innovative and impactful web applications that meet client requirements and exceed user expectations.
Without professional experience, it's hard to demonstrate effective team work when applying for junior web developer positions, unless you're switching careers and can highlight skills from previous roles in other other industries that are transferable to software development. However, contributing to open source projects or working on a side project with a friend could be the key to showing off your teamwork capabilities.
In fact, as part of the developer coaching sessions I offer, my students often work on projects with me that not only improve their technical skills, but also enhance their teamwork and other soft skills, like pair programming, communication and technical writing. Get in touch via my contact page if you'd like to learn more about my professional software coaching.
Frontend developers face their own unique challenges. Showing knowledge and awareness of some or all of the following topics can give you a boost when applying for Junior Frontend Developer roles:
XHR requests are commonly used in frontend development to implement features such as dynamic content loading, form submissions, real-time updates, and fetching data from APIs. They enable a smoother user experience by allowing data to be retrieved and updated in the background, without disrupting the current page state. XHR requests are a fundamental tool for building interactive and responsive web applications.
Junior frontend developers might not be aware of the power of XHR requests for making dynamic and interactive website or web application, but in most, if not all, professional frontend developer roles, they will be necessary and form a fundamental part of the development. It's crucial to understand the tools that are available to make XHR requests and handle the responses, from the simple fetch API that browsers have, to dedicated tools like Axios that give the developer more control and abstract away the more complex parts of making requests.
Frameworks like Angular and React also have their own libraries that are designed specially for making XHR requests from those types of applications, so learning something like
react-query will give you a boost in your applications for React developer positions and also help you creating React applications in your side projects.
Accessibility, often shortened to A11y, in frontend development refers to the practice of designing and building websites and web applications that can be accessed and used by people with disabilities. It ensures that individuals with visual, auditory, motor, or cognitive impairments can perceive, navigate, and interact with digital content effectively.
Accessibility involves implementing standards and techniques that make the user interface inclusive and usable for a wide range of users. This includes considerations for screen readers, keyboard navigation, color contrast, text alternatives for non-text content, and semantic markup.
Screen readers, assistive technologies used by individuals with visual impairments, rely on well-structured HTML to interpret and convey information to users. Developers should use proper HTML tags, headings, and landmarks to provide a logical and meaningful structure to web content. Additionally, alternative text descriptions should be provided for images and multimedia elements to ensure they can be understood by screen readers.
Keyboard navigation is another crucial aspect of accessibility. Some users rely on keyboards or alternative input devices instead of a mouse. Developers should ensure that all interactive elements, such as buttons and links, can be accessed and operated using keyboard inputs. This includes providing visual focus indicators and ensuring that the tab order follows a logical flow.
Colour contrast is essential for individuals with visual impairments or color blindness. Developers should use colours with sufficient contrast to ensure that text and other visual elements are easily distinguishable. Tools such as the Web Content Accessibility Guidelines (WCAG) provide specific guidelines for colour contrast ratios.
It's a relately wide topic, and requires lots of learning and understanding of the various disabilities or alternative uses that users may have, but it's easy to get started and pick up the basics. Referring to accessibility, especially in technical interviews, can give your application a big boost and really set you apart from the other candidates for the role.
If you're applying for Junior Backend Developer positions, these topics will help you stand out in that specialisation:
Authentication is a process used in backend development to verify and validate the identity of users accessing a system or application. It ensures that only authorized individuals can access restricted resources and perform specific actions.
In a typical authentication flow, a user provides their credentials (such as a username and password) to the backend server. The server then checks these credentials against a stored user database or external authentication service to verify their validity. If the credentials are valid, the server generates a token or session identifier and sends it back to the client. This token serves as proof of authentication and is usually stored by the client for subsequent requests.
The client includes the token in each subsequent request to the server, typically in the form of an HTTP header or a cookie. The server checks the validity and integrity of the token to ensure that the request is coming from an authenticated user. If the token is valid, the server allows the requested action or returns the requested data. If the token is invalid or missing, the server denies the request and returns an appropriate error response.
Authentication is crucial in backend development to protect sensitive user data, prevent unauthorized access, and ensure the security of the system. It involves various security measures such as hashing and encryption to securely store and transmit user credentials. Additionally, developers need to handle common authentication scenarios like password resets, account lockouts, and session management to provide a smooth and secure user experience.
Even though authentication is just the tip of the iceberg when it comes to application security, it's a crucial part of the majority of web applications that you're likely to work on. If backend development is your desired industry, it's going to be one of the first things you need to know about. During interviews, the interviewer might not expect you to fully understand the ins and outs of authentication, especially since many systems will do things differently, but understanding the core principles that govern authentication and know about token-based authentication will certainly give you an edge on most of your fellow candidates for the role.
REST (Representational State Transfer) API development is a widely used architectural style for designing web services that allows systems to communicate over the internet. REST APIs are based on a set of principles and constraints that promote scalability, modifiability, and interoperability.
In REST API development, resources are identified by unique URLs (Uniform Resource Locators). These resources represent entities or objects, such as users, products, or orders, that can be accessed, created, updated, or deleted using standard HTTP methods: GET, POST, PUT, PATCH, and DELETE.
The key principles of REST include:
Stateless Communication: The server does not maintain any client state between requests. Each request from the client contains all the necessary information for the server to process it. This allows for scalability and simplifies server-side development.
Client-Server Architecture: The client and server are separate entities that communicate over the network. The server provides the API endpoints and handles data storage and business logic, while the client consumes the API and presents the data to users.
Uniform Interface: REST APIs have a uniform set of operations that are applied consistently across resources. This includes using HTTP methods for specific actions (GET for retrieving data, POST for creating data, etc.), utilizing standard status codes to indicate the outcome of requests, and following a consistent data format such as JSON or XML for data representation.
HATEOAS (Hypermedia as the Engine of Application State): REST APIs can provide hyperlinks within responses to guide clients on the available actions they can take. This enables clients to navigate the API dynamically and discover related resources and operations.
To develop a REST API, you need to design the API endpoints, define the data structure and format and implement the server-side logic to handle requests and perform CRUD operations on the underlying data storage (such as a database).
REST APIs are widely used in web development for building client-server interactions, enabling communication between different systems, and facilitating integration with third-party services. They provide a flexible and scalable approach to developing web services that can be consumed by various clients, including web browsers, mobile apps, or other servers.
Understanding the core concepts behind REST and being able to talk about them, even at a high level, will make you a good candidate for any Junior Backend Developer position that you interview for. Certain web framewors, like Ruby on Rails or Django, advocate quite strongly for building RESTful APIs in the way the frameworks have been built, so learning one of those, or the many others, will give you a boost in terms of practical experience building REST APIs, especially as you can get going quickly and take on the concepts while you build a basic application or API.
SQL (Structured Query Language) is a programming language used for managing and manipulating relational databases in backend web development. It allows developers to interact with the database to store, retrieve, update, and delete data. SQL is essential for tasks such as creating database tables, defining relationships between tables, querying data, and performing complex operations.
In SQL, you use statements to communicate with the database. The most common statements include:
- SELECT: Retrieves data from one or more database tables based on specified conditions.
- INSERT: Inserts new data into a table.
- UPDATE: Modifies existing data in a table.
- DELETE: Removes data from a table.
- CREATE TABLE: Creates a new table with defined columns and data types.
- ALTER TABLE: Modifies an existing table, such as adding or removing columns.
- JOIN: Combines data from multiple tables based on specified relationships.
SQL is a declarative language, meaning you specify what data you want to retrieve or manipulate, rather than specifying how to do it. It offers powerful features such as filtering, sorting, aggregating, and grouping data. Additionally, SQL provides functions for data manipulation and calculation, as well as the ability to create views, indexes, and constraints to ensure data integrity.
As a backend web developer, you will often use SQL alongside your programming language of choice to interact with databases, store user data, handle complex queries, and implement data-driven functionalities in web applications. A solid understanding of SQL is crucial for effective backend development as it allows developers to interact with and manage data efficiently within their applications.
While you might not use SQL directly since ORMs (Object Relational Mappers) can do a lot of the heavy lifting for you and provide a much more developer-friendly interface, it's still important to know the underlying ideas and what SQL is capable of doing. Demonstrating this knowledge during an interview can be a huge advantage when applying for Junior Full-Stack Developer or Junior Backend Developer positions.
There are a few key topics that can help set you apart from other developers:
All software developers:
- Git & GitHub - learn how VCS can be used for collaboration
- Data Structures - from databases to array, learn the data structures that you can use to handle, store and manipulate data within a web application
- XHR - learn how web applications communicate with backends and APIs
- Accessibility - understand the different ways that users can consume and interact with web applications
- Performance - understand how to measure and improve the loading speed of websites and web applications
- Authentication - learn how users identify themselves securely and access protected resources
- REST APIs - learn what makes an API RESTful and what benefits that carries
- SQL - while a thorough understanding is not necessary, learn the basics of inserting, updating and querying data