First 90 Days at New Job from Scratch (2026)
The first 90 days at a new job set the trajectory for your entire tenure. During this period, you build your reputation, establish relationships, learn the codebase, and demonstrate what kind of engineer you are. A strong start creates trust and autonomy that compound over years. A weak start creates skepticism and constraints that take months to overcome.
This guide covers a systematic approach to the first 90 days: how to onboard effectively, identify quick wins, build relationships, understand the political landscape, and set yourself up for long-term success. The framework is organized by phase: absorb, contribute, and lead.
Phase 1: Absorb (Days 1-30)
The first 30 days are for learning, not producing. Your goal is to understand the codebase, the team, the product, and the processes. Set up your development environment. Read through the codebase architecture. Set up the project locally and run the tests. Read through recent PRs to understand code style and review practices. Go through the documentation and READMEs. Identify the key components and how they interact.
Schedule 30-minute coffee chats with every team member. Ask: What does the team own? What is the most complex part of the system? What is the biggest challenge right now? What advice do you have for someone new? Take notes. Follow up with thank-you messages. These conversations build relationships and give you the context you need to be effective. By day 30, you should understand the system architecture, the team dynamics, and where you can add value.
const phase1 = {
goals: ['Understand codebase architecture', 'Build relationships with team', 'Set up dev environment', 'Learn team processes'],
dailyPractices: [
'Read 2-3 PRs to understand code style',
'Write notes on what you learn each day',
'Ask questions in team channels (no stupid questions)',
'Run the full test suite',
],
week1CoffeeChats: ['Manager', 'Tech lead', 'Senior engineer', 'Product manager'],
week2CoffeeChats: ['Rest of team', 'Adjacent teams', 'Designer', 'QA engineer'],
byDay30: 'Can explain the system architecture to another engineer'
};Phase 2: Contribute (Days 31-60)
By day 30, you have enough context to start contributing meaningfully. Start with small, well-defined tasks to build momentum: bug fixes, documentation improvements, test additions, small features. These build confidence and demonstrate reliability. The goal is to ship something visible and useful within your first 60 days. A quick win builds trust with your manager and team.
Pair with a senior engineer on a feature to learn while contributing. Volunteer for tasks that others do not want — documentation, refactoring, test improvements. These are high-visibility contributions that build goodwill. By day 60, you should have shipped at least one meaningful change independently and established a reputation as someone who delivers. The specific contribution matters less than the pattern of shipping reliably.
const phase2 = {
weeks5to6: 'Bug fixes, documentation, small features — build momentum',
weeks7to8: 'Ship one meaningful feature independently — establish reliability',
quickWinIdeas: [
'Fix a longstanding documentation gap',
'Add test coverage to a critical module',
'Automate a manual process',
'Improve CI pipeline speed',
],
strategy: 'Start small, ship fast, build trust, then take on larger challenges'
};
function findQuickWins(team) {
const complaints = team.map(m => m.painPoints).flat();
const unique = [...new Set(complaints)];
return unique.filter(p => {
return p.effortToFix < 3 && p.visibility > 7; // quick, visible wins
});
}Phase 3: Lead (Days 61-90)
By day 60, you have context and credibility. Now you can start leading: proposing improvements, identifying technical debt, suggesting process changes, and taking ownership of larger features. The shift is from executing assigned tasks to identifying what needs to be done and doing it without being asked. This is where you move from new hire to trusted team member.
Write a short document with your observations and suggestions: what the team does well, what could improve, and your proposed priorities for the next quarter. Share it with your manager and tech lead. This demonstrates strategic thinking and initiative. By day 90, you should be seen as a contributing member of the team who understands the system well enough to make independent decisions and influence direction.
const phase3 = {
weeks9to10: 'Identify improvement opportunities and propose changes',
weeks11to12: 'Take ownership of a significant feature or initiative',
observationDoc: {
whatWorksWell: ['Strong code review culture', 'Good test coverage', 'Supportive team'],
whatCouldImprove: ['CI pipeline is slow', 'API docs are outdated', 'On-call rotation needs automation'],
proposedPriorities: ['Speed up CI', 'Automate on-call handoff', 'Document API patterns']
},
byDay90: 'Seen as contributing team member with independent decision-making ability'
};
function writeOnboardingRetro(observations) {
const ret = observations.map(o => `## ${o.category}\n**Good:** ${o.good}\n**Improve:** ${o.improve}\n**Proposal:** ${o.proposal}`);
return ret.join('\n\n');
}Building Relationships Across the Organization
Your team is your primary community, but your success also depends on relationships outside your team. In the first 90 days, build relationships with: your skip-level manager, product managers, designers, QA engineers, DevOps/infrastructure team, and customer support. Each group has a different perspective on what the team does well and where it struggles. Understanding these perspectives makes you more effective.
For each relationship, follow the same pattern: schedule a 30-minute chat, ask about their work and challenges, share what you are working on, and ask how you can support them. Follow up with a thank-you and occasional check-ins. These cross-functional relationships are what enable you to influence beyond your team and accelerate your path to senior and staff roles.
const relationshipBuilding = {
crossFunctionalChats: [
'Skip-level manager',
'Product manager',
'Designer',
'QA engineer',
'DevOps engineer',
'Customer support lead',
'Data analyst',
],
questions: [
'What does your team work on?',
'What is the biggest challenge you face?',
'How can our team better support you?',
'What should I know about how our teams interact?',
],
followUp: 'Connect on LinkedIn. Check in quarterly. Share relevant resources.'
};
function scheduleRelationshipChats(yearPlan) {
return yearPlan.firstQuarter.map(person => ({
with: person,
week: 'Week 2-4',
duration: '30 min',
goal: 'Understand their work and find collaboration opportunities'
}));
}Navigating Office Politics as a New Hire
Office politics exists at every company, and ignoring it is a mistake. Politics is just the informal power dynamics that influence decisions. As a new hire, your strategy is: observe before acting. Identify who the informal leaders are (the people whose opinions shape decisions), understand the team's history (past conflicts, failed initiatives, sacred cows), and learn who makes which decisions. Do not take sides in ongoing conflicts until you fully understand the dynamics.
The safest political strategy for a new hire is to be helpful, reliable, and positive. Build relationships with everyone, not just the most powerful people. Share credit generously. Avoid gossip. When you see a political situation, ask neutral questions to understand it before forming opinions. By being known as competent and trustworthy, you build political capital that protects you when you eventually need to navigate a difficult situation.
const politicalNavigator = {
observe: 'First 30 days — identify decision-makers, informal leaders, team history',
principles: [
'Be helpful and reliable above all',
'Build relationships with everyone, not just powerful people',
'Share credit generously',
'Avoid gossip and taking sides',
'Be positive and constructive in public forums',
],
redFlags: [
'Team members speak negatively about each other',
'Decisions are made outside of meetings',
'Information is hoarded as power',
'Past initiatives are mentioned with bitterness',
]
};Common First-90-Day Mistakes to Avoid
Six common mistakes new hires make: trying to change everything immediately (you do not have enough context yet), staying isolated and not building relationships, working too hard to prove yourself and burning out, not asking enough questions (assumption is the enemy of onboarding), criticizing the existing system before understanding why it was built that way, and over-committing to deliverables before you understand the complexity.
The antidote is humility and curiosity. Assume the existing system makes sense given the constraints that were present when it was built. Ask why before suggesting what to change. Build relationships before proposing changes. Pace yourself — a marathon, not a sprint. The best first 90 days look boring from the outside: lots of reading, asking questions, and small contributions. The compound effect of a strong foundation pays off in years 2 and 3.
const commonMistakes = {
changingEverything: 'You lack context. Observe first, suggest changes after day 60.',
stayingIsolated: 'Schedule coffee chats. Be visible in team channels. Ask questions publicly.',
overworking: 'Pace yourself. Sustainable output beats heroic sprints. Burnout helps no one.',
notAskingQuestions: 'Ask early and often. The window for basic questions closes after day 30.',
criticizingLegacy: 'The existing system made sense given the constraints. Understand before judging.',
overCommitting: 'Under-promise and over-deliver in the first 90 days. Build a reputation for reliability.'
};
function first90DaysAdvice(companySize) {
const advice = {
startup: 'Wear many hats. Ship fast. Ask forgiveness, not permission.',
midSize: 'Build cross-team relationships. Follow processes. Find quick wins.',
large: 'Learn the processes. Build network. Find a mentor. Be patient with bureaucracy.'
};
return advice[companySize];
}Frequently Asked Questions
How many meetings should I schedule in the first week?
Schedule 2-3 coffee chats per day. The first week is about building relationships. Each chat should be 30 minutes. Spread them out to avoid meeting fatigue. Between chats, focus on setting up your environment and reading code.
What if I am not productive in the first month?
That is normal and expected. Productivity in the first 30 days is measured by learning, not output. Your manager should expect a ramp-up period. The key is showing progress: each week you should understand more than the previous week.
How do I know if my onboarding is going well?
Signals of good onboarding: you are getting increasingly complex tasks, teammates are coming to you with questions, you are unblocked quickly when stuck, and you feel more confident each week. If you feel more confused after 4 weeks than after 1 week, talk to your manager.
Originally published on Ayodhyyya. Last updated June 1, 2026.