Software Engineering Skills Development

During my career, I have been asked several times about "What I need to learn as an engineer?".

I have answered this question by having different roles: as a mentor, peer, coach, technical lead, software architect, staff engineer, and Principal Engineer. IMHO, the answer to this question depends on the person asking and their level.

Today I will share some useful tools that I personally use to describe my personal hard skills expectations. My proposal for every company is to create their expectations and share them with your engineering team.

The expectations that I will share (as an example) is for a web frontend engineer. Each company should adapt the contents to their necessities, roles, nature, technologies, etc.

How to create the expectations?

My suggestion: Involve your technical leaders in this process and create them collaboratively, sharing drafts with the engineering community to receive feedback and iterate until achieving the final version.

Benefits of having expectations about hard skills

• Raising the bar: is a way to push concrete ways (skills expectations) to raise the bar and push technical excellence.
• Engineer self-guidance: an engineer reading these expectations can know what is expected for a role, the current one or the next one.
• Guide managers to let them help engineers: can be used by a manager to set expectations with new or existing engineers (to be on track, to achieve promotions, etc).
• Performance review arguments: can be used as a reference to justify/do reasoning about an engineer’s improvement.
• Guide to hire people based on a skillset.

How cannot be used?

• As a strict reference to measure performance.
• As a limited vision of engineering and hard skills to learn. Engineers need to learn new technologies all the time. Don’t be limited by the technologies that have expectations and explore others.
• You don’t need to be exactly like this. Use it as orientation, is not prescriptive, and not mandatory. They are suggestions we think could help you in your day-to-day here.

Expectations matrix

Imagine the following engineering levels: Junio -> Middle -> Senior -> Staff -> Principal Engineer. In this kind of graph, we can have an overview of skills & expected levels for each role

Levels description

Languages

Typescript

1. Novice. Has theoretical knowledge about The Basics , and low experience using it.
2. Advance beginner. Has a bit real of experience with The Basics and Everyday Types .
3. Competent. Has consistent real experience working with Typescript in several projects. Knows major parts of the language.
4. Proficient. knows major parts, syntax, and elements of the language and is able to point out bad practices and best practices. Is able to solve complex problems with it.
5. Expert. Can define a Style Guide and Best Practices Guidelines with useful tips to improve the usage of the language based on experience. Not too much to learn from it to solve complex problems.

Javascript

1. Novice. Has theoretical knowledge about the language syntax, variables, data types, and basic concepts like loops and conditionals.
2. Advance beginner. Has real experience with the language and can write basic functions, handle events, and manipulate the DOM.
3. Competent. Has consistent real experience with the language and can work with more complex concepts like closures, prototypes, and async/await.
4. Proficient. Has in-depth knowledge of the language and can identify performance issues, write efficient algorithms, and understand the pros and cons of different design patterns.
5. Expert. Can design and implement complex systems using the language, write libraries and frameworks, and could contribute to the language specification.

HTML

1. Novice. Has theoretical knowledge about the language syntax, elements, and attributes.
2. Advance beginner. Has real experience with the language and can create simple web pages and forms.
3. Competent. Has consistent real experience with the language and can work with more complex elements like complex grids, nested fields in forms, and multimedia.
4. Proficient. Has in-depth knowledge of the language and can create accessible and semantic HTML code, optimize performance, and work with internationalization and localization.
5. Expert. Can design and implement complex web applications using HTML, integrate with different technologies like SEO, analytics, and social media, and contribute to the language specification.

CSS / SCSS / CSS-IN-JS

1. Novice. Has theoretical knowledge about the language syntax, selectors, properties, and values.
2. Advance beginner. Has real experience with the language and can create simple components stylesheets and layouts.
3. Competent. Has consistent real experience with the language and can work with more complex layouts, responsive design, and animations.
4. Proficient. Has in-depth knowledge of the language and can create reusable and maintainable stylesheets, optimize performance, and work with preprocessor and postprocessor tools.
5. Expert. Can design and implement complex design systems using CSS, understand the trade-offs between different styling methodologies like BEM, SMACSS, and CSS modules, and create a style architecture.

Bases

Maintainable code

1. Novice. Has theoretical knowledge about the importance of writing maintainable code, and understands basic concepts like code readability, maintainability, and simplicity.
2. Advance beginner. Has some real experience in writing maintainable code and can identify bad code smells, use descriptive naming, and follow basic code formatting rules.
3. Competent. Has consistent real experience in writing maintainable code and write self-explanatory code.
4. Proficient. Has in-depth knowledge of maintainable code rules and principles and can write code that is easy to extend, test, and refactor, use design patterns to simplify code, and mentor others on writing clean code.
5. Expert. Can design and implement maintainable code complex designs that are scalable, maintainable, and flexible, use advanced refactoring techniques, and write a codebase that is a pleasure to work with.

Object-oriented programming

1. Novice. Has theoretical knowledge about the main concepts of OOP like classes, objects, inheritance, and polymorphism.
2. Advance beginner. Has some real experience with OOP and can write basic classes and methods, and understand basic OOP principles like encapsulation and abstraction.
3. Competent. Has consistent real experience with OOP and can use advanced OOP principles like composition, interface segregation, and dependency inversion, and design flexible and extensible class hierarchies. Knows what means cohesion and coupling.
4. Proficient. Has in-depth knowledge of OOP and can use OOP principles to solve complex problems, write modular and reusable code, select the right responsibilities, and understand the pros and cons of different OOP design patterns and tradeoffs about which one should be used. Knows cohesion types and coupling types (connascense categories).
5. Expert. Can design and implement complex systems using OOP, complex Objects design, assigning the right level of abstractions and responsibilities, the scope and boundaries. Knows how to apply object calisthenics technique to exercise with objects.

Design Principles

1. Novice. Has theoretical knowledge about the main design principles like separation of responsibilities and simplicity.
2. Advance beginner. Has some real experience with design principles and can apply them to simple projects, and knows the basic ones: SOLID, DRY, POLA, and KISS.
3. Competent. Has consistent experience with design principles and can use them to design flexible and maintainable systems, refactor code to improve design, and explain the rationale behind design decisions.
4. Proficient. Has in-depth knowledge of design principles and can balance between design and implementation considerations, use design principles to reduce technical debt and increase velocity, and mentor others on design principles. Understands the trade-offs between different design principles. Has in-deep knowledge of fine-grain differences like circumstantial duplicity and code duplicity in the DRY principle.
5. Expert. Can apply design principles to complex systems, use design principles to enable innovation and evolution, and contribute to the design principles' best practices.

Smells & Refactoring

1. Novice. Has theoretical knowledge about code smells like duplication, long methods, and switch statements, and understands basic refactoring techniques like extract method and inline variable.
2. Advance beginner. Has some real experience with code smells and refactoring and can identify common code smells and refactorings, and use refactoring techniques to improve code quality.
3. Competent. Has consistent real experience with code smells and refactoring and can use advanced refactoring techniques like extract class, replace conditional with polymorphism, introduce parameter object, and measure the impact of refactoring.
4. Proficient. Has in-depth knowledge of code smells and refactoring and can identify subtle code smells and refactorings, use refactoring to improve the design and architecture of the codebase, and guide others during these processes. Is able to apply narrowed changes and parallel changes, or strangler fit patterns as techniques to do secure refactors in complex systems.
5. Expert. Can design and implement refactoring strategies for large and complex codebases, refactor legacy codebases to modern architectures, and contribute to the refactoring and code quality communities.

Design Patterns

1. Novice. Has theoretical knowledge about common design patterns like Singleton and understands the purpose and benefits of using design patterns.
2. Advance beginner. Has some real experience with design patterns and can identify common patterns in codebases (Repository, Observer, Mediator, etc), and use basic design patterns to solve simple problems.
3. Competent. Has consistent real experience with design patterns and can use more advanced patterns like Decorator, Command, and Facade, and apply patterns to solve complex problems and improve code quality.
4. Proficient. Has in-depth knowledge of design patterns, knows a big set of pattern options and their purpose and has experience applying them, and can identify anti-patterns and their solutions, use design patterns to improve the performance and maintainability of codebases, and evaluate the trade-offs of using different patterns. Knows resilience patterns like circuit breaker and retry-pattern.
5. Expert. Can design and implement new patterns, identify patterns in large and complex codebases, and apply the most accurate pattern while maintaining the simplicity of the codebase.

Concepts

Components

1. Novice. Has theoretical knowledge about Web Components and understands the basic concepts: create basic components with basic props interfaces/signatures and component state.
2. Advance beginner. Has practical experience in implementing simple components and understands the basic UI render lifecycle and how to connect with APIs.
3. Competent. Has consistent real-world experience working with Components in multiple projects. Familiar with advanced concepts like shadow DOM, encapsulation, and callback props. Has practical experience in composing simple components together to build more complex UIs.
4. Proficient. Possesses in-depth knowledge of Web Components, including advanced features and techniques, and including handling data flow and communication between components. Able to create reusable and highly customizable and composable components. Able to handle complex data flow scenarios and implement advanced composition techniques. Can identify performance optimizations and best practices.
5. Expert. Can define a comprehensive set of guidelines for building complex and performant Web Components. Has extensive experience in solving intricate problems related to components, in solving complex composition challenges, and can provide insights on emerging trends and cutting-edge practices.

Routing

1. Novice. Has theoretical knowledge about client-side routing and understands its basic concepts and purpose (movement between views, hiding/showing components based on the URL path).
2. Advance beginner. Has practical experience in implementing simple client-side routing mechanisms and understands the basic routing patterns (using params in the URL).
3. Competent. Has consistent real-world experience with client-side routing in various projects. Familiar with advanced routing features like nested routes and route guards.
4. Proficient. Possesses in-depth knowledge of client-side routing, including advanced configuration options and techniques. Able to handle complex routing scenarios and implement advanced navigation features.
5. Expert. Can define comprehensive routing strategies and best practices for large-scale applications. Has extensive experience in solving complex routing challenges, such as lazy loading and dynamic route configuration. Can provide guidance on optimizing routing performance and handling edge cases.

Communication between components

1. Novice. Has theoretical knowledge about communication between components and understands basic concepts like props and events.
2. Advance beginner. Has practical experience in passing data between components using props and emitting events. Understands basic patterns for parent-child and sibling component communication.
3. Competent. Has consistent real-world experience with various communication patterns like props drilling, event bus, or centralized state management. Familiar with component libraries/frameworks that provide communication solutions.
4. Proficient. Possesses advanced knowledge of different communication patterns and can design efficient and scalable communication strategies between components. Able to implement advanced techniques like context API, observables, or reactive frameworks for component communication. Knows exactly how it affects the rendering of each component involved in the communication.
5. Expert. Can define comprehensive guidelines for component communication in complex applications. Has extensive experience in implementing custom communication solutions and optimizing performance. Knows the underlying patterns that support the different ways/approaches to do communications like observer, command, SAM, mediator, etc. Can provide insights on emerging communication paradigms and integration with other architectural patterns.

Application or shared state management

1. Novice. Has theoretical knowledge about the application or shared state management and understands the purpose of centralizing application state.
2. Advance beginner. Has practical experience in using basic state management libraries or patterns like React's local state or Vuex in Vue.js (or similar). Understands the concept of state containers and basic state manipulation.
3. Competent. Has consistent real-world experience with popular state management solutions like (Redux, MobX, VueX, or similar). Familiar with state management concepts like middleware, selectors, or reactive state updates.
4. Proficient. Possesses in-depth knowledge of different state management approaches and can design scalable and maintainable state management architectures. Able to handle complex state dependencies, side effects, and data normalization.
5. Expert. Can define comprehensive state management strategies and best practices for large-scale applications. Has extensive experience in optimizing state management performance, and implementing advanced patterns like state persistence or time-travel debugging. Can provide guidance on choosing the right state management solution based on project requirements and team dynamics.

Rendering strategies

1. Novice. Has theoretical knowledge about client-side and server-side rendering and understands the basic concepts and differences between them.
2. Advance beginner. Has practical experience in building simple applications using either client-side or server-side rendering. Understands the basic workflow and challenges of each approach.
3. Competent. Has consistent real-world experience with both client-side and server-side rendering. Familiar with the trade-offs and benefits of each approach. Can handle basic optimizations and caching techniques for better rendering performance.
4. Proficient. Possesses advanced knowledge of rendering strategies and can design hybrid (isomorphic) rendering architectures based on project requirements. Able to optimize rendering performance, implement lazy loading, and handle data hydration/dehydration.
5. Expert. Can define comprehensive rendering strategies and best practices for different application scenarios. Has extensive experience in solving complex rendering challenges like incremental rendering, prefetching, or caching. Can provide insights on emerging rendering technologies and serverless rendering approaches.

Frameworks & Libraries

React

1. Novice. Has theoretical knowledge about the library syntax, components, props, and state.
2. Advance beginner. Has real experience with the library and can create simple components, handle events, and use basic hooks.
3. Competent. Has consistent real experience with the library and can work with more complex components, use context, and optimize performance. Knows how to create functional components using native hooks and custom hooks. Understands the render flow and react lifecycle at a high level. Knows how to do a lazy load of components.
4. Proficient. Has in-depth knowledge of the library and can create reusable and composable components hierarchies, communicate them, and do tradeoffs selecting context, state, shared states, or other options. Is able to debug complex issues. Knows different techniques to improve react components' render performance. Understands all states of react components lifecycle and how is the render flow and order. Understands and knows how to use SSR and CSR with React. Knows when to do lazy load to achieve the best performance.
5. Expert. Can design and implement complex applications using React (involving router, communicated components with shared states and pub/sub requirements), integrate with different libraries and frameworks, and understand the trade-offs between different architecture patterns to manage state based on Redux, MobX, and GraphQL. Is a real expert in determining components' responsibilities and scopes and dominates all composition techniques.

MVC HTTP frameworks (Next.js, Django, etc)

1. Novice. Has theoretical knowledge about MVC (Model-View-Controller) pattern and understands the basic concepts of HTTP server frameworks.
2. Advance beginner. Has practical experience in building simple applications using an MVC HTTP framework. Understands the basic structure of models, views, and controllers, and how they interact. Is able to obtain data to fill the models, and create a view and a controller to render simple HTML views. Is able to do the same with JSON endpoints.
3. Competent. Has consistent real-world experience with an MVC HTTP framework, such as Next.js, Django, or similar. Familiar with advanced features and functionalities provided by the framework. Can implement CRUD operations, handle routing, and manage basic authentication.
4. Proficient. Possesses in-depth knowledge of the chosen MVC HTTP framework and its underlying principles. Able to design complex models, views, and controllers, following best practices. Is able to understand the entire request pipeline inside the framework and knows how to work with request middleware. Can optimize performance, handle advanced authentication and authorization mechanisms, and implement advanced features like caching and pagination.
5. Expert. Can define comprehensive guidelines and best practices for building large-scale applications using an MVC HTTP framework. Has extensive experience in solving complex architectural challenges, such as modularization, scalability, and maintainability. Can provide insights on optimizing requests, security considerations (SQL injections, etc), and integrating external services or APIs. Can mentor and guide other developers in leveraging the full potential of the chosen framework.

Testing

Testing

1. Novice. Has theoretical knowledge about the importance of testing, and understands basic testing concepts like unit testing, integration testing, and end-to-end test.
2. Advance beginner. Has some real experience with testing and can write basic unit tests, use testing tools & frameworks like enzyme, jest, mocha, or react-testing-library. Knows how to name basic tests. Knows basic concepts like SUT, test, test suite, test runner, etc.
3. Competent. Has consistent real experience with testing and can use more advanced testing techniques like mocking, fixture composition, and property-based testing, and understand the trade-offs between different testing methodologies. Uses code coverage tools to measure the effectiveness of tests. Knows the F.I.R.S.T rules. Identifies the different parts of the tests based on responsibilities (ArrangeActAssert or GivenWhenThen).
4. Proficient. Has in-depth knowledge of testing and can use testing to improve the design and architecture of the codebase, design and implement effective test strategies for large and complex systems, and guide others on testing best practices. Knows the difference between false double types (spy, mock, stub, etc) and when to apply each one. Knows how to implement behavioral testing, when to use unit tests, integration tests, and e2e tests, and balance the amount of each one to achieve the best value protecting the product behavior. Knows advanced patterns to organic tests nesting scenarios, using Page Object patterns, Builder + fluent APIs to create scenarios, and other advanced techniques.
5. Expert. Can design and implement testing strategies for large and complex systems, using full-automated product behaviors using continuous integration and deployment, and has a deep knowledge of best practices and anti-patterns when building tests and testing strategies/architectures.

Architecture

Architecture & System Design

1. Novice. Has theoretical knowledge about basic frontend architectures and system design, and understands basic concepts like 3-layer architecture (UI, business, data access), and client-server architecture.
2. Advance beginner. Has some real experience with simple architecture and system design and can design simple systems, and how to organize the codebase using the architecture layers and concepts. Knows how to create simple components' architectures in a SPA with CSR.
3. Competent. Has consistent real experience with architecture and system design and can design and implement complex systems, understands the trade-offs between different architectural approaches (SSR/CSR/Isomorphic), use advanced architectural patterns (SAM, separation of concerns in the frontend) and styles like micro frontends, BFF, and optimize systems for performance and scalability.
4. Proficient. Has in-depth knowledge of architecture and system design and can identify business and technical requirements, design solutions that meet those requirements, evaluate trade-offs between different architectural patterns and styles, and ensure that the architecture aligns with the organization's goals and constraints.
5. Expert. Can design and implement architecture and system design strategies for large and complex systems, use architecture to enable innovation and evolution, and contribute to the architecture guild & community.

Infrastructure

CDN

1. Novice. Has theoretical knowledge about CDNs and understands their basic purpose and benefits.
2. Advance beginner. Has practical experience in integrating and using a CDN for static file delivery. Understands basic caching mechanisms and content distribution.
3. Competent. Has consistent real-world experience with using CDNs in various projects. Familiar with advanced features like content optimization, edge caching, and global content delivery.
4. Proficient. Possesses in-depth knowledge of CDNs, including advanced configuration options and performance optimizations. Able to implement caching strategies, handle content invalidation, and optimize CDN usage for dynamic content.
5. Expert. Can define comprehensive CDN strategies and best practices for large-scale applications. Has extensive experience in optimizing content delivery, implementing geo-routing, and leveraging CDN security features. Can provide guidance on selecting the right CDN provider and integrating CDNs with other components of the application architecture.

S3

1. Novice. Has theoretical knowledge about S3 and understands its basic purpose as a cloud storage service.
2. Advance beginner. Has practical experience in using S3 for basic file storage and retrieval. Understands S3 bucket configuration and basic access controls.
3. Competent. Has consistent real-world experience with S3, including advanced features like versioning, lifecycle policies, and cross-region replication. Familiar with integrating S3 with other AWS services.
4. Proficient. Possesses in-depth knowledge of S3 and its advanced capabilities. Able to design scalable and highly available S3 architectures, implement data encryption, and optimize performance and cost-efficiency.
5. Expert. Can define comprehensive S3 strategies and best practices for managing large-scale data storage and retrieval. Has extensive experience in optimizing data transfer, implementing data governance and compliance, and integrating S3 with serverless and microservices architectures. Can provide guidance on S3 performance tuning, security hardening, and disaster recovery.

Web server

1. Novice. Has theoretical knowledge about web servers and understands their role in handling HTTP requests and serving web content.
2. Advance beginner. Has practical experience in configuring and using basic web servers. Understands basic server configurations and virtual hosting.
3. Competent. Has consistent real-world experience with web servers, including load balancing, reverse proxy setup, and SSL/TLS configuration. Familiar with server-side caching and request/response optimization techniques.
4. Proficient. Possesses in-depth knowledge of web server technologies and can design high-performance and secure server architectures. Able to handle complex traffic management, implement advanced security features, and optimize server-side performance.
5. Expert. Can define comprehensive web server strategies and best practices for large-scale applications. Has extensive experience in optimizing server scalability, implementing fault-tolerant setups, and integrating with CDN and caching layers. Can provide insights on emerging web server technologies, containerization, and cloud-native deployment patterns.

Bundlers/compilers/transpilers

1. Novice. Has theoretical knowledge about bundlers, compilers, and transpilers and understands their purpose in the development process.
2. Advance beginner. Has practical experience in using basic bundlers like Webpack or Rollup to bundle and optimize frontend assets. Understands basic configuration and module bundling concepts.
3. Competent. Has consistent real-world experience with bundlers/compilers/transpilers, including advanced configuration for code splitting, asset optimization, and transpiling modern JavaScript or CSS syntax.
4. Proficient. Possesses in-depth knowledge of bundler/compiler/transpiler tools and their advanced features. Able to optimize build pipelines, implement advanced optimizations, and integrate with frameworks and libraries.
5. Expert. Can define comprehensive build tool strategies and best practices for large-scale applications. Has extensive experience in optimizing build performance, implementing custom build processes, and integrating with CI/CD pipelines. Can provide insights on choosing the right tools for specific project requirements and optimizing build outputs for production

Package managers

1. Novice. Has theoretical knowledge about package managers and understands their role in managing dependencies and project dependencies.
2. Advance beginner. Has practical experience in using basic package managers like npm or Yarn to install and manage project dependencies. Understands basic package.json or package-lock.json management.
3. Competent. Has consistent real-world experience with package managers, including advanced features like version management, dependency resolution, and package publishing. Familiar with package registry configuration and package versioning strategies.
4. Proficient. Possesses in-depth knowledge of package managers and can design efficient dependency management workflows. Able to handle complex dependency trees, manage version conflicts, and optimize package installation and updates.
5. Expert. Can define comprehensive package management strategies and best practices for large-scale applications. Has extensive experience in optimizing dependency resolution, implementing package caching and mirroring, and integrating with package vulnerability scanning tools. Can provide guidance on package publishing workflows, package monorepo management, and package versioning strategies.