library / lib6286e9e9e358f4b1
The Software Engineer's Guidebook
Gergely Orosz · 2023
In a sentence
A career-spanning field manual that explains the skills, behaviors, and judgment software engineers need to grow from entry-level developer through senior, tech lead, and staff/principal roles at tech companies and startups.
Written by Gergely Orosz, a former engineer and manager at Uber, Microsoft, and Skyscanner, and author of The Pragmatic Engineer Newsletter, this book is the practical guide he wishes he'd had early in his career. It follows the typical software engineering career arc and pairs durable 'soft' skills (owning your career, performance reviews, promotions, collaboration, stakeholder management) with the 'hard' craft of engineering (coding, debugging, testing, software architecture, shipping to production, and building reliable systems). Rather than offering one-size-fits-all rules, it equips readers with a toolkit of approaches and the judgment to know when to apply each, grounded in how Big Tech, scaleups, startups, and traditional companies actually operate. If you want to grow as an engineer—accelerate your impact, take ownership of your trajectory, and understand what's expected at each level—this is a reference you'll return to for years.
The four lenses
- Science
- Statistics
- Systems
- Strategy
Tags
The model
A factor model expressing how design levers and conditions (career ownership behaviors, engineering practices, collaboration, business understanding) drive psychological and behavioral states (reliability reputation, trust capital, influence) and outcomes (career progression, software reliability, team execution). Inferred from the book's structured, level-based guidance.
Career Ownership Behaviorsdesign lever
The degree to which an engineer proactively takes charge of their own professional growth by setting goals, keeping a work log, seeking feedback, making their manager an ally, and pacing themselves rather than waiting for recognition to arrive.
Work Visibility and Communicationbehavioral pattern
The extent to which an engineer makes their accomplishments, challenges, roadblocks, and impact known to managers, peers, and stakeholders through status updates, 1:1s, work logs, and the produce-organize-publish framework, rather than assuming work speaks for itself.
Getting Things Done Effectivelybehavioral pattern
An engineer's ability to focus on the most important work, unblock themselves, break down and estimate work, take initiative, and deliver impactful results with appropriate quality and pace, including doing work 'properly' so it works as intended.
Engineering Craft Proficiencydesign lever
Depth and breadth of technical skill including coding, language and framework proficiency, debugging, refactoring, readable code, and use of productive tools, which forms the technical foundation of competence as a developer.
Healthy Engineering Practicesdesign lever
Team and individual adoption of practices such as automated testing, code reviews, CI/CD, documentation, written planning, staged rollouts, and safe shipping to production that increase quality, maintainability, and iteration speed.
Collaboration and Teamwork Qualitybehavioral pattern
Effectiveness of working with others through good code reviews, pairing, mentoring, giving and receiving feedback, working across engineering teams, and managing stakeholders to keep everyone aligned and projects on track.
Business and Product Understandingdesign lever
An engineer's grasp of how the company makes money, what customers need, North Stars, KPIs, OKRs, profit versus cost centers, and the industry, enabling problem-finding and pragmatic tradeoffs aligned with business goals.
Reputation as Reliable Engineerpsychological state
The perception held by managers and peers that an engineer consistently delivers impactful, properly-done work on time, unblocks themselves, and communicates effectively—a psychological/social state that shapes opportunities and autonomy.
Trust Capital and Influencepsychological state
The accumulated goodwill, credibility, and standing—built from title, tenure, expertise, track record, and visible work—that enables an engineer to influence decisions, gather support for initiatives, and operate as a partner to managers and product.
Team Execution and Healthoutcome metric
The degree to which a team has clarity, executes and ships visibly, maintains good morale and healthy communication, and avoids dysfunctions like treading water, excessive context switching, or unaddressed tech debt.
Software System Reliabilityoutcome metric
The outcome of building and operating dependable systems, measured through uptime, latency percentiles, error rates, effective monitoring, alerting precision/recall, oncall health, and blameless incident management.
Career Progression and Recognitionoutcome metric
The downstream outcome of fair performance reviews, promotions, compensation growth, and expanded scope and impact across levels from developer to staff/principal.
Company Type and Compensation Tiercontextual condition
The contextual environment defined by company type (Big Tech, scaleup, startup, traditional, consultancy) and compensation tier (local, top-of-local, top-of-regional), which sets the level of expectations placed on engineers and shapes which behaviors are rewarded.
Wartime vs Peacetime Operating Modecontextual condition
The contextual operating state of a company—wartime (existential pressure, speed over quality, fewer allies needed) versus peacetime (stability, quality and alliance-building rewarded)—which moderates which getting-things-done and collaboration approaches succeed.
Lifelong Learning and Curiositybehavioral pattern
The ongoing practice of staying curious, asking questions, learning new languages and technologies, sharing knowledge, challenging oneself, keeping up with the industry, and pacing learning to avoid burnout.
How they connect
- career ownership → predicts work visibility
- work visibility → predicts reliability reputation
- getting things done → predicts reliability reputation
- engineering craft → predicts getting things done
- work visibility → mediates getting things done
- reliability reputation → predicts career progression
- trust capital influence → predicts career progression
- collaboration quality → predicts trust capital influence
- work visibility → predicts trust capital influence
- business understanding → influences trust capital influence
- engineering practices → predicts software reliability
- engineering practices → predicts team execution health
- collaboration quality → predicts team execution health
- business understanding → influences getting things done
- company tier context → moderates career progression
- wartime peacetime mode → moderates getting things done
- lifelong learning → predicts engineering craft
- lifelong learning → influences business understanding
- software reliability → influences team execution health
The process
This playbook provides a comprehensive guide for software engineers to navigate their careers, from identifying the right company fit to achieving senior-level impact. It begins with foundational processes for career planning, job seeking, and proactive self-management, including maintaining a work log and seeking feedback. The playbook then transitions into the core technical and execution skills required for day-to-day success, such as effective coding practices, debugging, testing, and project planning. As an engineer's responsibilities grow, the playbook introduces processes for effective collaboration, communication, and project management within a team. It covers the full software development lifecycle, from architectural design using RFCs and prototyping to safe deployment strategies with CI/CD, staged rollouts, and monitoring. Finally, it addresses the skills necessary for leadership and influence, including stakeholder management, developing a product mindset, navigating organizational dynamics, and fostering a healthy team environment. This structured approach equips engineers with the processes needed to not only deliver high-quality software but also to build a successful and impactful career.
Identify Career Fit
To determine which type of tech company, compensation tier, and career track aligns best with an engineer's career goals, values, and circumstances.
When to use: When starting a career, considering a job change, or re-evaluating long-term professional goals.
Step 1Understand the characteristics of different tech company types (e.g., startups, Big Tech) and compensation tiers.
Exit: A clear understanding of the tech landscape is achieved.
In: Market research on company types and compensation · Out: Categorization of potential employers
ch01
Step 2Assess personal career aspirations, values, and desired career path (e.g., single-track vs. dual-track).
Entry: Understanding of the tech landscape.
Exit: Personal career preferences are clearly defined.
- Choosing between management and individual contributor tracks.
In: Personal career goals and values · Out: Defined career path preference
ch01
Step 3Narrow down company options based on the alignment of your goals with their structure and compensation.
Entry: Defined personal career preferences.
Exit: A shortlist of target company types is created.
- Deciding which company types to target.
In: Professional network · Out: A list of suitable company types or specific companies
ch01
Job Seeking and Onboarding
To effectively explore new job opportunities, prepare for interviews, and successfully integrate into a new company.
When to use: When considering or starting a new job.
Step 1Determine job search strategy: active seeking or passive openness.
Entry: A decision to explore new opportunities.
Exit: A clear job search strategy is in place.
- Choosing between active and passive job searching.
In: Current job satisfaction assessment · Out: Updated professional profiles
ch06
Step 2Prepare for and participate in the technical interview process.
Entry: An interview opportunity is secured.
Exit: The interview process is completed.
In: Job description, Resume · Out: Potential job offer
ch06
Step 3Effectively onboard into the new role.
Entry: A job offer has been accepted.
Exit: A structured and successful onboarding experience.
In: New job offer, Onboarding materials · Out: Established rapport with team, Clear understanding of initial job expectations
ch06
Proactive Career Management
To take ownership of one's career growth through self-advocacy, documentation, continuous feedback, and sustainable pacing.
When to use: Continuously throughout an engineer's career.
Step 1Take ownership of your career by communicating your goals to your manager and peers.
Exit: Manager and peers are aware of your career aspirations.
In: Self-awareness of career aspirations · Out: Supportive relationship with manager
ch02 · ch04
Step 2Maintain a work log or 'brag document' of achievements and contributions.
Exit: A consistent and up-to-date record of accomplishments is maintained.
- Deciding on the level of detail to include in the log.
In: Weekly work outputs · Out: Comprehensive work log
ch02 · ch03
Step 3Proactively request specific and targeted feedback from peers and managers.
Entry: A specific project or task is completed.
Exit: Actionable feedback is received and documented.
- Determining whom to approach for feedback.
In: Completed work · Out: Documented feedback, Performance improvement plan
ch02 · ch03 · ch04
Step 4Pace yourself to manage workload sustainably and prevent burnout.
Exit: A sustainable work-life balance is achieved.
- Deciding when to take on new challenges versus when to pull back.
In: Self-assessment of mental and physical state · Out: Balanced workload
ch02
Mastering Technical Tools
To build deep proficiency in essential software development tools, including programming languages, IDEs, and version control, to enhance productivity and effectiveness.
When to use: Continuously throughout an engineer's career, especially when onboarding to new projects or technologies.
Step 1Become proficient in multiple programming language paradigms (imperative, declarative, functional).
Entry: Basic programming knowledge.
Exit: Deep understanding of at least one language from each major paradigm.
In: Learning resources (books, courses, documentation) · Out: Enhanced coding competence
ch09 · ch13
Step 2Master your Integrated Development Environment (IDE).
Entry: An IDE is installed and configured.
Exit: High efficiency in using the IDE for coding, debugging, and testing.
In: IDE software · Out: Increased coding efficiency
ch10
Step 3Utilize version control with Git effectively.
Entry: Access to a Git repository.
Exit: Comfort with common Git commands and workflows.
- Choosing between a command-line interface or a GUI for Git.
In: Git client · Out: Effective code management and collaboration
ch10
Step 4Create a personal productivity cheat sheet for internal tools and commands.
Entry: Engagement with a new project or team.
Exit: A personal reference guide is created and maintained.
In: Information from colleagues and documentation · Out: Personal productivity cheat sheet
ch10
Core Coding Practices
To establish a foundation of strong coding habits that improve code quality, readability, maintainability, and consistency.
When to use: During the daily software development process.
Step 1Practice coding daily to build and maintain proficiency.
Exit: Consistent coding habit is established.
In: Coding projects or problems · Out: Improved coding proficiency
ch08
Step 2Write readable and simple code.
Entry: A coding task is started.
Exit: Code is clear, maintainable, and peer-reviewed.
In: Coding task requirements · Out: Readable code
ch08
Step 3Implement a consistent error handling strategy.
Exit: Robust error handling is implemented in the code.
- Choosing between allowlists and blocklists for handling unknown API states.
In: Knowledge of potential error conditions · Out: Resilient code
ch08
Step 4Refactor code regularly to improve its quality and maintainability.
Entry: Code has been written.
Exit: Code is cleaner and more maintainable.
In: Existing codebase · Out: Refactored code
ch09
Step 5Adhere to team coding style guidelines.
Entry: Team has agreed on coding style guidelines.
Exit: All committed code adheres to the style guide.
In: Coding style guide · Out: Consistently formatted code
ch23
Step 6Iterate rapidly with small, well-documented pull requests (PRs).
Entry: A feature or fix needs to be implemented.
Exit: Change is merged after review.
- Choosing the scope of changes for a single PR.
In: Codebase · Out: Merged pull request
ch10
Debugging and Troubleshooting
To efficiently identify, diagnose, and resolve errors in code, CI/CD pipelines, and production systems.
When to use: When a bug is reported, a test fails, a CI/CD pipeline breaks, or a production incident occurs.
Step 1Utilize IDE debugging tools to inspect code execution.
Entry: A reproducible bug is identified in the local environment.
Exit: The root cause of the bug is understood.
- Choosing between IDE tools and manual debugging methods like logging.
In: Codebase, IDE with debugging tools · Out: Identified root cause
ch09 · ch13
Step 2Apply non-tool debugging methods when necessary.
Entry: IDE tools are unavailable or insufficient.
Exit: The bug is identified and resolved.
Out: Resolved bug
ch09
Step 3Troubleshoot CI/CD pipeline issues.
Entry: A CI/CD pipeline fails.
Exit: The pipeline issue is resolved.
- Assessing whether the issue is a code change or an infrastructure problem.
In: CI/CD logs · Out: A passing CI/CD pipeline
ch10
Step 4Debug issues in production systems.
Entry: A production incident or bug is reported.
Exit: The production issue is resolved.
In: Production logs, Metrics dashboards · Out: Resolved production issue
ch13
Implementing a Testing Strategy
To ensure code reliability and functionality through a multi-layered testing approach, including unit, integration, and UI tests.
When to use: Throughout the development lifecycle, from initial coding to pre-deployment validation.
Step 1Conduct manual tests before committing code.
Entry: A feature or bug fix is coded.
Exit: Basic functionality is confirmed and edge cases are identified.
In: Completed code · Out: List of test cases for automation
ch09
Step 2Write and execute unit tests to validate isolated components.
Entry: An isolated component of code is complete.
Exit: Unit tests pass, validating the component's functionality.
- If a test fails, determine if the code or the test needs adjustment.
In: Source code of the component, Testing framework · Out: Passing unit tests
ch14
Step 3Write and execute integration tests to validate interactions between components.
Entry: Multiple interacting components are complete.
Exit: Integration tests pass, validating the collaboration between units.
In: Source code for multiple units · Out: Passing integration tests
ch14
Step 4Write and execute UI tests to simulate user interactions.
Entry: The application is deployable in a test environment.
Exit: UI tests pass, validating key user flows.
In: Application code, UI testing framework · Out: Passing UI tests
ch14
Daily Work Execution and Prioritization
To manage daily tasks, priorities, and interruptions effectively to maintain focus and productivity.
When to use: On a daily basis to manage workload and respond to incoming requests.
Step 1Identify and commit to the single most important task for the week.
Entry: A list of potential tasks for the week.
Exit: The priority task is identified and committed to.
- Deciding which task is the highest priority.
In: Task list, Project deadlines · Out: A single priority task for the week
ch07
Step 2Prioritize inbound requests using the urgency/importance matrix.
Entry: An inbound request is received.
Exit: The request is categorized and an action is determined.
- Deciding the urgency and importance of a task.
In: Inbound requests · Out: Prioritized task list
ch11
Step 3Manage interruptions to protect focus time.
Entry: A period of focused work is needed.
Exit: Uninterrupted work time is protected.
Out: Scheduled focus time
ch11
Step 4Proactively unblock yourself when stuck.
Entry: No progress is being made on a task.
Exit: The blocker is resolved and progress resumes.
- Choosing which unblocking technique to use.
In: Recognition of being blocked · Out: Resolved blocker
ch07
Step 5Take initiative beyond assigned tasks.
Entry: Core responsibilities are being met.
Exit: Contributions are made beyond assigned tasks.
- Choosing which initiatives to pursue based on workload and interest.
Out: Proactive contributions to the team
ch07
Effective Collaboration and Communication
To foster a positive and productive team environment through clear communication, structured feedback, and mutual support.
When to use: During daily interactions, code reviews, pair programming sessions, and status updates.
Step 1Conduct structured and constructive code reviews.
Entry: A pull request is submitted for review.
Exit: The code is approved and merged after constructive feedback is addressed.
- Deciding whether feedback is blocking or non-blocking.
In: Code change submission · Out: Improved code quality, Shared knowledge
ch08 · ch12
Step 2Use pair programming for complex problems or knowledge sharing.
Entry: A complex problem needs solving or a new member needs onboarding.
Exit: The problem is solved or knowledge is transferred.
In: A defined problem · Out: Resolved coding issue, Stronger team relationships
ch12
Step 3Give specific and respectful feedback.
Entry: An opportunity to provide feedback arises.
Exit: Feedback is delivered and received constructively.
In: Observations of a team member's performance · Out: Improved individual performance
ch12
Step 4Communicate your work effectively to ensure visibility and recognition.
Entry: A status update is required (e.g., in a team meeting).
Exit: Peers and managers understand the complexity and value of your contributions.
In: Project details · Out: Improved recognition of work
ch11
Step 5Maintain a positive 'goodwill balance' with colleagues.
Exit: Positive and reciprocal working relationships are maintained.
Out: A collaborative team environment
ch07
Project Planning and Estimation
To effectively break down complex projects into manageable tasks, establish clear milestones, and provide realistic time estimates.
When to use: At the beginning of a project or a new phase of work.
Step 1Break down the project into major components or 'epics'.
Entry: High-level project goals are defined.
Exit: The project is broken down into epics.
In: Project goals · Out: List of project epics
ch07
Step 2Break down epics into smaller, manageable tasks and subtasks.
Entry: Epics are defined.
Exit: A detailed task breakdown is created.
- Determining the necessary level of task granularity.
In: List of epics · Out: Detailed task list
ch07
Step 3Define granular milestones that can be achieved within a few weeks.
Entry: Tasks are broken down.
Exit: A clear timeline of project milestones is established.
In: Detailed task list · Out: Project milestones
ch16
Step 4Estimate the duration of the work required for each milestone.
Entry: Milestones and their associated tasks are defined.
Exit: Rough time estimates are assigned to milestones.
- Choosing an estimation strategy.
In: Task breakdown · Out: Time estimates for milestones
ch07 · ch16
Project Management and Execution
To structure and manage the execution of a project from kickoff to completion, ensuring alignment, accountability, and continuous improvement.
When to use: Throughout the entire lifecycle of a project.
Step 1Conduct a project kickoff meeting to align all stakeholders.
Entry: A new project is approved.
Exit: All stakeholders are aligned on project goals and scope.
In: Product Requirements Document (PRD) · Out: Aligned understanding among stakeholders
ch16
Step 2Choose and implement a day-to-day project management framework.
Entry: The project has been kicked off.
Exit: A structured project management process is in place.
- Choosing between Scrum, Kanban, or a hybrid model.
In: Team consensus · Out: Improved team cohesion and transparency
ch16
Step 3Establish and agree upon a team 'Definition of Done' (DoD).
Entry: The team is working on shared tasks.
Exit: A documented Definition of Done is agreed upon by the team.
In: Team members' individual definitions of 'done' · Out: Shared Definition of Done
ch23
Step 4Properly wrap up the project upon completion.
Entry: Project work is complete.
Exit: The project is formally closed and learnings are documented.
In: Completed project · Out: Project retrospective document, Final project update
ch16
Implementing CI/CD Pipelines
To automate the integration, testing, and deployment of code changes to ensure stability, improve quality, and enable rapid delivery.
When to use: As a standard part of the development workflow for any project with ongoing changes.
Step 1Implement Continuous Integration (CI) to validate code changes automatically.
Entry: A pull request is opened.
Exit: The CI pipeline provides rapid feedback on the code change's quality and integration status.
In: Code changes in a pull request · Out: CI build status (pass/fail), Test and linting results
ch23
Step 2Implement Continuous Deployment (CD) to automate releases to production.
Entry: A change is merged to the main branch after passing CI.
Exit: The change is deployed to production.
In: Approved code changes · Out: A new version of the application in production
ch23
Step 3Use staged rollouts and automated rollbacks to minimize deployment risk.
Entry: A deployment is initiated.
Exit: The deployment is completed successfully or rolled back safely.
- Defining the criteria for a healthy deployment vs. a rollback.
In: Production health metrics · Out: A safe production release
ch23
Managing Software Deployment
To manage the process of releasing software to production, balancing speed with safety and reliability through various validation and rollout strategies.
When to use: Whenever a code change is ready to be released to users.
Step 1Choose a deployment strategy based on risk and product maturity.
Entry: Code is ready for deployment.
Exit: A deployment strategy is selected.
- Deciding between speed and safety for a given change.
In: Assessment of change risk · Out: Selected deployment strategy
ch17
Step 2Perform pre-production validation through multiple test environments.
Entry: A deployment is initiated for a mature product.
Exit: The change is thoroughly validated before production release.
In: Test environments, QA resources · Out: Verified code ready for production
ch17
Step 3Execute a staged rollout to incrementally release the change to users.
Entry: The change has passed pre-production validation.
Exit: The feature is fully rolled out or halted due to issues.
- Deciding whether to proceed to the next stage based on monitoring data.
In: Rollout plan, Monitoring tools · Out: A gradual and safe feature release
ch17
Step 4Use canary testing to assess the health of a new version.
Entry: A new version is ready for initial production exposure.
Exit: The health of the new version is confirmed.
In: Load balancing tools · Out: Early detection of deployment issues
ch17
Step 5Implement robust monitoring, alerting, and incident management for production systems.
Entry: Any deployment to production.
Exit: Production systems are continuously observed and incidents are managed effectively.
In: Monitoring tools · Out: Resilient production environment
ch17
Maintaining Effective Documentation
To create and maintain clear, accessible, and up-to-date documentation to aid team communication, onboarding, and system understanding.
When to use: Throughout the project lifecycle, from design to maintenance.
Step 1Identify the types of documentation needed for the project or team.
Entry: A new project is started or a knowledge gap is identified.
Exit: The required documentation types are defined.
- Deciding what information is most critical to document.
In: Project scope, Team needs · Out: A list of documents to be created
ch11 · ch13
Step 2Draft initial documentation during the planning phase of projects.
Entry: The planning phase of a project begins.
Exit: Initial design documentation is drafted and shared.
In: Project requirements · Out: Draft design document
ch13
Step 3Store documents in a shared, accessible location.
Entry: A document is created.
Exit: The document is stored in a central repository.
In: Completed document · Out: Accessible documentation
ch11
Step 4Update documentation as systems and processes evolve.
Entry: A change is made to a system or process.
Exit: The relevant documentation is updated to reflect the change.
In: System or process change · Out: Current and accurate documentation
ch11 · ch13
Managing Performance Reviews
To effectively prepare for and navigate the performance review process to ensure accurate evaluation and recognition of contributions.
When to use: Leading up to and during the formal performance review period.
Step 1Gather context on what the company values for performance.
Entry: The performance review cycle is approaching.
Exit: A clear understanding of performance expectations is achieved.
In: Company communications, Team goals · Out: Understanding of organizational priorities
ch03
Step 2Gather peer feedback on your performance.
Entry: Key projects have been completed.
Exit: Peer feedback is collected and documented.
In: List of peers · Out: Documented peer feedback
ch03
Step 3Prepare and write a self-review document.
Entry: Work log and peer feedback are available.
Exit: A comprehensive self-review is completed.
- Deciding which achievements to highlight.
In: Work log, Peer feedback · Out: Self-review document
ch03
Step 4Submit the self-review and participate in the review meeting.
Entry: Self-review is complete.
Exit: Performance review meeting is concluded.
In: Self-review document · Out: Performance rating, Feedback from manager
ch03
Navigating Promotions
To understand and strategically navigate the promotion process to advance one's career.
When to use: When an engineer is aiming for or being considered for a promotion.
Step 1Understand your company's promotion process and criteria.
Entry: A desire for promotion.
Exit: A clear understanding of the promotion process and criteria.
In: Company documentation, Discussions with manager · Out: Tailored strategy for navigating the process
ch04
Step 2Use the 'Produce, Organize, Publish' framework to increase visibility.
Entry: Working on impactful projects.
Exit: Contributions are visible to decision-makers.
In: Work artifacts (code, designs, docs) · Out: Increased visibility of contributions
ch04
Step 3Build support from your manager and key stakeholders.
Entry: A good working relationship with your manager.
Exit: Managerial support for the promotion case.
In: Performance data, Personal aspirations · Out: Advocates for your promotion
ch04
Step 4Gather perception feedback from decision-makers.
Entry: Promotion case is being built.
Exit: A clear understanding of how your candidacy is perceived.
In: Feedback from mentors and peers · Out: Stronger promotion case
ch04
Building Influence and Relationships
To build trust, influence, and strong professional relationships with managers, mentors, and peers to enhance collaboration, career growth, and overall impact.
When to use: Continuously throughout one's career.
Step 1Build trust capital by consistently delivering high-quality work and making it visible.
Exit: A reputation as a trustworthy and effective engineer is established.
In: Quality work · Out: Trust capital
ch12 · ch22
Step 2Cultivate a strong, collaborative relationship with your manager.
Entry: Regular 1:1 meetings are scheduled.
Exit: A supportive, allied relationship with your manager is formed.
In: Work log, Career aspirations · Out: Managerial support and advocacy
ch02 · ch04 · ch22
Step 3Establish mentorship relationships for guidance and support.
Entry: A need for guidance or a desire to help others.
Exit: A productive mentorship relationship is established.
Out: Professional growth for mentee, Leadership experience for mentor
ch07 · ch12 · ch22
Step 4Navigate internal politics by focusing on influence over self-serving behavior.
Entry: Working in a collaborative environment.
Exit: Positive influence is established, enhancing collaboration.
Out: Improved team dynamics, Expanded professional network
ch12 · ch20 · ch22
Step 5Sponsor colleagues to advocate for their growth and visibility.
Entry: You are in a position of influence.
Exit: A colleague's career is advanced through your advocacy.
Out: Enhanced career growth for sponsored individual
ch22
Managing Stakeholder Relationships
To identify, communicate with, and manage all relevant stakeholders to ensure project alignment, avoid delays, and foster positive collaboration.
When to use: At the beginning of and throughout any project with cross-team dependencies or impact.
Step 1Identify all key stakeholders early in the project lifecycle.
Entry: A new project is initiated.
Exit: A comprehensive list of stakeholders is created.
In: Project scope, Organizational charts · Out: Stakeholder list
ch18
Step 2Establish a communication plan to keep stakeholders informed.
Entry: Stakeholders have been identified.
Exit: A regular communication cadence is established.
- Choosing between synchronous meetings and asynchronous updates.
In: Stakeholder list, Project status updates · Out: Informed and engaged stakeholders
ch18
Step 3Manage problematic stakeholders through direct communication and transparency.
Entry: A stakeholder relationship is causing friction or delays.
Exit: The issue is resolved or a path to resolution is agreed upon.
- Determining when to escalate issues to management.
In: Details of the issue · Out: Improved trust and collaboration
ch18
Step 4Treat stakeholder interactions as learning opportunities.
Entry: Interacting with a stakeholder.
Exit: Deeper understanding of interdepartmental dynamics is gained.
Out: Enhanced business context
ch18
Developing a Product Mindset
To align engineering work with business and customer needs by understanding the product, its users, and its market position.
When to use: Continuously, to inform technical decisions and strategic contributions.
Step 1Understand the company's business goals and metrics.
Exit: A clear understanding of how engineering work contributes to business goals.
In: Business goals, Team objectives · Out: Alignment of technical work with business strategy
ch05 · ch11 · ch21
Step 2Engage directly with customers and user feedback.
Exit: Actionable insights into customer needs are gained.
In: Customer data, User feedback · Out: Improved product relevance
ch05 · ch11 · ch21
Step 3Build strong collaborative relationships with product managers.
Exit: A strong partnership with the product team is established.
Out: More impactful engineering contributions
ch05 · ch11 · ch21
Step 4Analyze the product's strategic market position.
Exit: A strategic overview of the product is created.
In: Market data, Competitive analysis · Out: SWOT analysis document
ch21
Software Architecture and Design
To design, implement, and evolve robust and scalable software systems that meet business needs while managing technical debt and complexity.
When to use: During the planning and execution of new systems or major changes to existing ones.
Step 1Write a Request for Comments (RFC) to clarify design and gather feedback early.
Entry: A complex project or architectural change is proposed.
Exit: A refined design plan incorporating stakeholder feedback is finalized.
- Deciding whether to prototype first, wait for feedback, or build while awaiting feedback.
In: Project objectives, Proposed design · Out: Approved RFC
ch15
Step 2Use prototyping to explore solutions and address unknowns.
Entry: Significant unknowns exist in the project.
Exit: Key uncertainties are resolved, informing the final design.
In: Project uncertainties · Out: Better understanding of the problem space
ch15
Step 3Apply Domain-Driven Design (DDD) for complex business domains.
Entry: Building a system with significant business logic.
Exit: A domain model that accurately reflects business needs is created.
In: Knowledge of the business domain · Out: Clear software design aligned with business logic
ch15
Step 4Systematically roll out architectural changes.
Entry: A major architectural change is ready for implementation.
Exit: The change is successfully implemented and validated in production.
In: Architecture goals, Rollout plan · Out: Implemented architectural change
ch15
Step 5Proactively manage and address technical debt.
Entry: Technical debt is identified in the codebase.
Exit: Technical debt is reduced, improving codebase maintainability.
- Deciding which tech debt to address first based on impact vs. effort.
In: Inventory of technical debt · Out: Reduced technical debt
ch13
Step 6Reflect on architectural decisions through retrospectives.
Entry: A project with significant architectural decisions is completed.
Exit: Lessons learned are documented and shared.
In: Project outcomes, Team feedback · Out: Documented architectural learnings
ch15
Defining and Managing Team Operations
To establish clear roles, effective processes, and a focused direction for an engineering team to enhance productivity, accountability, and agility.
When to use: When leading a team, onboarding new members, or seeking to improve team effectiveness.
Step 1Establish clear roles and responsibilities within the team.
Entry: Ambiguity exists around team responsibilities.
Exit: A clear and documented list of team roles is created.
- Deciding which implicit roles need to be made explicit.
In: Discussions with manager and team · Out: Documented team roles
ch19
Step 2Evaluate and manage team processes.
Entry: A need to improve team workflow.
Exit: An optimized set of processes tailored to the team's needs.
- Deciding whether to implement a new process or remove an existing one.
In: Team feedback · Out: Efficient team processes
ch19
Step 3Maintain team focus on key priorities.
Entry: The team is facing shifting priorities or distractions.
Exit: The team remains focused on its key priorities.
- Deciding whether to accept a change in priorities.
In: Management input, Stakeholder requests · Out: A consistently prioritized team focus
ch19
Step 4Maintain a service catalog to track team-owned services.
Entry: The number of services owned by teams is growing.
Exit: A comprehensive and up-to-date service catalog is in place.
In: Information about team services · Out: A central service catalog
ch23
Assessing and Improving Team Health
To evaluate team dynamics, identify areas for improvement, and take action to foster a healthy, inclusive, and high-performing team environment.
When to use: Periodically as a health check, or when team dynamics feel unhealthy or unproductive.
Step 1Assess team health by observing interactions and gathering feedback.
Entry: A need to understand the current state of team dynamics.
Exit: A clear understanding of the team's strengths and areas for improvement is achieved.
In: Observations of team behavior, Feedback from team members · Out: A list of positive traits and areas for improvement
ch20
Step 2Take proactive measures to improve team dynamics.
Entry: Specific areas for improvement have been identified.
Exit: Team interactions and morale are improved.
- Deciding whether to address an issue directly or escalate it to management.
In: Identified team issues · Out: Improved team dynamics
ch20
Step 3Build strong relationships with other teams.
Entry: The team has dependencies on or interacts with other teams.
Exit: Stronger inter-team relationships are established.
Out: Improved cross-team collaboration
ch20
Thriving in Different Environments
To adapt one's working style and priorities to succeed in different types of teams and company operating modes (peacetime vs. wartime).
When to use: When joining a new team or when the company's operating mode shifts.
Step 1Adapt to working in platform teams by building empathy for customers.
Entry: Working on a platform team.
Exit: Improved platform usability and strong relationships with internal customers.
Out: Enhanced platform offerings
ch05
Step 2Thrive in 'wartime' mode by focusing on speed and execution.
Entry: The company is in a high-urgency, competitive mode.
Exit: Critical projects are completed under pressure.
- Determining which projects to prioritize based on immediate business needs.
In: Awareness of company status · Out: Completed high-priority projects
ch05
Step 3Thrive in 'peacetime' mode by focusing on quality and long-term goals.
Entry: The company is in a stable, growth-focused mode.
Exit: High-quality, long-term projects are achieved.
- Choosing the right long-term projects to invest in.
In: Clear long-term goals · Out: Strong interdepartmental relationships
ch05
The story
The reader A software engineer—from entry-level developer to aspiring staff/principal—who wants to grow professionally, increase their impact, and navigate their career with confidence.
External problem
They lack clear guidance on what's expected at each level and how to get things done, get promoted, ship reliably, and collaborate effectively across different company environments.
Internal problem
They feel overlooked, uncertain, and anxious—working hard but unsure if it will translate into recognition, growth, or promotion.
Philosophical problem
It's wrong that talented engineers stall or burn out simply because no one told them how the career and craft actually work, and because they were taught to wait for recognition that never comes.
The plan
- Understand career fundamentals: company types, tiers, paths, and owning your career.
- Master the craft of a competent developer: getting things done, coding, software development, and tools.
- Grow into a well-rounded senior engineer: collaboration, software engineering, testing, and architecture.
- Lead pragmatically as a tech lead: project management, shipping to production, stakeholders, and team dynamics.
- Operate as a role-model staff/principal engineer: understand the business, build reliable systems, and shape architecture.
- Commit to lifelong learning and keep up with the industry.
Success
- You are seen as someone who reliably gets impactful things done, and your work is recognized.
- You progress through levels with clarity, achieving fair performance reviews and well-earned promotions.
- You ship maintainable, reliable software and lead projects and teams effectively.
- You build a strong network, mentor others, and shape pragmatic architecture aligned with the business.
- You enjoy a sustainable, decades-long career while continually learning and avoiding burnout.
At stake
- You stagnate at a level, passed over for promotion with no actionable feedback.
- Your good work goes unnoticed and you feel undervalued and frustrated.
- You ship fragile software, struggle to collaborate, and become a bottleneck or 'jargon architect'.
- You burn out from poor pacing, noisy oncall, and chasing titles at the expense of fulfillment.
- You miss opportunities and limit your career by failing to understand the business or own your trajectory.
Chapter by chapter
ch01Career Paths
This chapter explores the diverse career paths available to software engineers and the varying types of companies they can work for, addressing how these environments influence career development, compensation, and work-life balance.
- There’s no single “good” career path in software engineering; opportunities and experiences are highly individualized.
- Understanding company types and career paths is crucial for making informed career decisions in the fast-paced tech landscape.
- Compensation can vary significantly by company tier, and education on these differences can empower better negotiations.
- Both profit centers and cost centers have their place in a balanced workforce; each offers unique challenges and advantages.
ch02Owning Your Career
This chapter emphasizes the necessity for software engineers to take personal responsibility for their career advancement, underscoring that proactive initiative beats passive waiting for managerial guidance.
- Proactive ownership of your career is imperative; waiting for management to lead is not a sustainable strategy for growth.
- The perception that 'nobody cares about your career as much as you do' emphasizes the importance of self-advocacy in achieving professional goals.
- Documenting your work and accomplishments in a 'work log' is a powerful method to elevate your visibility during performance evaluations and career discussions.
- Engaging in meaningful feedback exchanges—both giving and receiving—can enhance professional growth and foster stronger workplace relationships.
ch03Performance Reviews
Performance reviews often induce stress and anxiety, yet with proactive preparation and strategic goal-setting, professionals can significantly enhance their outcomes.
- Early preparation is essential; understanding your workplace context significantly enhances your review outcomes.
- A proactive approach—recording achievements and soliciting feedback—can mitigate the risks posed by performance review biases.
- Managers are typically not mind readers; be explicit about your accomplishments and seek clarity on their expectations.
- Document your contributions throughout the year to counteract common biases and present a holistic view during evaluations.
ch04Promotions
In technology organizations, the promotion process is shaped by clear expectations, internal politics, and the interplay of business needs and employee performance; understanding these factors is vital for engineers seeking advancement.
- Promotions in tech organizations hinge not only on performance but also on visibility, internal politics, and support from decision-makers.
- Becoming familiar with the promotion process—both formal and informal—is critical for any software engineer aspiring to ascend the career ladder.
- The concept of 'terminal levels' highlights that reaching a senior-level position does not guarantee further promotions, emphasizing its importance in career planning.
- Prominent companies have faced scrutiny over their promotion processes, reflecting broader industry trends impacting engineers’ career trajectories.
ch05Thriving In Different Environments
In today's diverse corporate landscapes, finding success hinges on understanding and adapting to specific environments, whether in high-paced startups or established tech giants.
ch06Switching Jobs
Navigating career transitions in the tech industry is complex, as software engineers must weigh the merits of switching jobs against waiting for internal promotions, all while considering their long-term professional development and market value.
ch07Getting Things Done
This chapter details key strategies for software developers to enhance their effectiveness and reputation by reliably completing critical tasks, overcoming obstacles, and taking initiative.
ch08Coding
This chapter emphasizes the importance of mastering coding skills through practice, writing readable code, and producing quality software while navigating the complexities of code reviews and error handling.
- Daily coding practice is essential for developing proficiency; consistent effort leads to substantial improvement over time.
- Readability in code is as critical as correctness, as it significantly impacts future maintenance and collaboration.
- Constructive feedback through code reviews accelerates learning and helps cultivate good coding habits.
- Engaging in reading others' code broadens a developer's perspective and exposes them to diverse techniques and standards.
ch09Software Development
This chapter articulates the essential skills and practices necessary for becoming a respected and competent software developer, emphasizing proficiency in programming languages, efficient debugging, rigorous refactoring, and comprehensive testing.
ch10Tools Of The Productive Developer
This chapter emphasizes the essential tools and practices that software developers must master to enhance their productivity and effectiveness in coding and project management.
- Mastery of development tools significantly enhances coding speed and efficiency, supporting rapid iterations.
- Continuous learning and proactive engagement with one's tools are essential for development success in software engineering.
- A well-structured IDE environment can transform a developer's workflow and comfort with coding tasks.
- Regularly practicing command-line tasks builds the foundational skill set needed to drive efficiency in various scenarios.
ch11Getting Things Done
Senior software engineers must navigate complex workloads and communication challenges to be perceived as effective, while understanding that the distinction between getting things done and being perceived as someone who gets things done involves both technical ability and proactive communication.
- Visibility and recognition in engineering roles are often based more on effective communication than on sheer productivity.
- Under-promising and over-delivering creates a reputation of reliability and thoughtful commitment.
- Clear, concise updates that outline project complexities can greatly enhance managerial perception of an engineer’s true productivity.
- Prioritizing workload with frameworks such as the “urgent/important” matrix ensures focus on critical tasks and effective delegation of less urgent responsibilities.
ch12Collaboration And Teamwork
Successful collaboration in software engineering hinges on effective practices like code reviews, pair programming, and cross-team interactions, which are critical for a senior engineer's development and team dynamics.
ch13Software Engineering
Effective software engineering transcends mere coding; it hinges on long-term maintainability and adaptability through expertise in languages, debugging, tech debt management, documentation, and scaling best practices.
- Senior engineering is defined by a multidisciplinary approach; mastery across various programming languages and platforms is crucial for holistic problem resolution.
- Effective debugging separates seasoned engineers from novices; practice and familiarity with production environments enhance response times in critical situations.
- Tech debt is a natural byproduct of software development; understanding its phases can empower engineers to manage it strategically rather than reactively.
- Documentation is a high-leverage practice that can fundamentally reduce tech debt by providing essential clarity to both current engineers and future team members.
ch14Testing
In the realm of software engineering, effective testing is not merely an optional extra; it is essential for ensuring functionality and quality. This chapter interrogates the diverse methodologies for testing software and emphasizes the critical impact these practices can have on development efficiency and product reliability.
ch15Software Architecture
This chapter explores the crucial early decisions in software architecture that shape a system's ease of development, maintenance, and adaptability, emphasizing prototyping and domain-driven design as essential practices.
- Early architectural decisions significantly shape a software project's ease of maintenance and adaptability; using structured approaches like RFCs can mitigate future complexities.
- Prototyping is an essential tool for exploring unknowns, allowing teams to address conflicts early without lengthy planning processes.
- Domain-Driven Design fosters clearer communication and alignment between technical teams and business stakeholders, reducing misunderstandings.
- Successful architecture requires effective stakeholder buy-in, which can often be achieved through thoughtful proposals and transparent communication.
ch16Project Management
This chapter explores how engineers, even those without senior titles, can effectively lead projects in tech environments, emphasizing the importance of project management as a critical skill for career advancement.
ch17Shipping To Production
This chapter explores the critical balance between speed and reliability in shipping software to production, detailing strategies from rapid, risky deployments to thorough, multi-layered verification processes.
- Every organization should carefully consider their deployment strategy based on product maturity, customer impact, and regulatory environment.
- The balance between speed and safety in deployment practices is vital; each organization must define its own risk thresholds.
- Thorough verification protocols are essential for mature products where customer trust is paramount.
- Agile teams must not only prioritize speed but also implement robust monitoring and feedback mechanisms for post-deployment evaluations.
ch18Stakeholder Management
Effective stakeholder management is critical for project success, as it aligns diverse interests and prevents misunderstandings that can derail efforts at critical junctures.
- The success of a project is fundamentally linked to effective stakeholder identification and management.
- Engage stakeholders early to prevent last-minute changes that can derail project timelines.
- Utilize a systematic categorization of stakeholders to tailor communication methods appropriately.
- Prioritize face-to-face communication, particularly with problem stakeholders, to build trust and facilitate collaboration.
ch19Team Structure
This chapter examines how tech leads can effectively structure their teams by clarifying roles, optimizing processes, and maintaining focus, ultimately driving better team dynamics and productivity.
ch20Team Dynamics
This chapter explores how tech leads can positively influence team dynamics to foster a healthy, high-performing environment by addressing both explicit and subtle challenges within the team.
ch21Understanding The Business
To thrive as a staff+ engineer, one must not only execute technical tasks but also grasp the fundamental dynamics of the business, including key metrics, product value, and market positioning.
- Understanding the business is paramount for staff+ engineers looking to thrive in their roles; it empowers them to make significant contributions aligned with company goals.
- North Stars, KPIs, and OKRs should be viewed as practical tools for engineers to connect their work with larger business objectives.
- Engaging with customers and understanding their needs can transform engineers into proactive problem-finders, not just problem-solvers.
- Establishing relationships with product and business teams can offer engineers valuable insights that enhance cross-functional collaboration.
ch22Collaboration
This chapter confronts the complexities of collaboration in engineering, arguing that success in this realm often hinges on navigating internal politics and influencing others effectively.
ch23Software Engineering
This chapter outlines the multifaceted role of a staff+ engineer, emphasizing the balance between hands-on coding and advancing engineering practices across teams to boost efficiency and quality.
- Staff+ engineers must allocate coding time judiciously, recognizing that their leadership responsibilities often demand time away from direct coding.
- Pair programming should be embraced as a crucial opportunity for mentorship and team skill enhancement, not merely a coding exercise.
- Establishing a shared 'Definition of Done' can significantly improve a team's output quality and cohesiveness.
- Automated testing remains a non-negotiable aspect of effective software engineering practice, providing essential quality assurance during deployments.
ch24Reliable Software Systems
In this chapter, staff+ engineers are urged to take ownership of system reliability through structured practices such as logging, monitoring, alerting, and incident management, emphasizing that effective reliability hinges on collaboration with engineering managers and teams.
- Staff+ engineers must embrace ownership of system reliability to ensure effective performance across their teams.
- Effective logging and monitoring frameworks are foundational for diagnosing and improving system reliability.
- Percentiles, rather than averages, offer critical insights into user experiences and potential bottlenecks in system performance.
- A structured alerting process mitigates alert fatigue and empowers on-call engineers to focus on critical issues.
ch25Software Architecture
This chapter emphasizes the critical role software architecture plays for staff+ engineers, detailing essential practices while warning against common pitfalls related to architecture debt, decision-making, and the integration of business priorities.
- Effective software architecture is integral to building reliable, maintainable systems that scale alongside evolving business needs.
- Simplifying architecture discussions increases engagement, inclusivity, and the potential for collaborative input from team members.
- Architecture debt accumulates when decisions are made for immediate speed without regard for long-term systemic health.
- Recognizing one-way door versus two-way door decisions helps engineers manage risk by ensuring that impactful choices receive thorough consideration.
ch26Lifelong Learning
The best software engineers distinguish themselves through a commitment to lifelong learning, consistently embracing new technologies and approaches to stay relevant and effective in their roles.
- Continuous learning is vital to staying relevant as a software engineer; it is an expectation in a rapidly evolving field.
- Asking questions and maintaining curiosity leads to a deeper understanding of projects and greater value creation.
- Pairing with others is not just a problem-solving method, but also an effective learning strategy that enhances collaboration.
- Exploring mentorship can facilitate mutual growth; both mentors and mentees stand to gain from shared knowledge and experience.
ch27Further Reading
This chapter provides valuable resources to extend the reader’s knowledge beyond the book, offering insights into contemporary trends in software engineering through recommended literature and ongoing publications.
- Continuous learning is essential for software engineers to adapt to the rapidly changing landscape of the industry.
- Engaging with real-time resources such as newsletters can bridge the gap between the theoretical knowledge found in books and the dynamic environment of modern software engineering.
- Foundational understanding of software systems and team dynamics plays a crucial role in ensuring long-term success, even as specific technologies evolve.
- Curating a personal library of both contemporary resources and enduring texts is a proactive strategy to ensure professional relevance and growth.
Questions this book answers
- What does it take to grow from entry-level developer to staff/principal engineer?
- How do performance reviews and promotions really work, and how can you influence the outcome?
- What distinguishes a competent developer, a senior engineer, a tech lead, and a staff+ engineer?
- How do you get things done reliably, unblock yourself, and ship to production safely?
- How do you collaborate, mentor, influence others, and manage stakeholders effectively?
Glossary
- Career Ownership Behaviors
- The proactive stance an engineer takes toward their own professional development, treating their career as their responsibility rather than their manager's.
- Work Visibility and Communication
- The degree to which an engineer's accomplishments, challenges, and impact are known and understood by managers, peers, and stakeholders.
- Getting Things Done Effectively
- An engineer's capacity to reliably deliver impactful, properly-completed work by focusing on priorities, unblocking themselves, breaking down and estimating work, and taking initiative.
- Engineering Craft Proficiency
- The depth and breadth of an engineer's technical skill in coding, languages, frameworks, debugging, refactoring, and use of productive tools.
- Healthy Engineering Practices
- The adoption of proven processes and techniques—testing, code reviews, CI/CD, documentation, planning, and safe shipping—that improve software quality, maintainability, and iteration speed.
- Collaboration and Teamwork Quality
- The effectiveness with which an engineer works with others through reviews, pairing, mentoring, feedback, cross-team work, and stakeholder management.
- Business and Product Understanding
- An engineer's comprehension of how the company makes money, customer needs, key metrics (North Stars, KPIs, OKRs), profit/cost centers, and industry dynamics.
- Reputation as Reliable Engineer
- The shared perception among managers and peers that an engineer consistently delivers impactful, properly-done work, unblocks themselves, and communicates well.
Related in the library
- A Philosophy of Software Design (2nd Edition)shared: Systems
- Accelerate The Science of DevOpsshared: Systems
- Analytics Engineering with SQL and dbt Building Meaningful Data Models at Scaleshared: Systems
- Architecture Patterns with Pythonshared: Systems
- Artificial Intelligence - A Very Short Introductionshared: Systems
- Big Data_ A Very Short Introduction (Very Short Introductions)shared: Systems
Tools these methods power